Understanding UTXO References in Transactions with Rust: A Practical Guide In blockchain and cryptocurrency systems, UTXO (Unspent Transaction Output) is a critical concept. Transactions consume UTXOs from previous transactions and create new ones for future use. This tutorial will guide you through using Rust to search for transactions referencing specific UTXOs using efficient data structures […]
Let’s assume we have a list of numbers, and we want to transform them into a list of structs: into_iter(): Consumes the original collection, turning it into an iterator. enumerate(): Adds an index (id) to each item. map(): Applies a closure to transform each item. collect(): Gathers the transformed items into a collection (e.g., Vec). […]
Comparison: impl Fn vs Box<dyn Fn> 1. Using impl Fn (Static Dispatch) Explanation: 2. Using Box<dyn Fn> (Dynamic Dispatch) Explanation: Key Differences: Feature impl Fn (Static Dispatch) Box<dyn Fn> (Dynamic Dispatch) Dispatch Type Compile-time (Static Dispatch) Run-time (Dynamic Dispatch) Performance Faster (No heap allocation) Slower (Heap allocation + Indirection) Flexibility Less flexible (Fixed closure type) […]
While most examples for performing embeddings will be Python code, Rust is better when performance, safety, and scalability are critical. Most examples/tutorials stick to Python, maybe it’s easier to start with but let’s look beyond “getting started”. Let’s explore Qdrant some more, this time we’ll delve into the Rust client plus fastembed. (Note: If you […]
Tokio is an asynchronous runtime for Rust. “It provides the building blocks needed for writing network applications.” – It’s pretty much the de-facto standard for Rust! Before we look at “spawn” let’s review what tokio is, how to use it, and look at what tasks are. tokio::main The #[tokio::main] function is a macro. It transforms […]
TL;DR – use the “R” in RwLock as “R” for READ – i.e when there are lots of reads/Read mostly, use RwLock Choosing between a Mutex and an RwLock in Rust depends on the nature of the access patterns and the trade-offs you’re willing to make in your program’s concurrency model. Here’s a detailed breakdown […]
In this article, we will explore how to format and display byte data in Rust. Specifically, we’ll focus on a simple program that formats a secret (a Vec<u8>, or vector of bytes) as a binary string. Understanding the Code Here is the Rust code that we will break down: 1. Defining the Struct In this […]
Bitwise operations When working with data processing in Rust, there are times you may need to efficiently combine elements from an array into a single variable. This tutorial explains how to take four elements from a 1D array of bytes (u8) at a time and pack them into a single 4-byte variable (u32). This approach […]
Here’s an example demonstrating how to use lazy_static to initialize a global logger with thread-safe access in Rust. The code is structured to illustrate safe concurrency and the advantages of lazy initialization while remaining simple enough for a beginner to grasp. lazy_static: Mutex for Thread Safety: Global Logger: Future Expansion:
using the criterion crate This is a very very basic demo I made to learn how to benchmark my own function. I made a new project, added a lib.rs and then made a function inside lib.rs called “cycler” This is a tiny function so won’t really make full use of the benchmarks but I wanted […]