You don’t need the mod hello in your hello.rs file. Code in any file but the crate root (main.rs for executables, lib.rs for libraries) is automatically namespaced in a module. To include the code from hello.rs in your main.rs, use mod hello;. It gets expanded to the code that is in hello.rs (exactly as you … Read more
Summary: below 240, LLVM fully unrolls the inner loop and that lets it notice it can optimize away the repeat loop, breaking your benchmark. You found a magic threshold above which LLVM stops performing certain optimizations. The threshold is 8 bytes * 240 = 1920 bytes (your array is an array of usizes, therefore the … Read more
The other answers all have salient points (fjh’s concrete example where an explicit lifetime is needed), but are missing one key thing: why are explicit lifetimes needed when the compiler will tell you you’ve got them wrong? This is actually the same question as “why are explicit types needed when the compiler can infer them”. … Read more
Non-answer answer Avoid global state in general. Instead, construct the object somewhere early (perhaps in main), then pass mutable references to that object into the places that need it. This will usually make your code easier to reason about and doesn’t require as much bending over backwards. Look hard at yourself in the mirror before … Read more
All string literals can be broken across several lines; for example: let string = “line one line two”; is a two line string, the same as “line one\nline two” (of course one can use the \n newline escape directly too). If you wish to just break a string across multiple lines for formatting reasons you … Read more
Use split() let mut split = “some string 123 ffd”.split(“123”); This gives an iterator, which you can loop over, or collect() into a vector. for s in split { println!(“{}”, s) } let vec = split.collect::<Vec<&str>>(); // OR let vec: Vec<&str> = split.collect();
Rust uses static linking to compile its programs, meaning that all libraries required by even the simplest Hello world! program will be compiled into your executable. This also includes the Rust runtime. To force Rust to dynamically link programs, use the command-line arguments -C prefer-dynamic; this will result in a much smaller file size but … Read more
Your pseudo-code is pretty much correct. For this example, suppose we had a method call foo.bar() where foo: T. I’m going to use the fully qualified syntax (FQS) to be unambiguous about what type the method is being called with, e.g. A::bar(foo) or A::bar(&***foo). I’m just going to write a pile of random capital letters, … Read more
Managing the lifetimes of garbage-collected objects [closed]
Tok:tmp doug$ du -a 8 ./Cargo.toml 8 ./src/bin.rs 8 ./src/lib.rs 16 ./src Cargo.toml: [package] name = “mything” version = “0.0.1” authors = [“me <me@gmail.com>”] [lib] name = “mylib” path = “src/lib.rs” [[bin]] name = “mybin” path = “src/bin.rs” src/lib.rs: pub fn test() { println!(“Test”); } src/bin.rs: extern crate mylib; // not needed since Rust edition … Read more