Learning Paths

412Fundamental

412: Macro Repetition Patterns

413Fundamental

413: Macro Fragment Types (Designators)

414Fundamental

414: Recursive Macro Patterns

415Fundamental

415: Token Tree Munching

419Fundamental

419: `cfg!` and Conditional Compilation

420Fundamental

420: `env!` and `option_env!` — Compile-time Environment Variables

421Fundamental

421: `include!`, `include_str!`, `include_bytes!`

422Fundamental

422: Derive Macro Concepts

427Fundamental

427: `syn` and `quote!` Basics

428Fundamental

428: Macro Hygiene

429Fundamental

429: Macro Scoping and Visibility

430Fundamental

430: Macro Debugging Techniques

431Fundamental

431: Counting Patterns in Macros

432Fundamental

432: Macro Enum Dispatch

434Fundamental

434: Domain-Specific Languages with Macros

435Fundamental

435: Lazy Static Pattern

437Fundamental

437: Test Helper Macros

438Fundamental

438: `format_args!` and Efficient Formatting

439Fundamental

439: Assert Variant Macros

440Fundamental

440: Log Pattern Macros

502Fundamental

Fn, FnMut, FnOnce

593Fundamental

Interpreter Pattern

598Fundamental

Finally tagless

603Fundamental

Functor Laws

607Fundamental

Fixed-Point Types

613Fundamental

Futumorphism

616Fundamental

Optics: lens pattern

619Fundamental

Optics: iso pattern

623Fundamental

Optics: functional rust grand tour

760Fundamental

760-serde-derive-concept — Serde Derive Concept

761Fundamental

761-custom-serialize-logic — Custom Serialize Logic

762Fundamental

762-custom-deserialize-logic — Custom Deserialize Logic

766Fundamental

766-config-file-parsing — Config File Parsing

767Fundamental

767-versioned-data-format — Versioned Data Format

773Fundamental

773-serde-attributes-concept — Serde Attributes Concept

776Fundamental

776-const-fn-basics — Const Fn Basics

777Fundamental

777-const-assert-patterns — Const Assert Patterns

779Fundamental

779-const-lookup-table — Const Lookup Table

781Fundamental

781-const-where-bounds — Const Where Bounds

782Fundamental

782-const-eval-patterns — Const Eval Patterns

783Fundamental

783-const-type-arithmetic — Const Type Arithmetic

850Fundamental

Functors Introduction

858Fundamental

Kleisli Composition

863Fundamental

Traverse with Option

933Fundamental

933-map-functor — Map / Functor

FunctionsHigher-Order Programming

1093Fundamental

Currying and Partial Application

1162Fundamental

Hello World — Functions and Greetings

Higher-Order FunctionsFunctional CompositionCurrying

001Intermediate

Applying a Function Twice

001Intermediate

001 — Higher-Order Functions

Higher-Order FunctionsClosuresComposition

002Intermediate

Function Composition

005Intermediate

005 — Currying and Partial Application

006Intermediate

006 — Function Composition

051Intermediate

051 — Applying a Function Twice

054Intermediate

054 — Applicative Validation

074Intermediate

074 — Currying and Partial Application (Applied)

077Intermediate

077 — Generic Bounds

120Intermediate

Closure Types: Fn, FnMut, FnOnce

121Intermediate

Closure Capture Modes

122Intermediate

Higher-Order Functions with Lifetime Constraints

127Intermediate

Const Functions — Compile-Time Computation

213Intermediate

Practical Lens — Deeply Nested Config Update

230Intermediate

Semigroup

Algebra / Type Classes

501Intermediate

Closure Capture Rules

503Intermediate

Closure as Argument

504Intermediate

Closure as Return

505Intermediate

Boxing Closures

506Intermediate

Closure Move Semantics

508Intermediate

Closure Partial Application

509Intermediate

Closure Composition

510Intermediate

Closure Currying

511Intermediate

Recursive Closures and Y Combinator

512Intermediate

Closure State Machine

513Intermediate

Closure Strategy Pattern

514Intermediate

Closure Observer Pattern

515Intermediate

Lazy Evaluation with OnceLock

516Intermediate

Complex Closure Environments

517Intermediate

Closure-to-Function-Pointer Coercion

518Intermediate

Function Pointers vs Closures

519Intermediate

Closure Type Inference

520Intermediate

Higher-Order Functions

521Intermediate

Map-Reduce with Closures

522Intermediate

Predicate Functions Pattern

523Intermediate

Event Handler Pattern

524Intermediate

Builder Pattern with Closures

525Intermediate

Tap Pattern for Side Effects

526Intermediate

Pipe Operator Simulation

527Intermediate

FnOnce for Consuming Closures

528Intermediate

Closures Capturing References

529Intermediate

Async Closures

530Intermediate

Closures in Benchmarking

605Intermediate

Applicative Laws

778Intermediate

778-const-fibonacci — Const Fibonacci

852Intermediate

Applicative Functor Basics

853Intermediate

Applicative Validation

871Intermediate

871-generic-bounds — Generic Bounds

947Intermediate

947 Currying Partial

1084Intermediate

Monoid Pattern

1107Intermediate

Currying, Partial Application, and Sections

Pattern MatchingHigher-Order FunctionsType-Class Patterns

1136Intermediate

Monoid — Fold with Closures and Traits

1163Intermediate

Currying, Partial Application, and Operator Sections

074Advanced

074 — Bifunctor

099Advanced

099 — Continuation-Passing Style (CPS)

126Advanced

Const Generics

134Advanced

Higher-Kinded Types Simulation

194Advanced

Coroutines and Generators

195Advanced

Continuation-Passing Style

200Advanced

Tagless Final

DSLsType System

201Advanced

Introduction to Lenses — The Nested Update Problem

202Advanced

Lens Basics — Get and Set

203Advanced

Lens Laws

Functional PatternsOpticsImmutable Updates

204Advanced

Lens Composition — Zoom Into Nested Structs

205Advanced

Lens Modify

206Advanced

Prism Basics — Optics for Enum Variants

207Advanced

Prism Laws

208Advanced

Traversal — Focus on Zero or More Targets

209Advanced

Affine Traversal — At Most One Focus

210Advanced

Iso Basics — Isomorphisms

211Advanced

Optics Hierarchy

227Advanced

Functor Category — Functors as Objects, Natural Transformations as Morphisms

Category Theory

228Advanced

Natural Transformations

Category Theory

229Advanced

Monoid as a Category

Category Theory

260Advanced

Functor Comparable Set

Functors and Modules

383Advanced

383: Simulating Higher-Kinded Types with GATs

423Advanced

423: Procedural Macro Introduction

424Advanced

424: Proc Macro Derive

425Advanced

