How to repeat a static string at compile time

by

You cannot do such a thing in stable Rust. Your example of 1000 * "abc" is not run at “compile time” in Python either, as far as I understand Python.

Including a file

If it has to be static, you could use a Cargo build script. This is a bit of Rust code that can do lots of things before your code is actually compiled. Specifically, you could write a source file out that has your string and then use include_str! to bring it into your crate:

build.rs

use std::{
    env, error::Error, fs::File, io::{BufWriter, Write}, path::Path,
};

fn main() -> Result<(), Box<Error>> {
    let out_dir = env::var("OUT_DIR")?;
    let dest_path = Path::new(&out_dir).join("long_string.txt");
    let mut f = BufWriter::new(File::create(&dest_path)?);

    let long_string = "abc".repeat(100);
    write!(f, "{}", long_string)?;

    Ok(())
}

lib.rs

static LONG_STRING: &'static str = include_str!(concat!(env!("OUT_DIR"), "/long_string.txt"));

Lazy initialization

You could create a once_cell or lazy_static value that would create your string at runtime, but only once.

use once_cell::sync::Lazy; // 1.5.2

static LONG_STR: Lazy<String> = Lazy::new(|| "abc".repeat(5000));

See also:

The far future

At some point, RFC 911 will be fully implemented. This, plus a handful of additional RFCs, each adding new functionality, will allow you to be able to write something like:

// Does not work yet!
static LONG_STR: String = "abc".repeat(1000);

More Related Contents:

  1. What are non-lexical lifetimes?
  2. What does “Sized is not implemented” mean?
  3. Deriving a trait results in unexpected compiler error, but the manual implementation works
  4. How do I implement Copy and Clone for a type that contains a String (or any type that doesn’t implement Copy)?
  5. Mutably borrow one struct field while borrowing another in a closure
  6. How do I convert a Vector of bytes (u8) to a string?
  7. Can I write an Iterator that mutates itself and then yields a reference into itself?
  8. How to update-or-insert on a Vec?
  9. Lifetime troubles sharing references between threads
  10. Moved variable still borrowing after calling `drop`?
  11. How do I include the end value in a range?
  12. How do I specify lifetime parameters in an associated type?
  13. How do I invoke a system command and capture its output?
  14. How to return a string (or similar) from Rust in WebAssembly?
  15. Can I destructure a tuple without binding the result to a new variable in a let/match/for statement?
  16. How to format output to a byte array with no_std and no allocator?
  17. What is the right way to allocate data to pass to an FFI call?
  18. Efficiently insert or replace multiple elements in the middle or at the beginning of a Vec?
  19. Calling a generic async function with a (mutably) borrowed argument
  20. Read large files line by line in Rust [duplicate]
  21. Why is it discouraged to accept a reference &String, &Vec, or &Box as a function argument?
  22. What makes `impl Trait` as an argument “universal” and as a return value “existential”?
  23. How to represent shared mutable state?
  24. Mutable reference to container object within iterator loop
  25. How can I pull data out of an Option for independent use?
  26. Mutable self while reading from owner object
  27. How to idiomatically alias a crate in Rust 2018?
  28. Why do I get “does not live long enough” in a return value?
  29. Why does the compiler not complain that an iterator moved to a for loop is immutable?
  30. Why doesn’t the lifetime of a mutable borrow end when the function call is complete?

Leave a Comment