Translate

domingo, 7 de enero de 2024

Visibilidad en Rust


Los módulos permiten definir la visibilidad :

  • Los elementos del módulo son privados por defecto (oculta los detalles de implementación).
  • Los elementos de padres y hermanos siempre están visibles.
  • En otras palabras, si un elemento es visible en el módulo foo, será visible en todos los descendientes de foo.


mod outer {

    fn private() {

        println!("outer::private");

    }


    pub fn public() {

        println!("outer::public");

    }


    mod inner {

        fn private() {

            println!("outer::inner::private");

        }


        pub fn public() {

            println!("outer::inner::public");

            super::private();

        }

    }

}


fn main() {

    outer::public();

}


Podemos utilizar la palabra clave pub para hacer públicos los módulos. Además, existen especificadores pub(...) avanzados para restringir el alcance de la visibilidad pública.


Jerarquía de archivos en Rust

mod garden;

Esto le indica a Rust que el contenido del módulo garden se encuentra en src/garden.rs. De manera similar, se puede definir un módulo garden::vegetables que va estar en src/garden/vegetables.rs.

Los módulos definidos en archivos también se pueden documentar mediante "comentarios internos del documento". Estos documentan el elemento que los contiene, por ejemplo: 


//! This module implements the garden, including a highly performant germination

//! implementation.


// Re-export types from this module.

pub use garden::Garden;

pub use seeds::SeedPacket;


/// Sow the given seed packets.

pub fn sow(seeds: Vec<SeedPacket>) {

    todo!()

}


/// Harvest the produce in the garden that is ready.

pub fn harvest(garden: &mut Garden) {

    todo!()

}


Antes de Rust 2018, los módulos debían estar ubicados en module/mod.rs en lugar de un archivo y esta sigue siendo una alternativa funcional para las ediciones posteriores a 2018.

La razón principal para introducir filename.rs como alternativa a filename/mod.rs fue porque muchos archivos llamados mod.rs pueden ser difíciles de distinguir en los IDE.

Un anidamiento más profundo puede utilizar carpetas, incluso si el módulo principal es un archivo:

src/

├── main.rs

├── top_module.rs

└── top_module/

    └── sub_module.rs


El lugar donde Rust buscará los módulos se puede cambiar con una directiva del compilador:

#[path = "some/path.rs"]
mod some_module;

Esto es útil, por ejemplo, si desea colocar pruebas para un módulo en un archivo llamado some_module_test.rs, similar a la convención en Go.


miércoles, 3 de enero de 2024

Modulos en Rust


Hemos visto cómo los bloques impl nos permiten asignar funciones de espacio de nombres a un tipo.

De manera similar, mod nos permite tipos de espacios de nombres y funciones:


mod foo {

    pub fn do_something() {

        println!("In the foo module");

    }

}


mod bar {

    pub fn do_something() {

        println!("In the bar module");

    }

}


fn main() {

    foo::do_something();

    bar::do_something();

}


Los paquetes brindan funcionalidad e incluyen un archivo Cargo.toml que describe cómo crear un paquete de más de 1 caja.

Las cajas son un árbol de módulos, donde una caja binaria crea un ejecutable y/o una caja de biblioteca se compila en una biblioteca.

Los módulos definen la organización, el alcance de los proyectos. 

martes, 2 de enero de 2024

FromIterator en Rust


FromIterator te permite crear una colección a partir de un Iterator.


fn main() {

    let primes = vec![2, 3, 5, 7];

    let prime_squares = primes.into_iter().map(|p| p * p).collect::<Vec<_>>();

    println!("prime_squares: {prime_squares:?}");

}


Iterator iteradores:


fn collect<B>(self) -> B

where

    B: FromIterator<Self::Item>,

    Self: Sized


Hay dos formas de especificar B para este método:

  • Con el “turbofish”: some_iterator.collect::<COLLECTION_TYPE>(), como se muestra. La abreviatura _ utilizada aquí le permite a Rust inferir el tipo de elementos Vec.
  • Con inferencia de tipos: let prime_squares: Vec<_> = some_iterator.collect(). Vuelva a escribir el ejemplo para utilizar este formulario.