425: Proc Macro Attribute

426Advanced

426: Function-like Proc Macros

507Advanced

Closure Memoization

594Advanced

Continuation-Passing Style (CPS)

615Advanced

Optics: optics intro

617Advanced

Optics: prism pattern

620Advanced

Optics: affine traversal

622Advanced

Optics: classy optics

774Advanced

774-const-generics-basics — Const Generics Basics

780Advanced

780-const-generic-struct — Const Generic Struct

1081Advanced

Lenses

Higher-order functions

1082Advanced

Tail-Recursive Map with CPS

1086Advanced

Lenses — Functional Getters and Setters

Functional Abstractions

184Expert

Introduction to Free Monads

185Expert

Console DSL with Free Monad

186Expert

Free Monad Interpreters

187Expert

Free Monad with State

188Expert

Operational Monad

189Expert

Introduction to Algebraic Effects

190Expert

Effect Handlers

191Expert

Effects as Exceptions

192Expert

Effects as State

193Expert

Effects as Async

196Expert

Delimited Continuations

199Expert

Scott Encoding

212Expert

Van Laarhoven Lenses

218Expert

Anamorphism — Unfold to Build Recursive Structures

219Expert

Hylomorphism — Ana then Cata, Fused

220Expert

Paramorphism — Cata with Access to Original Subtree

221Expert

Apomorphism — Ana that Can Short-Circuit

222Expert

Histomorphism — Cata with Full History

223Expert

Zygomorphism — Two Mutually Dependent Folds

224Expert

Mutumorphism — Genuinely Mutual Recursion

225Expert

Prepromorphism — Apply Natural Transformation at Each Step

226Expert

Category Basics

233Expert

Curry-Howard Correspondence

234Expert

Propositions as Types

235Expert

Yoneda Lemma

236Expert

Coyoneda

237Expert

Day Convolution

238Expert

Profunctor Basics

239Expert

Strong Profunctor

240Expert

Choice Profunctor

241Expert

Comonad Basics

242Expert

Store Comonad

243Expert

Environment Comonad

244Expert

Comonad Laws

245Expert

Cofree Comonad

246Expert

Adjunctions

247Expert

Limits and Colimits

248Expert

Kan Extensions

249Expert

Monad from Adjunction

250Expert

Grand Synthesis

597Expert

Scott encoding rust

599Expert

Free monad rust

600Expert

Effect system sim

604Expert

Monad Laws

609Expert

Anamorphism

610Expert

Hylomorphism

611Expert

Paramorphism

612Expert

Zygomorphism

614Expert

Histomorphism

618Expert

Optics: traversal optics

621Expert

Optics: profunctor optics

854Expert

Option Monad

859Expert

State Monad

860Expert

Reader Monad

861Expert

Writer Monad

862Expert

Monad Transformers

865Expert

Sequence Monadic

869Expert

869-continuation-monad — Continuation Monad

941Expert

941 Identity Monad

949Expert

949 Profunctor Intro

1079Expert

Writer Monad — Logging Computation

Monadic Patterns

🛡️

Error Handling FP Style

Result, Option, monadic error composition, async patterns, and concurrency.

156 examples

060Fundamental

Option Type — Safe List Maximum

Error Handling

441Fundamental

441: Thread Basics — Spawn and Join

442Fundamental

442: Scoped Threads — Borrowing Across Threads

446Fundamental

446: Thread Pool Pattern

448Fundamental

448: Rayon Parallel Iterators — Data Parallelism

449Fundamental

449: Rayon Join — Fork-Join Parallelism

450Fundamental

450: Crossbeam Channels — Advanced Channel Patterns

451Fundamental

451: Crossbeam Select — Multiplexing Channels

459Fundamental

459: Thread-Local Storage

462Fundamental

462: Pipeline Concurrency

463Fundamental

463: Fan-Out / Fan-In Pattern

465Fundamental

465: Message Passing vs. Shared Memory

466Fundamental

Concurrent HashMap

469Fundamental

Parallel Reduce

470Fundamental

Concurrent BTree

715Fundamental

ffi error codes

741Fundamental

741-parse-dont-validate — Parse Don't Validate

754Fundamental

754-testing-async-code — Testing Async Code

755Fundamental

755-testing-error-paths — Testing Error Paths

864Fundamental

Traverse with Result

923Fundamental

923-thread-pool — Thread Pool

979Fundamental

979 Future Basics

983Fundamental

983 Channel Basics

984Fundamental

984 Channel Pipeline

985Fundamental

985 Select Pattern

988Fundamental

988 Thread Local

989Fundamental

989 Once Init

990Fundamental

990 Semaphore

994Fundamental

994 Map Reduce

995Fundamental

995 Pipeline Stages

1122Fundamental

List Filter — Select Elements by Predicate

ListsHOF

004Intermediate

004 — Option and Result

041Intermediate

041 — Option Basics

042Intermediate

042 — Option Map

043Intermediate

043 — Option Bind (and_then)

044Intermediate

044 — Option Filter

045Intermediate

045 — Result Basics

046Intermediate

046 — Result Map

047Intermediate

047 — Result Bind (and_then)

048Intermediate

048 — Error Propagation with the ? Operator

049Intermediate

049 — Error Conversion

050Intermediate

050 — Custom Error Types

072Intermediate

072 — Error Accumulation (Validation Type)

072Intermediate

072 — Railway-Oriented Programming

073Intermediate

