src/libcore/array.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Implementations of things like `Eq` for fixed-length arrays
  12 //! up to a certain length. Eventually we should able to generalize
  13 //! to all lengths.
  14
  15 #![experimental] // not yet reviewed
  16
  17 use clone::Clone;
  18 use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
  19 use fmt;
  20 use kinds::Copy;
  21 use ops::Deref;
  22 use option::Option;
  23
  24 // macro for implementing n-ary tuple functions and operations
  25 macro_rules! array_impls {
  26     ($($N:expr)+) => {
  27         $(
  28             #[stable]
  29             impl<T:Copy> Clone for [T; $N] {
  30                 fn clone(&self) -> [T; $N] {
  31                     *self
  32                 }
  33             }
  34
  35             #[unstable = "waiting for Show to stabilize"]
  36             impl<T:fmt::Show> fmt::Show for [T; $N] {
  37                 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  38                     fmt::Show::fmt(&self[], f)
  39                 }
  40             }
  41
  42             #[stable]
  43             impl<A, B> PartialEq<[B; $N]> for [A; $N] where A: PartialEq<B> {
  44                 #[inline]
  45                 fn eq(&self, other: &[B; $N]) -> bool {
  46                     self[] == other[]
  47                 }
  48                 #[inline]
  49                 fn ne(&self, other: &[B; $N]) -> bool {
  50                     self[] != other[]
  51                 }
  52             }
  53
  54             #[stable]
  55             impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; $N] where
  56                 A: PartialEq<B>,
  57                 Rhs: Deref<Target=[B]>,
  58             {
  59                 #[inline(always)]
  60                 fn eq(&self, other: &Rhs) -> bool { PartialEq::eq(self[], &**other) }
  61                 #[inline(always)]
  62                 fn ne(&self, other: &Rhs) -> bool { PartialEq::ne(self[], &**other) }
  63             }
  64
  65             #[stable]
  66             impl<'a, A, B, Lhs> PartialEq<[B; $N]> for Lhs where
  67                 A: PartialEq<B>,
  68                 Lhs: Deref<Target=[A]>
  69             {
  70                 #[inline(always)]
  71                 fn eq(&self, other: &[B; $N]) -> bool { PartialEq::eq(&**self, other[]) }
  72                 #[inline(always)]
  73                 fn ne(&self, other: &[B; $N]) -> bool { PartialEq::ne(&**self, other[]) }
  74             }
  75
  76             #[stable]
  77             impl<T:Eq> Eq for [T; $N] { }
  78
  79             #[stable]
  80             impl<T:PartialOrd> PartialOrd for [T; $N] {
  81                 #[inline]
  82                 fn partial_cmp(&self, other: &[T; $N]) -> Option<Ordering> {
  83                     PartialOrd::partial_cmp(&self[], &other[])
  84                 }
  85                 #[inline]
  86                 fn lt(&self, other: &[T; $N]) -> bool {
  87                     PartialOrd::lt(&self[], &other[])
  88                 }
  89                 #[inline]
  90                 fn le(&self, other: &[T; $N]) -> bool {
  91                     PartialOrd::le(&self[], &other[])
  92                 }
  93                 #[inline]
  94                 fn ge(&self, other: &[T; $N]) -> bool {
  95                     PartialOrd::ge(&self[], &other[])
  96                 }
  97                 #[inline]
  98                 fn gt(&self, other: &[T; $N]) -> bool {
  99                     PartialOrd::gt(&self[], &other[])
 100                 }
 101             }
 102
 103             #[stable]
 104             impl<T:Ord> Ord for [T; $N] {
 105                 #[inline]
 106                 fn cmp(&self, other: &[T; $N]) -> Ordering {
 107                     Ord::cmp(&self[], &other[])
 108                 }
 109             }
 110         )+
 111     }
 112 }
 113
 114 array_impls! {
 115      0  1  2  3  4  5  6  7  8  9
 116     10 11 12 13 14 15 16 17 18 19
 117     20 21 22 23 24 25 26 27 28 29
 118     30 31 32
 119 }