Hay implementaciones básicas de FromIterator para Vec, HashMap, etc. También hay implementaciones más especializadas que le permiten hacer cosas interesantes como convertir un Iterator<Item = Result<V, E>> en un Result<Vec<V>, E> .

sábado, 30 de diciembre de 2023

Feliz Navidad y buen año para todos!!


Como todos los años les deseo una feliz navidad y un buen 2024. 

Gracias por leerme! 

viernes, 29 de diciembre de 2023

IntoIterator en Rust


El trait Iterator le indica cómo iterar una vez que haya creado un iterador. El trait relacionado IntoIterator define cómo crear un iterador para un tipo. Es utilizado automáticamente por el bucle for.


struct Grid {

    x_coords: Vec<u32>,

    y_coords: Vec<u32>,

}


impl IntoIterator for Grid {

    type Item = (u32, u32);

    type IntoIter = GridIter;

    fn into_iter(self) -> GridIter {

        GridIter { grid: self, i: 0, j: 0 }

    }

}


struct GridIter {

    grid: Grid,

    i: usize,

    j: usize,

}


impl Iterator for GridIter {

    type Item = (u32, u32);


    fn next(&mut self) -> Option<(u32, u32)> {

        if self.i >= self.grid.x_coords.len() {

            self.i = 0;

            self.j += 1;

            if self.j >= self.grid.y_coords.len() {

                return None;

            }

        }

        let res = Some((self.grid.x_coords[self.i], self.grid.y_coords[self.j]));

        self.i += 1;

        res

    }

}


fn main() {

    let grid = Grid {

        x_coords: vec![3, 5, 7, 9],

        y_coords: vec![10, 20, 30, 40],

    };

    for (x, y) in grid {

        println!("point = {x}, {y}");

    }

}


Cada implementación de IntoIterator debe declarar dos tipos:

  • Item: el tipo sobre el que se va a iterar, como i8,
  • IntoIter: el tipo de Iterator devuelto por el método into_iter.

Tenga en cuenta que IntoIter y Item están vinculados: el iterador debe tener el mismo tipo de elemento, lo que significa que devuelve Option<Item>

El ejemplo itera sobre todas las combinaciones de coordenadas x e y.


domingo, 24 de diciembre de 2023

Iterator en Rust


El trait Iterator admite la iteración sobre valores en una colección. Requiere un método next y proporciona muchos métodos. Muchos tipos de bibliotecas estándar implementan Iterator y usted también puede implementarlo usted mismo:


struct Fibonacci {

    curr: u32,

    next: u32,

}


impl Iterator for Fibonacci {

    type Item = u32;


    fn next(&mut self) -> Option<Self::Item> {

        let new_next = self.curr + self.next;

        self.curr = self.next;

        self.next = new_next;

        Some(self.curr)

    }

}


fn main() {

    let fib = Fibonacci { curr: 0, next: 1 };

    for (i, n) in fib.enumerate().take(5) {

        println!("fib({i}): {n}");

    }

}


Iterator implementa muchas operaciones de programación funcional comunes sobre colecciones (por ejemplo, mapear, filtrar, reducir, etc.). Este es el rasgo donde puedes encontrar toda la documentación sobre ellos. En Rust, estas funciones deberían producir un código tan eficiente como las implementaciones imperativas equivalentes.

sábado, 23 de diciembre de 2023

Invertir una lista en prolog


Si queremos invertir una lista en prolog lo que podemos hacer es utilizar el predicado union del post anterior y hacer lo siguiente : 


inversa([], []).

inversa([H|T], L) :-

    inversa(T, IT),

    union(IT, [H], L).


Lo probamos : 


inversa([1,2,3,4], X)

X = [4, 3, 2, 1]

Introducción a gRPC


gRPC es un sistema de llamadas a procedimientos remotos (RPC) de código abierto desarrollado por Google. Se basa en el protocolo HTTP/2 para la comunicación entre servicios, lo que ofrece una comunicación eficiente y de bajo consumo de recursos.

