ownership – Tarik Billa

Proper way of transferring ownership of a std::vector< std::unique_ptr< int> > to a class being constructed

January 8, 2024 by Tarik

std::unique_ptr<T> is a non-copyable but movable type. Having a move-only type in a std:vector<T> make the std::vector<T> move-only, too. To have the compiler automatically move objects, you need to have an r-value for move-construction or move-assignment. Within your constructor the object vecOfIntPtrsOwnedByCaller is an l-value, although one which, despite its name, already owns the pointed … Read more

What is the right way to store an immutable Path in a struct?

December 26, 2023 by Tarik

This question is almost the same as String vs &str , if that helps. PathBuf is String, &Path is &str. So: Store a PathBuf if you want the struct to own it. If you don’t know what you want, start here. Store a &Path if you just want a reference to a path. Depending on … Read more

Implement graph-like data structure in Rust

November 28, 2023 by Tarik

Modeling graph-like structures in Rust is not a simple problem. Here there are two valuable discussions from Nick Cameron and Niko Matsakis (two main Rust developers at Mozilla.) Graphs and arena allocation Modeling Graphs in Rust Using Vector Indices

Do mutable references have move semantics?

September 11, 2023 by Tarik

You are completely right with both your reasoning and your observations. It definitely looks like things should be happening the way you describe it. However, the compiler applies some convenience magic here. Move semantics generally apply in Rust for all types that do not implement the Copy trait. Shared references are Copy, so they are … Read more

What are move semantics in Rust?

June 8, 2023 by Tarik

Semantics Rust implements what is known as an Affine Type System: Affine types are a version of linear types imposing weaker constraints, corresponding to affine logic. An affine resource can only be used once, while a linear one must be used once. Types that are not Copy, and are thus moved, are Affine Types: you … Read more

How to convert Option to Option in the most idiomatic way in Rust?

June 3, 2023 by Tarik

Option comes with utility methods for various transformations, which are listed in its documentation. For any T that implements Clone (which String does), Option<&T>::cloned does what you’re looking for. Clone is more specific than ToOwned, so .cloned() isn’t an exact match for .map(|x| x.to_owned()). For example, it won’t turn an Option<&str> into an Option<String>; for … Read more

how to find the owner of a file or directory in python

May 19, 2023 by Tarik

I’m not really much of a python guy, but I was able to whip this up: from os import stat from pwd import getpwuid def find_owner(filename): return getpwuid(stat(filename).st_uid).pw_name

Convert Vec into a slice of &str in Rust?

April 24, 2023 by Tarik

You can create a function that accepts both &[String] and &[&str] using the AsRef trait: fn test<T: AsRef<str>>(inp: &[T]) { for x in inp { print!(“{} “, x.as_ref()) } println!(“”); } fn main() { let vref = vec![“Hello”, “world!”]; let vown = vec![“May the Force”.to_owned(), “be with you.”.to_owned()]; test(&vref); test(&vown); }

What is the difference between a weak and a block reference?

February 5, 2023 by Tarik

From the docs about __block __block variables live in storage that is shared between the lexical scope of the variable and all blocks and block copies declared or created within the variable’s lexical scope. Thus, the storage will survive the destruction of the stack frame if any copies of the blocks declared within the frame … Read more

Does println! borrow or own the variable?

February 2, 2023 by Tarik

The macros print!, println!, eprint!, eprintln!, write!, writeln! and format! are a special case and implicitly take a reference to any arguments to be formatted. These macros do not behave as normal functions and macros do for reasons of convenience; the fact that they take references silently is part of that difference. fn main() { … Read more