A crate that generate books with the same design as The Rust Programming Language.
Saved for future uses

Je pose ça sur le tas. Le billet semble un peu vieux; je n'ai trouvé aucune date.

Rust VS Golang est finalement pas pertinent, comme expliqué à la fin du billet :

Faut-il utiliser Rust, donc le choisir plutôt que Go ou C++? On mettra go de coté car il est plutôt en compétition avec les langages de serveurs comme Java, Python, PHP, un garbage collector peut être un inconvénienr, et son système de modules en ligne l'est encore plus, ainsi que l'absence de généricité.

Le schéma des étapes de génération d'un programme exécutable est agréable à voir.

Lorsque dyn est utilisé, il désigne spécifiquement un trait. Ainsi, traits et structures ne sont plus confondus.

// trait objects (new dyn syntax)
&Foo     => &dyn Foo
&mut Foo => &mut dyn Foo
Box<Foo> => Box<dyn Foo>

// structs (no change)
&Bar
&mut Bar
Box<Bar>

Je pose ça sur le tas. Un engine pour jeux vidéos écrit en Rust

OuiOuiOui je m'étais déjà fais la remarque dans la tête. Finalement, un fonction standardisée existe bel et bien : l'équivalent du free() en C est élégant en Rust avec la fonction drop() <3
De plus, contrairement au C, pas besoin d'indiquer la zone mémoire, la taille à libérer, tout ça tout ça

Microsoft's decision to investigate Rust (and other languages) began due to the fact that roughly 70% of Common Vulnerabilities and Exposures (CVEs) in Microsoft products were related to memory safety issues in C and C++.

Un résumé sur la programmation d'un exécuteur Rust de code JS.

Et le gars, il écrit du code JS analysé et parsé en Rust. Pour ensuite produire du code WebAssembly et ếtre exécuté en tant que code JS importé grâce à WebAssembly. <3

Et la différence entre .iter() et .into_inter()

.iter() emprunte les valeurs (itération sur les valeurs par référence) de la structure
.into_iter() à l'opposé devient propriétaire des valeurs

Dupliquer un nombre z d'élément de la collection x dans un vecteur y :

    let y = x
        .iter()
        .map(|i| i.clone()) // Or use .cloned() instead since Rust 1.1
        .take(z)
        .collect::<Vec<_>>();

Excellente explication sur les lifetimes en rust

Une drôle d'histoire !

Je pose ça en réserve

edit 2024: déjà en train de partager à propos de Rust :)

Rendre son code Rust plus idiomatique <3

• returning values
• unimplemented!() / unreachable!()
• option.as_ref().unwrap()
• map.entry(key).or_insert_with(Vec::new).push(val);
• let numbers: Vec<_> = (0..10).collect();
• elements.iter().cloned()
• list.iter().enumerate() (like python)
• _ for unused variables

Un point de vue sur Rust

Un projet pertinent à surveiller.

Avec la vidéo expliquant le projet (+ des trucs sur Rust). Une base de donnée plus rapide !

La solution au problème de lenteur des verrous semble prometteuse. Je l'aime bien

Ou pourquoi s'intéresser à Rust <3
Chaque paragraphe suscite l'envie d'apprendre le langage

Compte rendu du choix de Rust comme langage de développement pour les CPU-bound bottlenecks de npm.

Rust expliqué pour des programmeurs en haut niveau style JS.

 Mémo

• on peut faire comme en python et surcharger l'opérateur "+" avec le trait Add. C'est aussi possible avec les autres opérateurs.
• le mot-clé type permet de créer des alias : type Int = i32; permet de déclarer des variables de cette façon : let number: Int = 10;. Int sera remplacé par i32. On peut donc imaginer des alias pour un type devant implémenter un ou plusieurs traits. Par exemple, type proxy = box<? impl Debug + > à tout hasard. L'exemple n'est pas top, mais rien ne me vient à l'idée. TODO: à améliorer.
• let mul = | a , b | a * b; est équivalent à fn mul (a: i32, b: i32) -> i32 { a * b } ou dans sa version plus typé let mul = |a: int32, b: int32 | -> i32 { a * b };
  Note : a et b dans la closure doivent implémenter l'opérateur "*" mais ne sont pas obligatoirement de type i32

Propre.

La recommandation est de créer un bloc impl pour les méthodes et un autre pour les fonctions liées à la structure. Cela afin de bien les séparer.

Une méthode prend en paramètre un référence à l'objet (généralement &self, il s'agit ici d'un emprunt car on veut généralement continuer à utiliser l'objet après l'appel à la méthode).
Une fonction liée à la structure ne prend pas de référence, elle est indépendante.