Características Principales:

  • Protocolo basado en HTTP/2: Utiliza HTTP/2 como su protocolo subyacente, lo que proporciona una comunicación más rápida, eficiente y multiplexada.
  • IDL y generación de código: Utiliza Protocol Buffers (protobuf) para definir la estructura del servicio y los mensajes intercambiados entre los clientes y servidores. Esto permite la generación automática de código en varios lenguajes.
  • Soporte para múltiples lenguajes: Ofrece soporte para una variedad de lenguajes de programación, lo que permite a los desarrolladores construir servicios heterogéneos y sistemas distribuidos.
  • Tipado fuerte y serialización eficiente: Utiliza Protocol Buffers para la serialización de datos, lo que resulta en una comunicación más rápida y eficiente que otros métodos de serialización.

Ventajas:

  • Alta eficiencia y rendimiento en la comunicación entre microservicios.
  • Facilita la creación de servicios interoperables en diferentes lenguajes.
  • Útil en entornos distribuidos, como arquitecturas de microservicios, Internet de las cosas (IoT) y sistemas basados en la nube.


Veamos un ejemplo de un protobuf:

syntax = "proto3";


service Greeter {

  rpc SayHello (HelloRequest) returns (HelloResponse) {}

}


message HelloRequest {

  string name = 1;

}


message HelloResponse {

  string message = 1;

}



gRPC ofrece una forma eficiente y poderosa de comunicación entre servicios, facilitando el desarrollo de aplicaciones distribuidas escalables y de alto rendimiento. Su capacidad para generar código y su enfoque en la eficiencia lo convierten en una herramienta valiosa para la construcción de sistemas modernos y distribuidos.

Tal vez te preguntas si esto va a sustituir a Rest y la respuesta es no, Rest proporciona una interfaz clara tanto para aplicaciones como para humanos para aplicaciones en cambio gRPC sacrifica la claridad de las apis en post de una mayor eficiencia. 

Si tenes que hacer una API que no interesa tanto la performance y es necesario que sea super clara para que todo el mundo la use, Rest es la mejor opción. Si es necesaria una comunicación rápida entre sistemas que tengo el control, gRPC viene bien. 

Dejo link: https://grpc.io/



viernes, 22 de diciembre de 2023

Unir dos listas en prolog


Vamos a hacer un predicado que una dos listas en prolog: 


unir([], Lista, Lista).

unir([X | Resto], Lista, [X | Resultado]) :-

   unir(Resto, Lista, Resultado).


Y lo vamos a probar : 

unir([5,6,7],[1,2,3,4], X)

X = [5, 6, 7, 1, 2, 3, 4]

jueves, 21 de diciembre de 2023

Maps en Go


Los maps son una estructura de datos que asocia valores de un tipo (la clave) con valores de otro tipo (el elemento o valor). La clave puede ser de cualquier tipo para el que esté definido el operador de igualdad, como números enteros, números de punto flotante y complejos, cadenas, punteros, interfaces (siempre que el tipo dinámico admita la igualdad), estructuras y matrices. Los slices no se pueden utilizar como claves de map porque la igualdad no está definida en ellos. Al igual que los slices, los map contienen referencias a una estructura de datos subyacente. Si pasa un map a una función que cambia el contenido del map, los cambios serán visibles en la persona que llama.

Los map se pueden construir utilizando la sintaxis literal compuesta habitual con pares clave-valor separados por dos puntos, por lo que es fácil construirlos durante la inicialización.0


var timeZone = map[string]int{

    "UTC":  0*60*60,

    "EST": -5*60*60,

    "CST": -6*60*60,

    "MST": -7*60*60,

    "PST": -8*60*60,

}


Asignar y recuperar valores de maps parece sintácticamente igual que hacer lo mismo con matrices y slices, excepto que no es necesario que el índice sea un número entero.


offset := timeZone["EST"]


