如何避免在Rust中爲可變和不可變引用編寫重複訪問器函數？

Question

有幾次，我碰到了一個場景，在這個場景中，可變參數和不可變參考都需要訪問器方法。

對於〜3行，複製邏輯不是問題，但是當邏輯變得更復雜時，複製粘貼大塊代碼並不好。

我希望能夠重新使用兩者的代碼。

Rust是否提供了一些方法來處理這個問題，然後複製粘貼代碼或使用unsafe強制轉換？

例如爲：

impl MyStruct { 
    pub fn get_foo(&self) -> &Bar { 
     // ~20 lines of code 
     // --- snip --- 
     return bar; 
    } 
    pub fn get_foo_mut(&mut self) -> &mut Bar { 
     // ~20 lines of code 
     // (exactly matching previous code except `bar` is mutable) 
     // --- snip --- 
     return bar; 
    } 
} 

---

這裏是一個代碼庫，其中一個不變的返回參數被轉換爲可變的，以支持功能的兩個可變和不可變版本的更詳細的摘錄。這使用包裝的指針類型（ConstP和MutP用於不可變和可變引用），但函數的邏輯應該清楚。

pub fn face_vert_share_loop<V, F>(f: F, v: V) -> LoopConstP 
    where V: Into<VertConstP>, 
      F: Into<FaceConstP> 
{ 
    into_expand!(f, v); 

    let l_first = f.l_first.as_const(); 
    let mut l_iter = l_first; 
    loop { 
     if l_iter.v == v { 
      return l_iter; 
     } 

     l_iter = l_iter.next.as_const(); 
     if l_iter == l_first { 
      break; 
     } 
    } 

    return null_const(); 
} 
pub fn face_vert_share_loop_mut(f: FaceMutP, v: VertMutP) -> LoopMutP { 
    let l = face_vert_share_loop(f, v); 
    return unsafe { 
     // Evil! but what are the alternatives? 
     // Perform an unsafe `const` to `mut` cast :(
     // While in general this should be avoided, 
     // its 'OK' in this case since input is also mutable. 
     l.as_mut() 
    }; 
} 

Answer 1

你沒有，真的。回想一下，T,&T和&mut T都是不同類型。在這種情況下，您的問題與「如何避免爲String和HashMap寫入重複訪問器函數」相同。

馬蒂厄中號有正確的術語 「抽象的過度易變性」：

• Parameterisation over mutability
• Dealing with &/&mut in data structures: abstract over mutability or split types?
• A safe way to reuse the same code for immutable and mutable variants of a function?
• Abstracting over mutability in Rust
• "Mutability polymorphism"
• 等等，等等等等

TL; DR是Rust可能需要增加新功能來支持這一點。由於沒有人成功，沒有人百分之百地確定那些特徵是需要的。目前最好的猜測是更高的激活類型（HKT）。

Answer 2

當前Rust不支持對可變性進行抽象。

有一些方法可以做到這一點，雖然他們並不理想：

• 使用宏來擴大重複的代碼，聲明宏觀和兩個功能之間共享 - 需要構建所以當然適用於可變和不可變。
• 編寫該函數的不可變版本（以確保沒有任何更改），然後爲可變版本編寫一個包裝函數，該函數對結果執行unsafe轉換以使其變爲可變。

這些都不是非常有吸引力的（宏過於冗長，有點不太可讀，添加一些代碼膨脹），該unsafe更具可讀性，但它會很高興，以避免因爲從一成不變的鑄造可變通過代碼庫不太好。

就我所能看到的（其中複製粘貼代碼不可接受）而言，現在是最好的選擇，就是編寫一個不可變的函數版本，然後用一個mut版本的函數包裝它，其中兩個輸入並且輸出是可變的。

這需要在該功能的輸出上鑄造一個unsafe，因此它並不理想。

---

注意：它有不可改變的功能包含代碼的身體，由於反向將允許什麼可能是一成不變的輸入偶然的不同誘變是很重要的。

Answer 3

（操場鏈接使用type parameters和associated types解決方案）

在這種情況下&T和&mut T只是兩個不同的類型。通過不同類型（在編譯時和運行時）通用的代碼通常使用traits在Rust中編寫。例如，給定：

struct Foo { value: i32 } 
struct Bar { foo: Foo } 

假設我們要提供Bar與它Foo數據成員的通用訪問。訪問者應在&Bar和&mut Bar上適當地返回&Foo或&mut Foo。因此，我們寫一個特點FooGetter

trait FooGetter { 
    type Output; 
    fn get(self) -> Self::Output; 
} 

，他們的工作是要在特定類型的Bar，我們有通用的。其Output類型將取決於Bar，因爲我們想要get有時返回&Foo有時&mut Foo。另請注意，它消耗self類型Self。因爲我們想get是通用在&Bar和&mut Bar我們需要實現FooGetter兩個，讓Self具有相應類型：

// FooGetter::Self == &Bar 
impl<'a> FooGetter for &'a Bar { 
    type Output = &'a Foo; 
    fn get(self) -> Self::Output { & self.foo } 
} 

// FooGetter::Self == &mut Bar 
impl<'a> FooGetter for &'a mut Bar { 
    type Output = &'a mut Foo; 
    fn get(mut self) -> Self::Output { &mut self.foo } 
} 

現在我們可以很容易地使用.get()在通用的代碼，即可獲得&或&mut引用Foo從&Bar或&mut Bar（僅需要T: FooGetter）。例如：

// exemplary generic function: 
fn foo<T: FooGetter>(t: T) -> <T as FooGetter>::Output { 
    t.get() 
} 

fn main() { 
    let x = Bar { foo: Foo {value: 2} }; 
    let mut y = Bar { foo: Foo {value: 2} }; 

    foo(&mut y).value = 3; 
    println!("{} {}\n", foo(&x).value, foo(&mut y).value); 
} 

請注意，您也可以實現FooGetter爲Bar，使get是通用在&T，&mut T和T本身（在移動它）。這實際上是如何在標準庫中實現.iter()方法的，以及它爲什麼始終做到「正確的事情」而不依賴於它所調用的參數的參考性。