Rust: Conversiones implícitas

Rust no aplicará automáticamente conversiones implícitas entre tipos (a diferencia de C++). Puedes ver esto en un programa como este:

fn multiply(x: i16, y: i16) -> i16 {

    x * y

}

fn main() {

    let x: i8 = 15;

    let y: i16 = 1000;

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

}

Si corremos este código: 

$ cargo run

   Compiling hello_cargo v0.1.0 

error[E0308]: mismatched types

 --> src/main.rs:9:41

  |

9 |     println!("{x} * {y} = {}", multiply(x, y));

  |                                -------- ^ expected `i16`, found `i8`

  |                                |

  |                                arguments to this function are incorrect

  |

note: function defined here

 --> src/main.rs:1:4

  |

1 | fn multiply(x: i16, y: i16) -> i16 {

  |    ^^^^^^^^ ------

help: you can convert an `i8` to an `i16`

  |

9 |     println!("{x} * {y} = {}", multiply(x.into(), y));

  |                                          +++++++

For more information about this error, try `rustc --explain E0308`.

error: could not compile `hello_cargo` due to previous error

Vamos a hacerle caso y vamos a correr : rustc --explain E0308

El tipo esperado no coincide con el tipo recibido.

Ejemplos de código erróneo:

``

fn plus_one(x: i32) -> i32 {

    x + 1

}

plus_one("Not a number");

//       ^^^^^^^^^^^^^^ expected `i32`, found `&str`

if "Not a bool" {

// ^^^^^^^^^^^^ expected `bool`, found `&str`

}

let x: f32 = "Not a float";

//     ---   ^^^^^^^^^^^^^ expected `f32`, found `&str`

//     |

//     expected due to this

```

Este error ocurre cuando se usó una expresión en un lugar donde el compilador esperaba una expresión de un tipo diferente. Puede ocurrir en varios casos, siendo el más común cuando se llama a una función y se pasa un argumento que tiene un tipo diferente al tipo coincidente en la declaración de la función.

Genial! no cambio el tipo de forma implicita. 

Todos los tipos enteros de Rust implementan las características From<T> e Into<T> para permitirnos convertir entre ellos. El rasgo From<T> tiene un solo método from() y, de manera similar, el rasgo Into<T> tiene un solo método into(). La implementación de estos rasgos es la forma en que un tipo expresa que se puede convertir en otro tipo.

La biblioteca estándar tiene una implementación de From<i8> para i16, lo que significa que podemos convertir una variable x de tipo i8 en i16 llamando a i16::from(x). O, más simple, con x.into(), porque From<i8> para la implementación de i16 crea automáticamente una implementación de Into<i16> para i8.

Lo mismo se aplica a sus propias implementaciones From para sus propios tipos, por lo que es suficiente implementar solo From para obtener una implementación Into respectiva automáticamente.

Por lo tanto si hacemos .into() este código va funcionar : 

fn multiply(x: i16, y: i16) -> i16 {

    x * y

}

fn main() {

    let x: i8 = 15;

    let y: i16 = 1000;

    println!("{x} * {y} = {}", multiply(x.into(), y));

}

$ cargo run

   Compiling hello_cargo v0.1.0 

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

     Running `target/debug/hello_cargo`

15 * 1000 = 15000

Sobrecarga de funciones

Rust no soporta la sobrecarga:

• Cada función tiene una sola implementación:
• Siempre toma un número fijo de parámetros.
• Siempre toma un único conjunto de tipos de parámetros.
• Los valores predeterminados no son compatibles:
• Todos los sitios de llamadas tienen el mismo número de argumentos.
• Las macros a veces se utilizan como alternativa.

Sin embargo, los parámetros de función pueden ser genéricos:

fn pick_one<T>(a: T, b: T) -> T {

    if std::process::id() % 2 == 0 { a } else { b }

}

fn main() {

    println!("coin toss: {}", pick_one("heads", "tails"));

    println!("cash prize: {}", pick_one(500, 1000));

}

Rustdoc

Todos los elementos de Lenguaje Rust se pueden documentar usando una sintaxis especial ///.

/// Determine whether the first argument is divisible by the second argument.

///

/// If the second argument is zero, the result is false.

fn is_divisible_by(lhs: u32, rhs: u32) -> bool {

    if rhs == 0 {

        return false;  // Corner case, early return

    }

    lhs % rhs == 0     // The last expression in a block is the return value

}

Los contenidos se tratan como Markdown. Las librerias de Rust se documentan automáticamente en docs.rs mediante la herramienta rustdoc. Es idiomático documentar todos los elementos públicos en una API utilizando este patrón.

Y para utilizarla podemos hacer : 

rustdoc src/main.rs 

Funciones en Rust

Una versión de Rust de la famosa pregunta de entrevista de FizzBuzz:

fn main() {

    print_fizzbuzz_to(20);

}

fn is_divisible(n: u32, divisor: u32) -> bool {

    if divisor == 0 {

        return false;

    }

    n % divisor == 0

}

fn fizzbuzz(n: u32) -> String {

    let fizz = if is_divisible(n, 3) { "fizz" } else { "" };

    let buzz = if is_divisible(n, 5) { "buzz" } else { "" };

    if fizz.is_empty() && buzz.is_empty() {

        return format!("{n}");

    }

    format!("{fizz}{buzz}")

}

fn print_fizzbuzz_to(n: u32) {

    for i in 1..=n {

        println!("{}", fizzbuzz(i));

    }

}

$ cargo run

   Compiling hello_cargo v0.1.0 

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

     Running `target/debug/hello_cargo`

1

2

fizz

4

buzz

fizz

7

8

fizz

buzz

11

fizz

13

14

fizzbuzz

16

17

fizz

19

buzz

Los parámetros de declaración son seguidos por un tipo (lo contrario de algunos lenguajes de programación), luego un tipo de retorno.

La última expresión en el cuerpo de una función (o cualquier bloque) se convierte en el valor devuelto. Y Simplemente se omite el ; al final de la expresión.

Algunas funciones no tienen valor de retorno y devuelven el 'tipo de unidad', (). El compilador inferirá esto si se omite el tipo de retorno -> ().

La expresión de rango en el ciclo for en print_fizzbuzz_to() contiene =n, lo que hace que incluya el límite superior.

Rust: String vs str

 

Dado este post, podemos entender los dos tipos de cadenas en Rust:

fn main() {

    let s1: &str = "World";

    println!("s1: {s1}");

    let mut s2: String = String::from("Hello ");

    println!("s2: {s2}");

    s2.push_str(s1);

    println!("s2: {s2}");

    

    let s3: &str = &s2[6..];

    println!("s3: {s3}");

}

$ cargo run

   Compiling hello_cargo v0.1.0 

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

     Running `target/debug/hello_cargo`

s1: World

s2: Hello 

s2: Hello World

s3: World

En Rust: 

• &str una referencia inmutable a un segmento de cadena.
• String de un búfer de cadena mutable.

&str introduce un segmento de cadena, que es una referencia inmutable a datos de cadena codificados en UTF-8 almacenados en un bloque de memoria. Los literales de cadena ("Hola") se almacenan en el binario del programa.

El tipo String de Rust es un contenedor alrededor de un vector de bytes. Al igual que con un Vec<T>, es propiedad.

Como ocurre con muchos otros tipos, String::from() crea una cadena a partir de un literal de cadena; String::new() crea una nueva cadena vacía, a la que se pueden agregar datos de cadena usando los métodos push() y push_str().

La macro format!() es una forma conveniente de generar una cadena propia a partir de valores dinámicos. Acepta la misma especificación de formato que println!().

Puede tomar prestados segmentos de &str de String a través de & y, opcionalmente, selección de rango.

Para programadores de C++: piense en &str como const char* de C++, pero el que siempre apunta a una cadena válida en la memoria. Rust String es un equivalente aproximado de std::string de C++ (diferencia principal: solo puede contener bytes codificados en UTF-8 y nunca utilizará una optimización de cadena pequeña).

Slices en Rust

Un segmento o slices te da una vista de una colección más grande:

 fn main() {

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

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

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

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

}

$ cargo run

   Compiling hello_cargo v0.1.0 

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

     Running `target/debug/hello_cargo`

a: [10, 20, 30, 40, 50, 60]

s: [30, 40]

Creamos un segmento a partir de un arreglo y especificando los índices inicial y final entre paréntesis.

Si el segmento comienza en el índice 0, la sintaxis de rango de Rust nos permite descartar 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.

Para crear fácilmente una porción de la matriz completa, podemos usar &a[..].

s es una referencia a una porción de i32s. Y el tipo de s es &[i32] y no menciona la longitud del vector. Esto nos permite realizar cálculos en rebanadas de diferentes tamaños.

Las rebanadas siempre toman prestado de otro objeto. En este ejemplo, a tiene que permanecer "vivo" durante al menos el mismo tiempo que nuestro segmento.

La pregunta sobre la modificación de a[3] puede generar una discusión interesante, pero la respuesta es que, por razones de seguridad de la memoria, no puede hacerlo a través de a después de crear un segmento, pero puede leer los datos de a y s de forma segura. 

Rust y Referencias colgantes

 Rust prohibirá las referencias colgantes:

fn main() {

    let ref_x: &i32;

    {

        let x: i32 = 10;

        ref_x = &x;

    }

    println!("ref_x: {ref_x}");

}

Se dice que una referencia "toma prestado" el valor al que se refiere.

Rust está rastreando la vida útil de todas las referencias para garantizar que vivan lo suficiente. Y lanza el siguiente error: 

$ cargo run

   Compiling hello_cargo v0.1.0 (/home/emanuel/Projects/rust/hello_cargo)

error[E0597]: `x` does not live long enough

  --> src/main.rs:9:17

   |

9  |         ref_x = &x;

   |                 ^^ borrowed value does not live long enough

10 |

11 |     }

   |     - `x` dropped here while still borrowed

12 |

13 |     println!("ref_x: {ref_x}");

   |                       ----- borrow later used here

For more information about this error, try `rustc --explain E0597`.

error: could not compile `hello_cargo` due to previous error

Rust: Tipos de compuestos

 

	Types	Literals
Arrays	[T; N]	[20, 30, 40], [0; 3]
Tuples	(), (T,), (T1, T2), …	(), ('x',), ('x', 1.2), …

Asignación de matriz y acceso:

fn main() {

    let mut a: [i8; 10] = [42; 10];

    a[5] = 0;

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

}

Asignación de tuplas y acceso:

fn main() {

    let t: (i8, bool) = (7, true);

    println!("1st index: {}", t.0);

    println!("2nd index: {}", t.1);

}

Arrays:

Los Arrays tienen elementos del mismo tipo, T, y longitud, N, que es una constante de tiempo de compilación. Tenga en cuenta que la longitud de la matriz es parte de su tipo, lo que significa que [u8; 3] y [u8; 4] se consideran dos tipos diferentes.

Podemos usar literales para asignar valores a matrices.

Tuplas:

Al igual que los arreglos, las tuplas tienen una longitud fija.

Las tuplas agrupan valores de diferentes tipos en un tipo compuesto.

Se puede acceder a los campos de una tupla por el período y el índice del valor, p. t.0, t.1.

La tupla vacía () también se conoce como el "tipo de unidad". Es a la vez un tipo y el único valor válido de ese tipo, es decir, tanto el tipo como su valor se expresan como (). Se utiliza para indicar, por ejemplo, que una función o expresión no tiene valor de retorno, como veremos más adelante.

Puede considerarlo como un void que puede resultarle familiar de otros lenguajes de programación.

Referencias en Rust

Como C++, Rust tiene referencias:

fn main() {

    let mut x: i32 = 10;

    let ref_x: &mut i32 = &mut x;

    *ref_x = 20;

    println!("x: {x}");

}

Debemos desreferenciar ref_x al asignarleun valor, de forma similar a los punteros de C y C++.

Rust eliminará automáticamente la referencia en algunos casos, en particular al invocar métodos.

Las referencias que se declaran como mut se pueden vincular a diferentes valores durante su vida útil.

Asegúrese de notar la diferencia entre let mut ref_x: &i32 y let ref_x: &mut i32. El primero representa una referencia mutable que se puede vincular a diferentes valores, mientras que el segundo representa una referencia a un valor mutable.

Rust: Comandos básicos y tipos

Gran parte de la sintaxis de Rust le resultará familiar de C, C++ o Java:

• Los bloques y ámbitos están delimitados por llaves.
• Los comentarios de línea comienzan con //, los comentarios de bloque están delimitados por /* ... */.
• Palabras clave como if y while funcionan de la misma manera.
• La asignación de variables se realiza con =, la comparación se realiza con ==.

Los tipos escalares son : 

Types	Literals
Signed integers	i8, i16, i32, i64, i128, isize	-10, 0, 1_000, 123i64
Unsigned integers	u8, u16, u32, u64, u128, usize	0, 123, 10u16
Floating point numbers	f32, f64	3.14, -10.0e20, 2f32
Strings	&str	"foo", "two\nlines"
Unicode scalar values	char	'a', 'α', '∞'
Booleans	bool	true, false

Cuanto bites usan: 

iN, uN y fN tienen N bits,

isize y usize son el ancho de un puntero,

char tiene 32 bits,

bool tiene un ancho de 8 bits.

Las cadenas sin formato permite crear un valor &str con escapes deshabilitados: r"\n" == "\\n". Puede incrustar comillas dobles usando una cantidad igual de # a cada lado de las comillas:

fn main() {

    println!(r#"<a href="link.html">link</a>"#);

    println!("<a href=\"link.html\">link</a>");

}

Las cadenas de bytes le permiten crear un valor &[u8] directamente:

fn main() {

    println!("{:?}", b"abc");

    println!("{:?}", &[97, 98, 99]);

}

Primeros pasos con Rust

Quiero recomendarles el sitio primeros pasos en Rust, para aprender de 0 el lenguaje Rust. La pagina dice: 

¿Está interesado en aprender un nuevo lenguaje de programación que está creciendo en uso y popularidad? ¡Empiece por aquí! Siente las bases del conocimiento que necesita para compilar programas rápidos y eficaces en Rust.

En esta ruta de aprendizaje, hará lo siguiente:

• Instalar las herramientas necesarias para escribir sus primeras líneas de código de Rust.
• Aprender los conceptos básicos de Rust.
• Aprender a administrar los errores.
• Administrar la memoria en Rust.
• Usar tipos y rasgos genéricos.
• Configurar módulos para paquetes y contenedores.
• Escribir y ejecutar pruebas automatizadas.
• Crear una herramienta de línea de comandos.

Sin más dejo link:  https://learn.microsoft.com/es-es/training/paths/rust-first-steps/

Ya tenemos los resultados de la encuesta de stackoverflow

 

Como dije, ya tenemos los resultados de la encuesta de stackoverflow!!!

Dejo link: 

https://survey.stackoverflow.co/2023/

¿Por qué Rust?

Los puntos más fuertes de Rust son:

• Seguridad de la memoria.
• Comportamiento bien definido en tiempo de ejecución.
• Características del lenguaje moderno.

Si lo comparamos con otros lenguajes :

Experiencia con C o C++: Rust elimina toda una clase de errores de tiempo de ejecución. Obtiene un rendimiento como en C y C++, pero no tiene los problemas de inseguridad de la memoria. Además, es un lenguaje moderno con construcciones como pattern matching y la gestión de dependencias integrada.

Experiencia con Java, Go, Python, JavaScript…: Obtiene la misma seguridad de memoria que en esos lenguajes, además de una sensación de lenguaje de alto nivel similar. Además, obtiene un rendimiento rápido y predecible como C y C++ (sin recolector de basura), así como acceso a hardware de bajo nivel (si lo necesita).

 

Supera 6 desafíos clave de la nube con Google Cloud. ¿Quieres marcar la diferencia en tu organización? Aprende a tomar mejores decisiones con nuestra guía digital. Descargar ahora

Hola, Emanuel:

Seguramente ya sabes que, como líder de tecnología, tus decisiones pueden tener un gran impacto en tu organización. Desde las más simples hasta las más complejas, todas tienen consecuencias y, si hablamos de aplicaciones en la nube, existen varios aspectos a tener en cuenta.

Para ayudarte, te acercamos nuestra guía electrónica más reciente: Toma decisiones que marquen la diferencia: Cómo las decisiones inteligentes pueden ayudarte a superar seis desafíos comunes a la hora de desarrollar aplicaciones modernas en la nube.

Conocerás estrategias que pueden ayudarte en desafíos clave, como acelerar la entrega de software, optimizar los sistemas existentes con un entorno de múltiples nubes y alcanzar la flexibilidad que tanto necesitas. Con este material aprenderás a:

Operar más rápido y obtener ahorros sin comprometer la seguridad. Expandir tus negocios mucho más utilizando tus inversiones actuales en tecnología. Retener y capacitar en cuestiones técnicas a los mejores talentos. Acceder a muchas otras recomendaciones que agregarán valor a tu empresa.

Descubre los insights, las mejores prácticas y los casos de éxito con historias reales de clientes.

Descargar ahora

Nos vemos en la nube, Equipo de Google Cloud

© 2023 Google LLC 1600 Amphitheatre Parkway, Mountain View, CA 94043

Un pequeño ejemplo en Rust

Un pequeño programa de ejemplo en Rust:

fn main() {              // Program entry point

    let mut x: i32 = 6;  // Mutable variable binding

    print!("{x}");       // Macro for printing, like printf

    while x != 1 {       // No parenthesis around expression

        if x % 2 == 0 {  // Math like in other languages

            x = x / 2;

        } else {

            x = 3 * x + 1;

        }

        print!(" -> {x}");

    }

    println!();

}

Si corremos este programa: 

$ cargo run

   Compiling hello_cargo v0.1.0 (/home/emanuel/Projects/rust/hello_cargo)

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

     Running `target/debug/hello_cargo`

6 -> 3 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1

El código implementa la conjetura de Collatz: se cree que el ciclo siempre terminará, pero esto aún no está probado. 

Que podemos ver de este código: 

• Todas las variables están tipadas estáticamente. Podemos eliminar i32 para activar la inferencia de tipo :  let mut x = 6; 
• mut se utiliza para indicar que x es mutable. 
• print! se utiliza para imprimir.