Un intento de recuperar un valor de mapa con una clave que no está presente en el mapa devolverá el valor cero para el tipo de entradas en el mapa. Por ejemplo, si el mapa contiene números enteros, buscar una clave inexistente devolverá 0. Un conjunto se puede implementar como un mapa con valor de tipo bool. 

attended := map[string]bool{

    "Ann": true,

    "Joe": true,

    ...

}


if attended[person] { // will be false if person is not in the map

    fmt.Println(person, "was at the meeting")

}


A veces es necesario distinguir una entrada faltante de un valor cero. ¿Hay una entrada para "UTC" o es 0 porque no está en el mapa? Se puede discriminar con una forma de asignación múltiple.


var seconds int

var ok bool

seconds, ok = timeZone[tz]


Por razones obvias, esto se denomina modismo "coma ok". En este ejemplo, si tz está presente, los segundos se configurarán apropiadamente y ok será verdadero; de lo contrario, los segundos se establecerán en cero y ok será falso. Aquí hay una función que lo combina con un bonito informe de errores:


func offset(tz string) int {

    if seconds, ok := timeZone[tz]; ok {

        return seconds

    }

    log.Println("unknown time zone:", tz)

    return 0

}


Para probar la presencia en el mapa sin preocuparse por el valor real, puede utilizar el identificador en blanco (_) en lugar de la variable habitual para el valor.


_, present := timeZone[tz]


Para eliminar una entrada de mapa, utilice la función incorporada de eliminación, cuyos argumentos son el mapa y la clave que se va a eliminar. Es seguro hacer esto incluso si la clave ya no está en el mapa.


delete(timeZone, "PDT")  // Now on Standard Time


martes, 19 de diciembre de 2023

Predicado que nos indique si un elemento existe en una lista en prolog


Vamos a hacer un predicado que nos indique si un elemento existe en una lista en prolog: 


existe(Elemento, [Elemento | _]).

existe(Elemento, [_ | Tail]) :-

    existe(Elemento, Tail).


Si la probamos : 


existe(5,[1,2,3,4])

false

existe(4,[1,2,3,4])

true

lunes, 18 de diciembre de 2023

Contar elementos de una lista en prolog


Vamos a hacer un predicado que cuenten los elementos de una lista en prolog: 

count_elements([], 0).

count_elements([_ | Tail], Count) :-

    count_elements(Tail, TailCount),

    Count is TailCount + 1.

Contar valores que cumplan un criterio en Lisp

 


Función para contar valores de una lista en lisp según un criterio (que va a ser una función) : 

(defun contarSegun (lista fx) 

 (cond

     ((null lista) 0)

     ((funcall fx (first lista)) 

           (+ (contarSegun (rest lista) fx) 1))

     (T (contarSegun (rest lista) fx))

 )

)


Y vamos a probarla : 


> (contarSegun '(1 2 3 4 5 6) (lambda (a) (> a 3)))

3


> (contarSegun '(1 2 3 4 5 6) (lambda (a) (>= a 3)))

4


> (contarSegun '(1 2 3 4 5 6) (lambda (a) (= a 3)))

1


sábado, 16 de diciembre de 2023

Slices en Rust


Los Slices brindan una vista de una colección más grande, es como una porción:


fn main() {

    let mut a: [i32; 6] = [10, 20, 30, 40, 50, 60];

    println!("a: {a:?}");

    let s: &[i32] = &a[2..4];

    println!("s: {s:?}");

}


Los Slice toman prestados el tipo del arreglo.

Si el Slice comienza en el índice 0, la sintaxis de rango de Rust nos permite eliminar el índice inicial, lo que significa que &a[0..a.len()] y &a[..a.len()] son idénticos. Lo mismo ocurre con el último índice, por lo que &a[2..a.len()] y &a[2..] son idénticos. Por lo tanto, para crear fácilmente un  Slice de todo el vector, podemos usar &a[..].

El tipo de s (&[i32]) ya no menciona la longitud de la matriz. Esto nos permite realizar cálculos en sectores de diferentes tamaños.