Rust: From & str to Cow

One of the first things I wrote in Rust was a &strfield structure . As you know, the borrowing analyzer did not allow me to do many things with it and severely limited the expressiveness of my APIs. This article aims to demonstrate the problems that arise when storing raw & str links in structure fields and their solutions. In the process, I'm going to show some intermediate API that increases the usability of such structures, but at the same time reduces the efficiency of the generated code. In the end, I want to provide an implementation that will be both expressive and highly effective.

Let's imagine that we are making some kind of library to work with the example.com site API, and we will sign each call with a token, which we define as follows:

// Token для example.io API
pub struct Token<'a> {
    raw: &'a str,
}

Then we implement a function newthat will create an instance of the token from &str.

impl<'a> Token<'a> {
    pub fn new(raw: &'a str) -> Token<'a> {
        Token { raw: raw }
    }
}

Such a naive token only works well for static lines &'static strthat are directly embedded in the binary. However, let's say that the user does not want to embed the secret key in the code, or he wants to load it from some secret store. We could write code like this:

// Вообразим, что такая функция существует
let secret: String = secret_from_vault("api.example.io");
let token = Token::new(&secret[..]);

Such an implementation has a big limitation: the token cannot survive the secret key, which means that it cannot leave this area of ​​the stack.
But what if Tokenit stores Stringinstead &str? This will help us get rid of the parameter indicating the lifetime of the structure, turning it into an owning type.

Let's make changes to Token and the new function.

struct Token {
    raw: String,
}
impl Token {
    pub fn new(raw: String) -> Token {
        Token { raw: raw }
    }
}

All places where provided Stringmust be corrected:

// Это работает сейчас
let token = Token::new(secret_from_vault("api.example.io"))

However, it harms usability &'str. For example, such code will not compile:

// не собирается
let token = Token::new("abc123");

The user of this API will need to explicitly convert &'strto String.

let token = Token::new(String::from("abc123"));

You can try to use &strnew Stringin the function instead , hiding it String::fromin the implementation, but in the case Stringit will be less convenient and require additional allocation of memory on the heap. Let's see how it looks.

// функция new выглядит как-то так
impl Token {
    pub fn new(raw: &str) -> Token {
        Token(String::from(raw))
    }
}
// &str может передана беспрепятственно
let token = Token::new("abc123");
// По-прежнему можно использовать String, но необходимо пользоваться срезами
// и функция new должна будет скопировать данные из них
let secret = secret_from_vault("api.example.io");
let token = Token::new(&secret[..]); // неэффективно!

However, there is a way to force new to accept arguments of both types without the need for memory allocation in the case of passing a String.

Meet Into

There is a trait in the standard library Intothat will help solve our problem with new. The type definition looks like this:

pub trait Into {
    fn into(self) -> T;
}

A function is intodefined quite simply: it takes away self(something that implements Into) and returns a type value T. Here is an example of how this can be used:

impl Token {
    // Создание нового токена
    //
    // Может принимать как &str так и String
    pub fn new(raw: S) -> Token
        where S: Into
    {
        Token { raw: raw.into() }
    }
}
// &str
let token = Token::new("abc123");
// String
let token = Token::new(secret_from_vault("api.example.io"));

pub enum Cow<'a, B> where B: 'a + ToOwned + ?Sized {
    Borrowed(&'a B),
    Owned(B::Owned),
}

enum Cow<'a, str> {
    Borrowed(&'a str),
    Owned(String),
}

struct Token<'a> {
    raw: Cow<'a, str>
}
impl<'a> Token<'a> {
    pub fn new(raw: Cow<'a, str>) -> Token<'a> {
        Token { raw: raw }
    }
}
// создание этих токенов
let token = Token::new(Cow::Borrowed("abc123"));
let secret: String = secret_from_vault("api.example.io");
let token = Token::new(Cow::Owned(secret));

struct Token<'a> {
    raw: Cow<'a, str>
}
impl<'a> Token<'a> {
    pub fn new(raw: S) -> Token<'a>
        where S: Into>
    {
        Token { raw: raw.into() }
    }
}
// создаем токены.
let token = Token::new("abc123");
let token = Token::new(secret_from_vault("api.example.io"));

let raw = String::from("abc");
let token_owned = Token::new(raw);
let token_static = Token::new("123");
thread::spawn(move || {
    println!("token_owned: {:?}", token_owned);
    println!("token_static: {:?}", token_static);
}).join().unwrap();

// Сделаем ссылку с нестатическим временем жизни
let raw = String::from("abc");
let s = &raw[..];
let token = Token::new(s);
// Это не будет работать
thread::spawn(move || {
    println!("token: {:?}", token);
}).join().unwrap();

error: `raw` does not live long enough

impl Into for T where U: From {
    fn into(self) -> U {
        U::from(self)
    }
}