Почему String::push_str() принимает и &str и &string

https://habrahabr.ru/post/274485/

Спасибо, читну

Там работает Deref Coersion.

Взятие ссылки от String приводится к &str.

Сложна

А, вот:

https://doc.rust-lang.org/std/string/struct.String.html#deref

Я не знаю. Не дочитал еще до таких глубин. В 8 главе внезапно, без объяснения причин начали работать с &string как со &str

Вот про это написано в первой редакции Rust Book'а: https://doc.rust-lang.org/book/first-edition/deref-coercions.html

Паста из первой редакции Книги:

Strings will coerce into &str with an &:

fn takes_slice(slice: &str) {
    println!("Got: {}", slice);
}

fn main() {
    let s = "Hello".to_string();
    takes_slice(&s);
}

This coercion does not happen for functions that accept one of &str’s traits instead of &str. For example, TcpStream::connect has a parameter of type ToSocketAddrs. A &str is okay but a String must be explicitly converted using &*.

use std::net::TcpStream;

TcpStream::connect("192.168.0.1:3000"); // Parameter is of type &str.

let addr_string = "192.168.0.1:3000".to_string();
TcpStream::connect(&*addr_string); // Convert `addr_string` to &str.

Viewing a String as a &str is cheap, but converting the &str to a String involves allocating memory. No reason to do that unless you have to!

Это ещё самый простой вариант, из-за deref. Из-за отсутствия перегрузки методов используют шаблонные методы, типа:

use std::fmt::Debug;

#[derive(Debug)]
enum Value {
    Int(i32),
    Float(f64),
}

impl From<i32> for Value {
    fn from(v: i32) -> Self {
        Value::Int(v)
    }
}

impl From<f64> for Value {
    fn from(v: f64) -> Self {
        Value::Float(v)
    }
}

fn func<V: Into<Value> + Debug>(v: V) {
    println!("{:?}", v.into());
}

fn main() {
    func(1);
    func(1.5);
}

http://hermanradtke.com/2015/05/06/creating-a-rust-function-that-accepts-stri...

Зачем хабрапомойка, если если оригинал: http://hermanradtke.com/2015/05/03/string-vs-str-in-rust-functions.html

Всем спасибо

А вот это тоже deref coercion?

fn main() {
    let mut s1: String = "Hello".to_string();
    s1 = s1 + ", world";
    s1 = s1 + &"!";
    println!("{}", s1);
}

+ - это функция add, которая принимает &str. Но она прекрасно съедает и &«str» и просто «str». И даже &&«str», что уже вообще перебор

Да. Она без проблем заглотит и &&&str, и &&&&str. А ещё Deref Coercions работают не только со строками, но и с вектором (&Vec<T> в &[T]), OsString, CString, Arc, Rc, Box и т.д.

Она без проблем заглотит и &&&str, и &&&&str

Боюсь спросить, а не являются ли ли такие синтаксические вольности источником ошибок?

Полезный паттерн, спасибо. Нечто похожее недавно хотел сделать, но не хватило знаний.

Логических - не исключено, но на себе не замечал.

Хотя если подумать, то в контексте раста разницы межу &T и &&&&T в общем то и нет.

Не бывает ссылок на ссылки?

Ссылка на ссылку - это и есть ссылка. Компилятор уберёт ненужные &.

Можно через clippy прогнать, он скажет где лишние.

Бывает. Но смысла в более чем одном слое ссылок особо нет.

Да, но если нужно переменное число аргументов - придётся с tuple возится. Но в целом тот же код будет.

Хз, почему авторы не сделали перегрузку. Внятных ответов не видел.

Возможно когда нибудь в расте будут дженерики с переменным числом аргементов, а пока что ждём Пи-Типов (:

RFC есть. Ждём.