允許函數接受`T`或任何`FnMut（T） - > T`

Question

我的目標是做最後兩行的代碼編譯，最後斷言的經過：

struct State { 
    string: String 
} 

impl State { 
    fn string<F: FnMut(String) -> String>(mut self, mut f: F) -> Self { 
     self.string = f(self.string); 
     self 
    } 
} 

fn main() { 
    let state = State { string: String::from("foo") }; 
    assert_eq!(state.string, "foo"); 
    let state = state.string(|old| old + "bar"); 
    assert_eq!(state.string, "foobar"); 
    // let state = state.string(String::from("baz")); 
    // assert_eq!(state.string, "baz"); 
} 

我認爲這將是可能的特質和專業化，但下面的代碼：

#![feature(specialization)] 

trait Get<T> { 
    fn get(self, old: T) -> T; 
} 

impl<T> Get<T> for T { 
    default fn get(self, _: T) -> T { 
     self 
    } 
} 

impl<T, F> Get<T> for F where F: FnMut(T) -> T { 
    fn get(mut self, old: T) -> T { 
     self(old) 
    } 
} 

struct State { 
    string: String 
} 

impl State { 
    fn string<G: Get<String>>(mut self, g: G) -> Self { 
     self.string = g.get(self.string); 
     self 
    } 
} 

拋出這個錯誤（live）：

error[E0119]: conflicting implementations of trait `Get<_>`: 
    --> <anon>:13:1 
    | 
13 | impl<T, F> Get<T> for F where F: FnMut(T) -> T { 
    |^
    | 
note: conflicting implementation is here: 
    --> <anon>:7:1 
    | 
7 | impl<T> Get<T> for T { 
    |^

error: aborting due to previous error 

所以我的問題是，爲什麼第二個impl沒有獲得比第一個更具體的「特定」，並且在當前的stable或每晚的Rust中有沒有辦法讓我的原始代碼工作？

編輯：我知道只爲一種類型實現一個特性是可行的，但我想爲任何類型的通用解決方案，因爲我希望能夠使用此結構的任何任意字段。

Answer 1

爲了您的具體問題，你不需要專業化：

struct State { 
    string: String, 
} 

impl State { 
    fn string<F>(mut self, mut f: F) -> Self 
     where F: Thing 
    { 
     self.string = f.thing(self.string); 
     self 
    } 
} 

trait Thing { 
    fn thing(&mut self, s: String) -> String; 
} 

impl Thing for String { 
    fn thing(&mut self, _s: String) -> String { 
     self.clone() 
    } 
} 

impl<F> Thing for F 
    where F: FnMut(String) -> String 
{ 
    fn thing(&mut self, s: String) -> String { 
     (self)(s) 
    } 
} 

fn main() { 
    let state = State { string: String::from("foo") }; 
    assert_eq!(state.string, "foo"); 
    let state = state.string(|old| old + "bar"); 
    assert_eq!(state.string, "foobar"); 
    let state = state.string(String::from("baz")); 
    assert_eq!(state.string, "baz"); 
} 

您既可以想要求FnOnce或實現一個&str的特質。目前，String的分配未被使用，導致一些效率低下。

然後，您可以多次實施的特質對有趣的類型：

struct State { 
    string: String, 
    vec: Vec<u8>, 
} 

impl State { 
    fn string<F>(mut self, mut f: F) -> Self 
     where F: Thing<String> 
    { 
     self.string = f.thing(self.string); 
     self 
    } 

    fn vec<F>(mut self, mut f: F) -> Self 
     where F: Thing<Vec<u8>> 
    { 
     self.vec = f.thing(self.vec); 
     self 
    } 
} 

trait Thing<T> { 
    fn thing(&mut self, s: T) -> T; 
} 

impl Thing<String> for String { 
    fn thing(&mut self, _s: String) -> String { 
     self.clone() 
    } 
} 

impl<F> Thing<String> for F 
    where F: FnMut(String) -> String 
{ 
    fn thing(&mut self, s: String) -> String { 
     (self)(s) 
    } 
} 

impl Thing<Vec<u8>> for Vec<u8> { 
    fn thing(&mut self, _s: Vec<u8>) -> Vec<u8> { 
     self.clone() 
    } 
} 

impl<F> Thing<Vec<u8>> for F 
    where F: FnMut(Vec<u8>) -> Vec<u8> 
{ 
    fn thing(&mut self, s: Vec<u8>) -> Vec<u8> { 
     (self)(s) 
    } 
} 

fn main() { 
    let state = State { string: String::from("foo"), vec: vec![1] }; 

    assert_eq!(state.string, "foo"); 
    let state = state.string(|old| old + "bar"); 
    assert_eq!(state.string, "foobar"); 
    let state = state.string(String::from("baz")); 
    assert_eq!(state.string, "baz"); 

    assert_eq!(state.vec, [1]); 
    let state = state.vec(|mut old: Vec<u8>| { 
     old.push(2); 
     old 
    }); 
    assert_eq!(state.vec, [1, 2]); 
    let state = state.vec(vec![3]); 
    assert_eq!(state.vec, [3]); 
} 

我相信，重複可以通過宏來處理：

macro_rules! thing { 
    ($t: ty) => { 
     impl Thing<$t> for $t { 
      default fn thing(&mut self, _val: $t) -> $t { 
       self.clone() 
      } 
     } 

     impl<F> Thing<$t> for F 
      where F: FnMut($t) -> $t 
     { 
      fn thing(&mut self, val: $t) -> $t { 
       (self)(val) 
      } 
     } 
    } 
} 

thing!(String); 
thing!(Vec<u8>); 

Answer 2

專業化在這裏不起作用，因爲專業化只適用於連鎖店。也就是說，存在滿足impl

impl<T, F> Get<T> for F where F: FnMut(T) -> T 

但不

impl<T> Get<T> for T 

使後者不能專注前者的功能。

解決這個問題的最簡單方法是隻寫一個GetString特徵而不是Get<T>特徵;這樣你就不必考慮專門化這種malarkey了。