最初に非等価な結果を返す最も簡単な方法は何ですか？

Question

比較できる複数のメンバーを持つ構造体、またはsort_byコールバックの場合は、データを優先順位と比較することがよくあります。

// Example of sorting a: Vec<[f64; 2]>, sort first by y, then x, 
xy_coords.sort_by(
    |co_a, co_b| { 
     let ord = co_a[1].cmp(&co_b[1]); 
     if ord != std::cmp::Ordering::Equal { 
      ord 
     } else { 
      co_a[0].cmp(&co_b[0]) 
     } 
    } 
); 

のみ最初の非同等の結果が返された複数のcmp機能を実行するために、より簡単な方法はありますか？

Answer 1

は、最初の非等しい結果Ordはタプルのために定義される方法は基本的だつまり

返される複数のCMP機能を実行します。タプルにあなたのタイプを変換する関数を作成し、それらを比較します。それは一般的ですので

fn main() { 
    let mut xy_coords = vec![[1, 0], [-1, -1], [0, 1]]; 

    fn sort_key(coord: &[i32; 2]) -> (i32, i32) { 
     (coord[1], coord[0]) 
    } 

    xy_coords.sort_by(|a, b| { 
     sort_key(a).cmp(&sort_key(b)) 
    }); 
} 

は、ちょうどそれのための方法があります：それはfloating point doesn't implement Ordので、あなたのケースを助けにはなりません

xy_coords.sort_by_key(sort_key); 

。

多くの可能性の一つはNaN上のプログラムを殺すためにある：

xy_coords.sort_by(|a, b| { 
    sort_key(a).partial_cmp(&sort_key(b)).expect("Don't know how to handle NaN") 
}); 

も参照してください

• Using max_by_key on a vector of floats
• How to do a binary search on a Vec of floats?

---

大きなタプルを作成して値を比較したくない場合があります。優先度の高い値が早期に終了するため無視されます。 Guava's ComparisonChainからページを盗む

、私たちは、私たちは余分な作業を避けるために、クロージャを使用することができます小さなビルダーを行うことができます。

use std::cmp::Ordering; 

struct OrdBuilder<T> { 
    a: T, 
    b: T, 
    ordering: Ordering, 
} 

impl<T> OrdBuilder<T> { 
    fn new(a: T, b: T) -> OrdBuilder<T> { 
     OrdBuilder { 
      a: a, 
      b: b, 
      ordering: Ordering::Equal, 
     } 
    } 

    fn compare_with<F, V>(mut self, mut f: F) -> OrdBuilder<T> 
     where F: for <'a> FnMut(&'a T) -> V, 
       V: Ord, 
    { 
     if self.ordering == Ordering::Equal { 
      self.ordering = f(&self.a).cmp(&f(&self.b)); 
     } 
     self 
    } 

    fn finish(self) -> Ordering { 
     self.ordering 
    } 
} 

これは、この答えは

struct Thing { 
    a: u8, 
} 

impl Thing { 
    fn b(&self) -> u8 { 
     println!("I'm slow!"); 
     42 
    } 
} 

fn main() { 
    let a = Thing { a: 0 }; 
    let b = Thing { a: 1 }; 

    let res = OrdBuilder::new(&a, &b) 
     .compare_with(|x| x.a) 
     .compare_with(|x| x.b()) 
     .finish(); 

    println!("{:?}", res); 
}