Formation Rust

Types basique : Basic types

• Machine types
  • Integer, Floating-point, bool, Characters types
• Tuples
  • Pointer types
  • References
  • Boxes
  • Raw pointers
• Arrays, Vectors, and Slices
• String types

Ownership

• Ownership
• Moves : operations, control flow, indexed content
• Copy types : exception
• Rc & Arc: shared ownership

Les conditions

References

• References as values
• Rust references VS C++ references
• Assignation, comparaison, Null
• References to slices and trait objects
• Passing & Returning
• Structs
• Lifetime parameters
• Sharing VS mutation

Expressions

• Blocks & semicolons
• Declarations
• if and match, if let
• Loops
• Return expressions
• Function & method calls
• Fields & elements
• Reference operators
• Arithmetic, bitwise, comparison, and logical operators
• Assignment, Type casts, Closures
• Precedence & Associativity

Gestion d’erreur

• Panic
• Aborting, Result, Catching, Ignoring
• Result type aliases
• Propagating errors
• Manipuler plusieurs types d’erreurs
• Custom error type

Structs

• Named-field structs
• Tuple-like, Unit-like structs
• Struct layout
• Définir : methods implémentation
• Generic structs
• Lifetime parameters
• Héritage : Traits for struct types
• Mutabilité interne

Enums & patterns

• enums : Rich data structures using
• Generic enums
• Patterns
  • Literals, variables, wildcards
  • Reference, Tuple & struct patterns
    Matching multiple, guards, @ patterns
• Remplir : binary tree

Traits & Generics

• Trait objects, layout
• Drop, Sized, Clone, Copy
• Deref & DerefMut, Default
• AsRef & AsMut
• Borrow & BorrowMut
• From & Into
• Borrow & ToOwned
• Self in traits
• Subtraits
• Static methods
• Associated types (or, how iterators)
• Generic traits (or, how operator overloading)
• Buddy traits (or, how rand::random())
• Reverse-engineering bounds

Surcharge d’opérateurs

• Operator overloading
• Arithmetic and bitwise operators
• Unary, Binary operators
• Affectation : Compound assignment operators
• Egalité : Equality tests
• Ordered comparisons
• Index & IndexMut
• Autre opérateurs

Closures

• Capturing variables
• Closures : Borrow, steal, function & types
• Performance
• Sécurité
• FnOnce & FnMut
• Callbacks

Iterateurs

• Iterator & IntoIterator traits
  • iter & iter_mut methods
  • drain methods
• Adapters
  • Map & filter
  • filter_map & flat_map
  • scan
  • take & take_while, skip & skip_while
  • peekable, fuse
  • Reversible iterators and rev
  • inspect, chain, enumerate, zip
  • by_ref, cloned, cycle
• Consuming iterators
  • Accumulation : count, sum, product
  • max, min, max_by, min_by
  • max_by_key, min_by_key
  • Comparaison : item sequences
  • any & all
  • position, rposition, & ExactSizeIterator
  • fold, nth, last, find
  • collect & FromIterator
  • Extend trait, Partition
• Implémenter son propre itérateur

Collections

• Vec<T>
• Accessing elements
• Iteration
• Growing & shrinking vectors
• Joining, Splitting, Swapping
• Sorting & searching
• Comparing slices
• Random elements
• Règles : Rust rules out invalidation errors
• VecDeque<T>, LinkedList<T>, BinaryHeap<T>
• HashMap<K, V> and BTreeMap<K, V>
• Entries
• Map iteration
• HashSet<T> and BTreeSet<T>
• Set iteration
• Hashing & custom hashing algorithm

Strings & Text

• ASCII, Latin-1, Unicode , UTF-8
• Conversions : characters, integers, digits
• String and str
• Inspection
• Appending, inserting, Removing text
• Conventions for searching and iterating
• Patterns : Searching & replacing
• Iterating over text, Trimming
• Case conversion for strings
• Parsing other types from strings
• Converting other types to strings
• Borrowing as other text-like types
• Strings as generic collections
• Formatting values, text, numbers, custom…
• Debugging
• Regular expressions
• Basic Regex use & lazily
• Normalization forms, unicode-normalization crate

Input & output

• Readers & Writers : Files, Directories, Seeking
• Binary data, compression, serialization
• OsStr & Path
• Path & PathBuf methods
• Filesystem access functions
• Platform-specific features
• Pile réseau : Networking

Concurrency

• Fork-join parallelism, spawn & join, Error
• Sharing immutable data, Rayon, Mandelbrot
• Channels, Sending, Receiving values
• Pipeline, Channel features & performance
• Thread safety: Send and Sync
• Iterator channel
• Partager : Shared mutable state
• Mutex in Rust : mut & Mutex
• Deadlock, Poisoned mutexes
• Multi-producer channels
• Read-write locks (RwLock)
• Condition variables (Condvar)
• Atomics, Global variables

Macros

• Expansion, Repetition, Debugging, Error
• Utilisation : Json, Fragment types, Recursion, Traits with macros
• Bonnes pratiques : Scoping
• Import and export

Unsafe code

• Unsafe blocks
• Exemple : ASCII string type
• Unsafe functions, traits, Raw pointers
• Exemple: RefWithFlag
• Nullable pointers
• Type sizes & alignments
• Pointer arithmetic
• Moving into and out of memory
• Exemple : GapBuffer
• Interop : Foreign functions, calling function lib C & C++
• Common data representations
• Déclaration : foreign functions & variables
• Raw interface libgit2, Safe interface libgit2