073 — Validated Types (Parse, Don't Validate)

258Intermediate

Monadic Option Chaining

Monadic patterns

259Intermediate

Result Monad — Error Chaining

Monadic patterns

276Intermediate

Parallel Letter Frequency

291Intermediate

291: Result Combinators

292Intermediate

292: Option Combinators

293Intermediate

293: The ? Operator

294Intermediate

294: Custom Error Types

295Intermediate

295: Implementing std::error::Error

296Intermediate

296: From Trait for Error Conversion

297Intermediate

297: The thiserror Pattern

298Intermediate

298: The anyhow Pattern — Boxed Errors

299Intermediate

299: Adding Context to Errors

300Intermediate

300: Chaining Errors with source()

301Intermediate

301: Result::transpose() — Flipping Nested Types

302Intermediate

302: Option::transpose() — Collecting Optional Results

304Intermediate

304: Splitting Ok/Err with partition()

305Intermediate

305: unwrap_or, unwrap_or_else, unwrap_or_default

306Intermediate

306: ok_or and ok_or_else

307Intermediate

307: Error Propagation in Closures

308Intermediate

308: When to Panic vs Return Result

310Intermediate

310: Infallible Conversions

311Intermediate

311: Handling Multiple Error Types

312Intermediate

312: Error Downcasting

313Intermediate

313: The Try Trait — What ? Actually Does

315Intermediate

315: Result ok() and err() Methods

316Intermediate

316: std::io::Error Patterns

317Intermediate

317: Parse Error Handling

318Intermediate

318: Display vs Debug for Errors

319Intermediate

319: Error Handling in Tests

321Intermediate

321: async fn and .await Fundamentals

323Intermediate

323: async blocks and Lazy Evaluation

328Intermediate

328: Async Channels (mpsc)

341Intermediate

341: Buffered Stream — BufReader and BufWriter

341Intermediate

341: MPSC Channel

343Intermediate

343: Producer-Consumer Pattern

350Intermediate

350: Oneshot Channel

445Intermediate

445: MPSC Channels — Message Passing Between Threads

461Intermediate

461: Producer-Consumer Pattern

920Intermediate

920-buffered-stream — Buffered Stream

927Intermediate

927-option-result — Option and Result

943Intermediate

943 Result Railway

944Intermediate

944 Validated Type

980Intermediate

980 Async Map

981Intermediate

981 Async Sequence

993Intermediate

993 Work Queue

1001Intermediate

1001 — Event Loop

1003Intermediate

1003 — Custom Error Types

1004Intermediate

1004 — Error Conversion

1005Intermediate

1005 — Error Chaining

1006Intermediate

1006 — Multiple Error Types

1007Intermediate

1007-result-combinators — Result Combinators

1008Intermediate

1008-option-to-result — Option to Result

1009Intermediate

1009-collecting-results — Collecting Results

1010Intermediate

1010-partition-results — Partition Results

1011Intermediate

1011-try-operator — The ? (Try) Operator

1013Intermediate

1013-panic-vs-result — Panic vs Result

1014Intermediate

1014-recover-from-panic — Recover from Panic

1015Intermediate

1015-validation-error — Validation Errors

1016Intermediate

1016-error-context — Error Context

1017Intermediate

1017-typed-errors — Typed Error Hierarchies

1018Intermediate

1018-error-downcast — Error Downcast

1021Intermediate

1021-error-propagation-depth — Error Propagation Depth

1022Intermediate

1022-sentinel-vs-result — Sentinel Values vs Result

1023Intermediate

1023-parse-int-safe — Safe Integer Parsing

1024Intermediate

1024-file-errors — File Operation Errors

1025Intermediate

1025-network-errors — Network Error Classification

1026Intermediate

1026-error-display — Custom Error Display and Source Chain

1123Intermediate

List.fold_left — Accumulate a Result

1124Intermediate

1124-listfilter-select-elements-by-predicate — List.filter: Select Elements by Predicate

170Advanced

Error Recovery

309Advanced

309: The Never Type (!) in Error Handling

314Advanced

314: Validated — Accumulating All Errors

324Advanced

324: Running Futures Concurrently with join!

325Advanced

325: Racing Futures with select!

327Advanced

327: Spawning Concurrent Tasks

329Advanced

329: Async Streams

330Advanced

330: Async Sink — Buffered Writing

331Advanced

331: Timeouts with time::timeout

332Advanced

332: Retry Async with Exponential Backoff

333Advanced

333: Async Recursion

334Advanced

334: Pin and Unpin

336Advanced

336: Executor Basics

337Advanced

337: Async Mutex

338Advanced

338: Async RwLock — Multiple Readers, One Writer

339Advanced

339: Semaphore — Controlling Concurrency

342Advanced

342: Async I/O Concepts

343Advanced

343: Cancellation Token

344Advanced

344: Structured Concurrency

345Advanced

345: Async Drop

346Advanced

346: Runtime Context

347Advanced

347: Blocking in Async

348Advanced

348: Async Generator Pattern

349Advanced

349: Broadcast Channel

447Advanced

447: Work Stealing — Load Balancing Across Threads

458Advanced

458: Barrier Synchronization

464Advanced

464: Actor Pattern

921Advanced

921-async-io — Async I/O

922Advanced

922-cancellation-token — Cancellation Token

924Advanced

924-work-stealing — Work Stealing

982Advanced

982 Async Join

991Advanced

991 Barrier Sync

992Advanced

992 Actor Pattern

996Advanced

996 Timeout Pattern

997Advanced

997 Retry Backoff

998Advanced

998 Circuit Breaker

999Advanced

999 Rate Limiter

1000Advanced

1000 — Reactive Stream

1002Advanced

1002 — Backpressure

056Expert

056 — Result as a Monad

335Expert

335: Waker and Context

855Expert

Result Monad

🔤

Strings, Vectors & Data Types

String operations, vector manipulation, basic structs, records, and pattern matching.

114 examples

006Fundamental

006 — Palindrome Check

062Fundamental

062 — Isogram Check

068Fundamental

068 — Frequency Counter (Map Module)

070Fundamental

070 — Hamming Distance

082Fundamental

082 — Nucleotide Count

084Fundamental

084 — Phone Number Validation

086Fundamental

086 — Space Age

091Fundamental

091 — Caesar Cipher

092Fundamental

092 — Pangram Check

093Fundamental

093 — Isogram Check

102Fundamental

102-frequency-counter — Frequency Counter

264Fundamental

String Anagram Check

String Processing

265Fundamental

Caesar Cipher — Functional Encryption

String Processing

280Fundamental

Hamming Distance — Generic Zip

418Fundamental

418: `stringify!` and `concat!` Macros

471Fundamental

String vs &str

472Fundamental

String Slices

473Fundamental

String Parsing with FromStr

474Fundamental

String Formatting

475Fundamental

String Building

476Fundamental

String Splitting

477Fundamental

String Trimming

478Fundamental

String Searching

479Fundamental

String Replacing

480Fundamental

String Chars

481Fundamental

String Bytes

482Fundamental

String Unicode

483Fundamental

String Encoding

484Fundamental

Cow<str> Usage

485Fundamental

String Concatenation

486Fundamental

String Regex Pattern

488Fundamental

String Owning References

489Fundamental

Arc<str> for Shared Strings

490Fundamental

String Fixed Array

491Fundamental

Path and PathBuf

492Fundamental

OsStr Handling

493Fundamental

CString and CStr for FFI

494Fundamental

String-Number Conversion

495Fundamental

String Template Pattern

496Fundamental

String Diff Pattern

497Fundamental

String Case Conversion

498Fundamental

String Truncation

499Fundamental

String Escaping

500Fundamental

String Compression — Run-Length Encoding

712Fundamental

ffi string conversion

730Fundamental

730-small-string-optimization — Small String Optimization

763Fundamental

763-json-format-from-scratch — JSON Format From Scratch

769Fundamental

769-streaming-parser-pattern — Streaming Parser Pattern

771Fundamental

771-pratt-parser — Pratt Parser

823Fundamental

Polynomial String Hashing

929Fundamental

929-palindrome-check — Palindrome Check

930Fundamental

930-pangram-check — Pangram Check

945Fundamental

945 Word Count

952Fundamental

952 Atbash Cipher

955Fundamental

955 Json Value

956Fundamental

956 Json Pretty Print

957Fundamental

957 Json Query

959Fundamental

959 Csv Writer

970Fundamental

970 Rope String

1125Fundamental

1125-reverse-string — Reverse a String

010Intermediate

Run-Length Encoding

ListsData Compression

011Intermediate

011 — Modified Run-Length Encoding

012Intermediate

012 — Decode Run-Length Encoding

013Intermediate

013 — Direct Run-Length Encoding

036Intermediate

036 — Represent a Binary Tree as a String

039Intermediate

039 — Convert a Tree to a Dotstring Representation

040Intermediate

040 — Parse a Dotstring Back to a Binary Tree

063Intermediate

063 — Run-Length Encoding

064Intermediate

064 — Balanced Parentheses

083Intermediate

083 — Robot Simulator

088Intermediate

088 — Allergies

089Intermediate

089 — Bob

090Intermediate

Frequency Analysis — Letter Distribution

String Processing

094Intermediate

094 — Run-Length Encoding

095Intermediate

095 — Balanced Parentheses

113Intermediate

113-string-str — String vs &str

171Intermediate

CSV Parser

StringsFoldsNumeric ConversionRecursion

274Intermediate

Binary ↔ Decimal Fold

487Intermediate

String Interning

765Intermediate

765-csv-parsing-pattern — CSV Parsing Pattern

787Intermediate

787-edit-distance-levenshtein — Edit Distance (Levenshtein)

794Intermediate

794-word-break-dp — Word Break

958Intermediate

958 Csv Parser

1056Intermediate

1056-edit-distance — Edit Distance (Levenshtein)

1061Intermediate

1061-word-break — Word Break

096Advanced

096 — Recursive Descent Parser

151Advanced

Introduction to Parser Combinators

152Advanced

Character Parsers

153Advanced

Satisfy Parser

154Advanced

String Parser

155Advanced

Many Parser

156Advanced

Optional Parser

157Advanced

Choice Parser

158Advanced

Sequence Parser

159Advanced

Map Parser

160Advanced

FlatMap Parser

161Advanced

Digit Parser

162Advanced

Identifier Parser

163Advanced

Whitespace Parser

164Advanced

Number Parser

165Advanced

Keyword Parser

166Advanced

Separated List

167Advanced

Recursive Parser

168Advanced

Expression Parser

169Advanced

Operator Precedence

172Advanced

INI File Parser

173Advanced

Lisp / S-expression Parser

174Advanced

Arithmetic Expression Evaluator

175Advanced

Complete JSON Parser

764Advanced

764-binary-format-encoding — Binary Format Encoding

770Advanced

770-recursive-descent-parser — Recursive Descent Parser

772Advanced

772-parser-combinator-pattern — Parser Combinator Pattern

791Advanced

791-palindrome-partitioning — Palindrome Partitioning

820Advanced

Manacher's Algorithm — Longest Palindromic Substring

🔍

Pattern Matching & Types

Algebraic data types, sum types, traits, type system, and pattern-based destructuring in Rust.

151 examples

058Fundamental

Variants — Days of the Week

Algebraic Data Types

407Fundamental

407: The Default Trait

409Fundamental

409: Drop Trait and RAII

410Fundamental

410: Arithmetic Operator Overloading

433Fundamental

433: Macro-Defined State Machines

561Fundamental

Or Patterns

562Fundamental

Pattern Guards

563Fundamental

Struct Destructuring

564Fundamental

Enum Variant Patterns

565Fundamental

Tuple Struct Patterns

566Fundamental

Nested Patterns

567Fundamental

Pattern Binding Modes

568Fundamental

@ Bindings

570Fundamental

Slice Patterns

571Fundamental

.. and _ Wildcards

572Fundamental

Ref Patterns

573Fundamental

let-else Pattern

574Fundamental

if-let and while-let

575Fundamental

Let Chains (&&)

576Fundamental

matches! Macro

577Fundamental

Irrefutable vs Refutable Patterns

578Fundamental

Pattern Exhaustiveness

579Fundamental

String Pattern Matching

580Fundamental

Option Pattern Matching

582Fundamental

Tuple Pattern Matching

583Fundamental

Pattern Const Patterns

584Fundamental

Pattern Type Ascription

585Fundamental

Pattern Box Deref

586Fundamental

Pattern Multiple Arms

587Fundamental

Pattern Visitor Match

588Fundamental

Pattern State Automata

589Fundamental

Pattern Command Dispatch

590Fundamental

Pattern Advanced Enums

592Fundamental

Command Pattern (Functional Style)

601Fundamental

Coproduct Types (Sum Types)

602Fundamental

Advanced Product Types

743Fundamental

743-session-types — Session Types

751Fundamental

751-mock-trait-pattern — Mock Trait Pattern

759Fundamental

759-manual-serialize-trait — Manual Serialize Trait

866Fundamental

Foldable Trait

003Intermediate

003 — Pattern Matching

062Intermediate

062 — Records (Structs)

076Intermediate

076 — Trait Objects (Dynamic Dispatch)

078Intermediate

078 — Where Clauses

079Intermediate

079 — Associated Types

081Intermediate

081 — Newtype Pattern

082Intermediate

082 — Type Aliases

083Intermediate

083 — Display Trait

084Intermediate

084 — From and Into Traits

102Intermediate

102-clone-copy — Clone vs Copy

114Intermediate

114-slice-patterns — Slice Patterns

118Intermediate

Deref Coercions

123Intermediate

impl Trait in Function Signatures

124Intermediate

dyn Trait — Dynamic Dispatch

135Intermediate

Generic Newtype Patterns

148Intermediate

Sealed Traits

149Intermediate

Extension Traits

Type SystemFunctional Patterns

231Intermediate

Product Types

232Intermediate

Sum Types

State MachinesPattern Matching

257Intermediate

State Machine — Turnstile

384Intermediate

384: Trait Objects and `dyn Trait`

385Intermediate

385: Trait Objects and `Any` (Runtime Type Information)

386Intermediate

386: Object-Safe Traits

387Intermediate

387: Sealed Trait Pattern

388Intermediate

388: Extension Trait Pattern

389Intermediate

389: Newtype Pattern

390Intermediate

390: Type Alias and `impl Trait`

391Intermediate

391: `impl Trait` in Return Position

392Intermediate

392: `impl Trait` in Argument Position

393Intermediate

393: Trait Bounds and Where Clauses

394Intermediate

394: Supertrait Pattern

395Intermediate

395: Default Methods in Traits

396Intermediate

396: Simulating Trait Specialization

397Intermediate

397: Marker Traits

400Intermediate

400: Static vs. Dynamic Trait Dispatch

401Intermediate

401: Deref and Deref Coercions

402Intermediate

402: Index and IndexMut Traits

403Intermediate

403: Display and Debug Traits

404Intermediate

404: From, Into, TryFrom, TryInto

406Intermediate

406: Hash, Eq, and Ord Traits

408Intermediate

408: Clone and Copy Traits

543Intermediate

Lifetimes in dyn Trait

569Intermediate

Range Patterns

581Intermediate

Result Pattern Matching

814Intermediate

814-kmp-pattern-matching — KMP Pattern Matching

870Intermediate

870-trait-objects — Trait Objects (Dynamic Dispatch)

872Intermediate

872-where-clauses — Where Clauses

873Intermediate

873-associated-types — Associated Types

875Intermediate

875-newtype-pattern — Newtype Pattern

876Intermediate

876-type-aliases — Type Aliases

877Intermediate

877-display-trait — Display Trait

878Intermediate

878-from-into-traits — From/Into Traits

896Intermediate

896-clone-copy — Clone and Copy Traits

926Intermediate

926-pattern-matching — Pattern Matching

931Intermediate

931-records — Records and Functional Update

1103Intermediate

Monoid Pattern — Trait-Based Combining

066Advanced

066 — Phantom Types (Type-Safe Units)

100Advanced

100 — Phantom Types

119Advanced

Zero-Cost Abstractions

125Advanced

Send and Sync Marker Traits

Type SystemPhantom TypesCompile-Time Safety

128Advanced

Type-Level Booleans

129Advanced

Type-Level Natural Numbers — Peano Arithmetic

130Advanced

Typestate Pattern — State Machines in Types

Type-Level ProgrammingDesign PatternsZero-Cost Abstractions

131Advanced

Builder Pattern with Typestate

132Advanced

Phantom Units of Measure

133Advanced

Variance — Covariance, Contravariance, Invariance

138Advanced

Type Witnesses / GADT Encoding

143Advanced

Associated Type Bounds

144Advanced

Generic Associated Types (GAT) Basics

145Advanced

GAT Collections

146Advanced

Opaque Types

147Advanced

Type Erasure

150Advanced

Coherence Rules

180Advanced

PhantomData for API Safety

181Advanced

Type-Safe SQL-like Query Builder

322Advanced

322: The Future Trait and Poll

340Advanced

340: Async Trait Pattern

381Advanced

381: Blanket Implementations

382Advanced

382: Associated Types (Advanced)

398Advanced

398: Auto Traits (`Send`, `Sync`, `Unpin`)

399Advanced

399: Coherence and Orphan Rules

416Advanced

416: Macro-Generated Builder Pattern

436Advanced

436: Newtype Derive Patterns

460Advanced

460: `Send` and `Sync` Bounds

538Advanced

Variance: Covariant, Contravariant, Invariant

591Advanced

Functional Builder Pattern

702Advanced

unsafe trait

734Advanced

734-typestate-basics — Typestate Basics

735Advanced

735-typestate-builder — Typestate Builder

736Advanced

736-typestate-connection — Typestate Connection

737Advanced

737-typestate-file-handle — Typestate File Handle

738Advanced

738-phantom-type-basics — Phantom Type Basics

739Advanced

739-phantom-units-of-measure — Phantom Units of Measure

740Advanced

740-phantom-variance-control — Phantom Variance Control

742Advanced

742-type-witnesses — Type Witnesses

874Advanced

874-phantom-types — Phantom Types

1012Advanced

1012-never-type — The Never Type (!)

Monadic Patterns / Higher-Order Functions

1078Advanced

Visitor Pattern via Fold — Expression Evaluator

1098Advanced

Monoid Pattern — Generic Combining

Type ClassesAlgebraic Abstractions

079Expert

079 — Lambda Calculus Interpreter

136Expert

Existential Types

137Expert

Rank-2 Types Simulation

140Expert

Type-Safe Printf

141Expert

Singleton Types

142Expert

Type Equality

176Expert

Introduction to GADTs

177Expert

GADT Typed Expression Evaluator

178Expert

Length-Indexed Lists

179Expert

GADT Preventing Runtime Errors — Safe Head

182Expert

Existential Types via Box<dyn Trait>

Type System / Phantom Types

1077Expert

Phantom Type State Machine — File Handle

📦

Data Structures & Collections

Trees, maps, graphs, advanced data structures, lifetimes, and memory safety.

135 examples

453Fundamental

453: Memory Ordering

454Fundamental

454: Compare-and-Exchange (CAS)

456Fundamental

456: `OnceLock` and `OnceCell` — Once-Initialized Values

457Fundamental

457: Condition Variable Pattern

467Fundamental

Epoch-Based Garbage Collection

699Fundamental

Raw Pointer Basics

703Fundamental

raw pointer arithmetic

704Fundamental

dereferencing raw ptr

705Fundamental

null pointer check

707Fundamental

transmute basics

708Fundamental

transmute safe patterns

709Fundamental

unions in rust

710Fundamental

extern c functions

711Fundamental

no mangle export

713Fundamental

ffi repr c structs

714Fundamental

ffi callbacks

717Fundamental

volatile memory

718Fundamental

soundness principles

719Fundamental

Struct of Arrays (SoA) Pattern

720Fundamental

Cache-Friendly Iteration

721Fundamental

MaybeUninit — Safe Uninitialized Memory

722Fundamental

Memory Layout and `repr` Attributes

724Fundamental

Zero-Copy Parsing

726Fundamental

Memory Pool Pattern

727Fundamental

Portable SIMD Concepts

728Fundamental

728-inline-hints — Inline Hints

731Fundamental

731-tiered-memory-strategy — Tiered Memory Strategy

733Fundamental

733-profile-guided-patterns — Profile-Guided Patterns

768Fundamental

768-zero-copy-deserialize — Zero-Copy Deserialize

838Fundamental

Interval Tree — Stabbing Queries

867Fundamental

867-foldable-tree — Foldable Tree

868Fundamental

868-traversable-tree — Traversable Tree

935Fundamental

935-tree-map-fold — Tree Map and Fold

986Fundamental

986 Mutex Basics

987Fundamental

987 Rwlock Pattern

029Intermediate

029 — Binary Tree (Algebraic Data Type)

030Intermediate

030 — Count the Leaves of a Binary Tree

032Intermediate

032 — Collect the Internal Nodes of a Binary Tree

033Intermediate

033 — Collect the Nodes at a Given Level

034Intermediate

034 — Construct a Complete Binary Tree

035Intermediate

035 — Layout a Binary Tree

037Intermediate

037 — Preorder Traversal Sequence

038Intermediate

038 — Inorder Traversal Sequence

059Intermediate

Recursive Variant — Expression Tree

Algebraic Data Types

061Intermediate

061 — Binary Tree (Size, Membership, Traversal)

101Intermediate

101-move-semantics — Move Semantics

103Intermediate

103-borrowing-shared — Shared Borrowing

104Intermediate

104-borrowing-mutable — Mutable Borrowing

105Intermediate

105-lifetime-basics — Lifetime Basics

105Intermediate

105-trie — Trie (Prefix Tree)

106Intermediate

106-lifetime-elision — Lifetime Elision Rules

107Intermediate

107-lifetime-structs — Lifetimes in Structs

Memory ManagementSmart Pointers

108Intermediate

Rc\<T\> — Shared Ownership

110Intermediate

110-cell-interior — Cell<T>: Interior Mutability for Copy Types

116Intermediate

116-box-heap — Box<T>: Heap Allocation

261Intermediate

Binary Search Tree — Insert and Search

262Intermediate

Rose Tree — Multi-Way Tree with Fold

362Intermediate

362: Trie Structure

531Intermediate

Lifetime Annotations: 'a Basics

532Intermediate

Multiple Lifetime Parameters

533Intermediate

Lifetimes in Structs

534Intermediate

Lifetimes in impl Blocks

535Intermediate

Lifetimes in Enums

536Intermediate

'static Lifetime

537Intermediate

Lifetime Coercion and Subtyping

539Intermediate

Non-Lexical Lifetimes (NLL)

540Intermediate

Borrow Checker Internals

541Intermediate

Lifetime Elision Rules

542Intermediate

Higher-Ranked Trait Bounds (for<'a>)

544Intermediate

Lifetimes in Closures

545Intermediate

Split Borrows from Structs

546Intermediate

Reborrowing Patterns

547Intermediate

Polonius Borrow Checker Concepts

548Intermediate

Named Return Lifetimes

549Intermediate

PhantomData for Lifetime Markers

551Intermediate

Rc and Weak for Shared Ownership

554Intermediate

Safe Transmute Patterns

555Intermediate

Owning References Pattern

556Intermediate

Rental Pattern

557Intermediate

Output Lifetime Patterns

558Intermediate

Input Lifetime Patterns

559Intermediate

Region Inference

560Intermediate

Lifetime Cheatsheet

821Intermediate

Trie Autocomplete

895Intermediate

895-move-semantics — Move Semantics

897Intermediate

897-borrowing-shared — Shared Borrowing (&T)

898Intermediate

898-borrowing-mutable — Mutable Borrowing (&mut T)

899Intermediate

899-lifetime-basics — Lifetime Basics

962Intermediate

962 Trie Map

1003Intermediate

Map and Fold on Trees

1047Intermediate

1047-flat-tree — Flat Binary Tree in Vec

TreesGreedy AlgorithmsPriority Queues

1143Intermediate

Huffman Encoding — Greedy Tree Building

097Advanced

097 — Zipper

109Advanced

109-arc-threads — Arc<T>: Thread-Safe Shared Ownership

OwnershipBorrowingInterior Mutability

111Advanced

RefCell<T> — Runtime Borrow Checking

112Advanced

112-cow-clone-on-write — Cow<T>: Clone on Write

263Advanced

AVL Tree — Self-Balancing BST

TreesFunctional Data StructuresZippers

272Advanced

Tree Zipper

326Advanced

326: Capturing with async move

342Advanced

342: Arc<Mutex<T>> Pattern

354Advanced

354: BinaryHeap Priority Queue

366Advanced

366: Segment Tree

367Advanced

367: Fenwick Tree (Binary Indexed Tree)

369Advanced

369: Clone-on-Write (Cow)

373Advanced

373: Custom B-Tree Implementation

374Advanced

374: Radix Tree (Compressed Trie)

443Advanced

443: `Arc<Mutex<T>>` — Shared Mutable State

444Advanced

444: `Arc<RwLock<T>>` — Multiple Readers, One Writer

452Advanced

452: Atomic Types — Lock-Free Concurrent Primitives

550Advanced

Cell and RefCell for Interior Mutability

553Advanced

Self-Referential Structs

700Advanced

Unsafe Blocks

701Advanced

Unsafe Functions

706Advanced

unsafe cell

716Advanced

global allocator

723Advanced

Branchless Programming

729Advanced

729-avoid-allocations — Avoid Allocations

965Advanced

965 Segment Tree

966Advanced

966 Fenwick Tree

972Advanced

972 Persistent Tree

973Advanced

973 Finger Tree

1001Advanced

Binary Tree — Size, Membership, Traversal

1033Advanced

1033-binary-heap-topk — Top-K with BinaryHeap

1046Advanced

1046-cow-collections — Clone-on-Write Collections

1048Advanced

1048-zipper-vec — Vec Zipper

1083Advanced

Red-Black Tree

TreesBalanced Data Structures

1088Advanced

Red-Black Tree — Balanced Insert

1091Advanced

Red-Black Tree — Balanced Insert (Iterator + Free Functions)

TreesBalancing

1094Advanced

Red-Black Tree — Okasaki's Functional Balanced Insert

TreesPersistent Data Structures

1095Advanced

Red-Black Tree with Balanced Insert

TreesBalanced Data Structures

1096Advanced

Red-Black Tree with Okasaki's Functional Balancing

TreesFunctional Data Structures

1165Advanced

1165-building-a-huffman-tree-from-character-frequencies — Huffman Encoding: Greedy Tree Building

1166Advanced

Trie-based Persistent Vector for O(log n) Random Access

455Expert

455: Lock-Free Stack

468Expert

Lock-Free Queue

🔄

Iterators & Transformation

Map, filter, fold, and lazy iteration patterns from OCaml to Rust.

106 examples

857Fundamental

FlatMap / Bind Chains

031Intermediate

031 — Collect the Leaves of a Binary Tree in a List

056Intermediate

fold_right — Structural Recursion

057Intermediate

fold_left — Tail-Recursive Accumulator

067Intermediate

067 — Lazy Sequences (Seq Module)

070Intermediate

070 — Scan Left (Running Accumulation)

085Intermediate

085 — Iterator Trait

086Intermediate

086 — Custom Iterator with State

087Intermediate

087 — Iterator Adapters

088Intermediate

088 — Iterator Consumers

089Intermediate

089 — Lazy Sequences

090Intermediate

090 — Infinite Iterators

091Intermediate

091 — Zip and Unzip

092Intermediate

092 — Scan Accumulate

094Intermediate

094 — Peekable Iterator

095Intermediate

095 — Double-Ended Iterator

096Intermediate

096 — Exact Size Iterator

097Intermediate

097 — Flatten and Flat Map

098Intermediate

098 — Partition Iterator

099Intermediate

099 — Group Consecutive Equal Elements

100Intermediate

100 — Step By

101Intermediate

Lazy Sequences

Lazy/Infinite Sequences

104Intermediate

104-scan-left — Scan Left (Running Accumulation)

Lazy / Infinite Sequences

255Intermediate

Lazy Fibonacci

256Intermediate

256: Chaining Iterators with chain()

257Intermediate

257: Pairing Elements with zip()

258Intermediate

258: Index-Value Pairs with enumerate()

259Intermediate

259: Flattening with flat_map()

260Intermediate

260: Stateful Accumulation with scan()

261Intermediate

261: Lookahead with Peekable

262Intermediate

262: Sliding Windows over Slices

263Intermediate

263: Fixed-Size Chunks Iteration

264Intermediate

264: Conditional Stopping with take_while()

265Intermediate

265: Conditional Skipping with skip_while()

266Intermediate

266: Striding with step_by()

267Intermediate

267: Infinite Cycling with cycle()

268Intermediate

268: Splitting Pairs with unzip()

269Intermediate

269: Splitting by Predicate with partition()

270Intermediate

270: Finding Index with position()

271Intermediate

271: Transform-and-Find with find_map()

272Intermediate

272: One-Level Flattening with flatten()

273Intermediate

273: Debugging Iterators with inspect()

274Intermediate

274: Numeric Reductions: sum() and product()

275Intermediate

275: Finding Extremes with min() and max()

276Intermediate

276: Custom Comparison with min_by() and max_by()

277Intermediate

277: Counting Elements with count()

278Intermediate

278: Getting the Last Element with last()

279Intermediate

279: Random Access with nth()

280Intermediate

280: Existential Checks with any() and all()

281Intermediate

281: Implementing the Iterator Trait from Scratch

282Intermediate

282: DoubleEndedIterator and rev()

283Intermediate

283: ExactSizeIterator for Known-Length Iterators

284Intermediate

284: FusedIterator for Stable Termination

285Intermediate

285: Building Custom Iterator Adapters

286Intermediate

286: Creating Iterators with from_fn()

287Intermediate

287: Recursive Sequences with successors()

288Intermediate

288: Materializing Iterators with collect()

289Intermediate

289: Extending Collections with extend()

290Intermediate

290: Advanced Splitting Patterns

303Intermediate

303: Collecting Iterator<Result<T>> into Result<Vec<T>>

320Intermediate

320: Fallible Iterators

405Intermediate

405: Iterator Trait Deep Dive

879Intermediate

879-iterator-trait — Iterator Trait

880Intermediate

880-custom-iterator — Custom Iterator

881Intermediate

881-iterator-adapters — Iterator Adapters

882Intermediate

882-iterator-consumers — Iterator Consumers

883Intermediate

883-lazy-sequences — Lazy Sequences

884Intermediate

884-infinite-iterators — Infinite Iterators

885Intermediate

885-zip-unzip — Zip and Unzip

886Intermediate

886-scan-accumulate — Scan / Accumulate

888Intermediate

888-peekable-iterator — Peekable Iterator

889Intermediate

889-double-ended — DoubleEndedIterator

890Intermediate

890-exact-size — ExactSizeIterator

891Intermediate

891-flatten-iterator — Flatten Iterator

892Intermediate

892-partition-iterator — Partition Iterator

893Intermediate

893-group-by-iter — Group By Iterator

894Intermediate

894-step-by — Step By, Enumerate, Rev

900Intermediate

900-iterator-chain — Iterator Chain

901Intermediate

901-iterator-zip — Iterator Zip

902Intermediate

902-iterator-enumerate — Iterator Enumerate

903Intermediate

903-iterator-flat-map — Iterator flat_map

904Intermediate

904-iterator-scan — Iterator Scan

905Intermediate

905-iterator-peekable — Iterator Peekable

906Intermediate

906-iterator-windows — Iterator Windows

907Intermediate

907-iterator-chunks — Iterator Chunks

908Intermediate

908-iterator-take-while — Iterator take_while

909Intermediate

909-iterator-skip-while — Iterator skip_while

910Intermediate

910-iterator-find-map — Iterator find_map

911Intermediate

911-iterator-flatten — Iterator Flatten

912Intermediate

912-iterator-inspect — Iterator Inspect

913Intermediate

913-iterator-sum-product — Iterator Sum and Product

914Intermediate

914-iterator-min-max — Iterator min and max

915Intermediate

915-iterator-min-by-max-by — Custom Comparison min_by / max_by

916Intermediate

916-iterator-count — Iterator Count

917Intermediate

917-iterator-last — Iterator Last

918Intermediate

918-iterator-nth — Iterator nth

919Intermediate

919-iterator-any-all — Iterator any and all

939Intermediate

939 Scan Left

951Intermediate

951 Series Sliding Window

1002Intermediate

1002 — List Fold Left

1019Intermediate

1019-fallible-iterator — Fallible Iterator

1020Intermediate

1020-try-fold — try_fold

069Advanced

069 — Unfold — Generate a Sequence from a Seed

103Advanced

103-unfold — Unfold: Generating Sequences from Seeds

214Advanced

Fold Optic — Read-Only Multi-Focus Aggregation

938Advanced

938-unfold — Unfold

♾️

Recursion & Induction

Recursive patterns, tail-call optimization, graphs, algorithms, and structural induction.

126 examples

071Fundamental

071 — Collatz Conjecture

087Fundamental

087 — Difference of Squares

252Fundamental

Insertion Sort

Sorting Algorithms

796Fundamental

796-counting-paths-dp — Counting Paths

798Fundamental

798-kadane-max-subarray — Kadane's Algorithm

800Fundamental

800-floyd-warshall — Floyd-Warshall Algorithm

801Fundamental

801-prims-mst — Prim's Minimum Spanning Tree

802Fundamental

802-kruskals-mst — Kruskal's Minimum Spanning Tree

804Fundamental

804-tarjan-scc — Tarjan's Strongly Connected Components

805Fundamental

805-kosaraju-scc — Kosaraju's Strongly Connected Components

809Fundamental

809-max-flow-ford-fulkerson — Max Flow (Ford-Fulkerson with BFS)

810Fundamental

810-eulerian-path — Eulerian Path

816Fundamental

Rabin-Karp Rolling Hash

819Fundamental

Z-Algorithm String Matching

822Fundamental

Burrows-Wheeler Transform

829Fundamental

Chinese Remainder Theorem

830Fundamental

Euler's Totient Function

831Fundamental

Miller-Rabin Primality Test

832Fundamental

Extended Euclidean Algorithm

833Fundamental

Discrete Logarithm — Baby-Step Giant-Step

836Fundamental

Line Segment Intersection

837Fundamental

Closest Pair of Points — Divide and Conquer

839Fundamental

Sweep Line Algorithm

840Fundamental

Divide and Conquer Pattern

844Fundamental

Greedy Algorithm Patterns

845Fundamental

Randomized Quickselect

846Fundamental

Monte Carlo Pattern

936Fundamental

936-mutual-recursion — Mutual Recursion

028Intermediate

028 — Sorting a List of Lists According to Length

068Intermediate

068 — Tail-Recursive Accumulator

069Intermediate

069 — Sieve of Eratosthenes

071Intermediate

071 — GCD and LCM

075Intermediate

075 — Merge Sort

076Intermediate

076 — GCD and LCM (Ownership Focus)

251Intermediate

Quicksort

Sorting algorithms

253Intermediate

Graph BFS

254Intermediate

Graph DFS

MemoizationHigher-Order Functions

256Intermediate

Memoization — Fibonacci with Hashtable Cache

273Intermediate

Fibonacci Variants

RecursionIterationAccumulatorsFold

377Intermediate

377: Graph — Adjacency List

378Intermediate

378: Graph — Adjacency Matrix

784Intermediate

784-fibonacci-memo-tab — Fibonacci: Memoization vs Tabulation

786Intermediate

786-longest-common-subsequence — Longest Common Subsequence

788Intermediate

788-coin-change-dp — Coin Change

789Intermediate

789-longest-increasing-subsequence — Longest Increasing Subsequence

793Intermediate

793-minimum-path-sum — Minimum Path Sum

797Intermediate

797-range-minimum-query — Range Minimum Query (Sparse Table)

812Intermediate

812-graph-coloring — Graph Coloring

813Intermediate

813-minimum-vertex-cover — Minimum Vertex Cover (Trees)

824Intermediate

Sieve of Eratosthenes

825Intermediate

Prime Factorization

826Intermediate

GCD and LCM — Euclidean Algorithm

827Intermediate

Modular Arithmetic

828Intermediate

Modular Exponentiation

835Intermediate

Point-in-Polygon Test

937Intermediate

937-tail-recursive-accumulator — Tail-Recursive Accumulator

940Intermediate

940 Gcd Lcm

948Intermediate

948 Merge Sort

1004Intermediate

1004 — Quicksort

1037Intermediate

1037-adjacency-list — Adjacency List Graph

1038Intermediate

1038-adjacency-matrix — Adjacency Matrix Graph

1051Intermediate

1051-fibonacci-memo — Fibonacci with Memoization

1052Intermediate

1052-fibonacci-dp — Fibonacci Bottom-Up DP

1053Intermediate

1053-coin-change — Coin Change

1055Intermediate

1055-longest-common-subseq — Longest Common Subsequence

1058Intermediate

1058-longest-increasing-subseq — Longest Increasing Subsequence

1064Intermediate

1064-permutations — Generate All Permutations

1068Intermediate

1068-maze-solver — Maze Solver

1069Intermediate

1069-graph-coloring — Graph Coloring

1123Intermediate

1123-sorting-algorithmsquicksort — Quicksort

073Advanced

073 — Topological Sort

078Advanced

078 — Topological Sort (Ownership Focus)

Graph AlgorithmsPriority QueuesFunctional Data Structures

100Advanced

Dijkstra's Shortest Path

117Advanced

Recursive Types

197Advanced

Trampoline

215Advanced

Recursion Schemes — Separating What From How

Recursion Schemes

595Advanced

Trampoline Pattern

785Advanced

785-knapsack-01 — 0/1 Knapsack Problem

792Advanced

792-rod-cutting-dp — Rod Cutting Problem

795Advanced

795-subset-sum-dp — Subset Sum

799Advanced

799-bellman-ford — Bellman-Ford Algorithm

803Advanced

803-a-star-pathfinding — A* Pathfinding

806Advanced

806-articulation-points — Articulation Points

807Advanced

807-bipartite-check — Bipartite Check

808Advanced

808-topological-sort-dfs — Topological Sort (DFS)

811Advanced

811-hamiltonian-backtrack — Hamiltonian Path (Backtracking)

815Advanced

Boyer-Moore String Search

817Advanced

Aho-Corasick Multi-Pattern Search

818Advanced

Suffix Array

834Advanced

Convex Hull — Graham Scan

841Advanced

Backtracking Framework

842Advanced

Branch and Bound

843Advanced

Generic Memoization

847Advanced

Approximation Algorithm — Set Cover

848Advanced

Algorithm Complexity Guide

1054Advanced

1054-knapsack-01 — 0/1 Knapsack

1059Advanced

1059-rod-cutting — Rod Cutting

1060Advanced

1060-partition-equal-subset — Partition Equal Subset Sum

1062Advanced

1062-n-queens — N-Queens

1063Advanced

1063-sudoku-solver — Sudoku Solver

1066Advanced

1066-subsets-power-set — Subsets / Power Set

1070Advanced

1070-hamiltonian-path — Hamiltonian Path

1071Advanced

1071-regex-matching — Regex Matching with . and *

1072Advanced

1072-wildcard-matching — Wildcard Matching

1073Advanced

1073-burst-balloons — Burst Balloons

1074Advanced

1074-egg-drop — Egg Drop

1075Advanced

1075-stone-game — Stone Game (Minimax DP)

1080Advanced

Topological Sort via Kahn's Algorithm

1099Advanced

Dijkstra's Shortest Path with Priority Queue

GraphsPriority Queues

1110Advanced

Dijkstra's Shortest Path — Priority Queue

GraphsAlgorithms

1113Advanced

0/1 Knapsack with Dynamic Programming (Functional Style)

1147Advanced

Dijkstra's Shortest Path — Functional Priority Queue

GraphsAlgorithms

1164Advanced

Shortest Path Algorithm with Functional Priority Queue

1167Advanced

0/1 Knapsack Solved with Memoized Recursion

Dynamic ProgrammingFunctional Algorithms

1169Advanced

Dijkstra's Shortest Path with a Priority Queue

GraphsAlgorithms

1173Advanced

Knapsack Problem — Dynamic Programming (Functional)

080Expert

080 — Catamorphism

098Expert

098 — Church Numerals

198Expert

Church Encoding

216Expert

Fix Point — How Recursive Types Work Under the Hood

217Expert

Catamorphism — The Universal Fold

596Expert

Church encoding rust

608Expert

Catamorphism

934Expert

934-church-numerals — Church Numerals

946Expert

946 Catamorphism

1076Expert

Y Combinator — Anonymous Recursion