stupid_add/

lib.rs

use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
use std::hash::Hash;

pub trait Add {
  fn add(self, rhs: Self) -> Self;
}

impl Add for String {
  fn add(self, rhs: String) -> String {
    self + &rhs
  }
}

impl Add for bool {
  fn add(self, rhs: bool) -> bool {
    self || rhs
  }
}

impl Add for char {
  fn add(self, rhs: char) -> char {
    let new_char = self as u32 + rhs as u32;
    std::char::from_u32(new_char).unwrap()
  }
}

impl Add for u8 {
  fn add(self, rhs: u8) -> u8 {
    self + rhs
  }
}

impl Add for u16 {
  fn add(self, rhs: u16) -> u16 {
    self + rhs
  }
}

impl Add for u32 {
  fn add(self, rhs: u32) -> u32 {
    self + rhs
  }
}

impl Add for u64 {
  fn add(self, rhs: u64) -> u64 {
    self + rhs
  }
}

impl Add for u128 {
  fn add(self, rhs: u128) -> u128 {
    self + rhs
  }
}

impl Add for usize {
  fn add(self, rhs: usize) -> usize {
    self + rhs
  }
}

impl Add for i8 {
  fn add(self, rhs: i8) -> i8 {
    self + rhs
  }
}

impl Add for i16 {
  fn add(self, rhs: i16) -> i16 {
    self + rhs
  }
}

impl Add for i32 {
  fn add(self, rhs: i32) -> i32 {
    self + rhs
  }
}

impl Add for i64 {
  fn add(self, rhs: i64) -> i64 {
    self + rhs
  }
}

impl Add for i128 {
  fn add(self, rhs: i128) -> i128 {
    self + rhs
  }
}

impl Add for isize {
  fn add(self, rhs: isize) -> isize {
    self + rhs
  }
}

impl Add for f32 {
  fn add(self, rhs: f32) -> f32 {
    self + rhs
  }
}

impl Add for f64 {
  fn add(self, rhs: f64) -> f64 {
    self + rhs
  }
}

impl<T> Add for Vec<T>
where
  T: Add,
{
  fn add(mut self, rhs: Vec<T>) -> Vec<T> {
    self.extend(rhs);
    self
  }
}

impl<T> Add for LinkedList<T>
where
  T: Add,
{
  fn add(mut self, rhs: LinkedList<T>) -> LinkedList<T> {
    self.extend(rhs);
    self
  }
}

impl<T> Add for VecDeque<T>
where
  T: Add,
{
  fn add(mut self, rhs: VecDeque<T>) -> VecDeque<T> {
    self.extend(rhs);
    self
  }
}

// impl<T> Add for BinaryHeap<T>
// where
//   T: Add + Ord,
// {
//   fn add(mut self, rhs: BinaryHeap<T>) -> BinaryHeap<T> {
//     self.extend(rhs);
//     self
//   }
// }

impl<T> Add for HashSet<T>
where
  T: Add + Eq + Hash,
{
  fn add(mut self, rhs: HashSet<T>) -> HashSet<T> {
    self.extend(rhs);
    self
  }
}

impl<T> Add for BTreeSet<T>
where
  T: Add + Ord,
{
  fn add(mut self, rhs: BTreeSet<T>) -> BTreeSet<T> {
    self.extend(rhs);
    self
  }
}

impl<K, V> Add for HashMap<K, V>
where
  K: Add + Eq + Hash,
  V: Add,
{
  fn add(mut self, rhs: HashMap<K, V>) -> HashMap<K, V> {
    self.extend(rhs);
    self
  }
}

impl<K, V> Add for BTreeMap<K, V>
where
  K: Add + Ord,
  V: Add,
{
  fn add(mut self, rhs: BTreeMap<K, V>) -> BTreeMap<K, V> {
    self.extend(rhs);
    self
  }
}

impl<T> Add for Option<T>
where
  T: Add + std::ops::Add<Output = T>,
{
  fn add(self, rhs: Option<T>) -> Option<T> {
    match (self, rhs) {
      (Some(a), Some(b)) => Some(a + b),
      (Some(a), None) => Some(a),
      (None, Some(b)) => Some(b),
      (None, None) => None,
    }
  }
}

impl Add for () {
  fn add(self, _: ()) -> () {
    ()
  }
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn add_string() {
    assert_eq!(
      String::from("hello ").add("world".to_owned()),
      "hello world"
    );
  }

  #[test]
  fn add_bool() {
    assert_eq!(true.add(true), true);
    assert_eq!(true.add(false), true);
    assert_eq!(false.add(true), true);
    assert_eq!(false.add(false), false);
  }

  #[test]
  fn add_char() {
    assert_eq!(char::from('a').add('b'), 'Ã');
  }

  #[test]
  fn add_u8() {
    assert_eq!(u8::from(1_u8).add(2), 3);
  }

  #[test]
  fn add_u16() {
    assert_eq!(u16::from(1_u16).add(2), 3);
  }

  #[test]
  fn add_u32() {
    assert_eq!(u32::from(1_u32).add(2), 3);
  }

  #[test]
  fn add_u64() {
    assert_eq!(u64::from(1_u64).add(2), 3);
  }

  #[test]
  fn add_u128() {
    assert_eq!(u128::from(1_u128).add(2), 3);
  }

  #[test]
  fn add_usize() {
    assert_eq!(usize::from(1_usize).add(2), 3);
  }

  #[test]
  fn add_i8() {
    assert_eq!(i8::from(1_i8).add(2), 3);
  }

  #[test]
  fn add_i16() {
    assert_eq!(i16::from(1_i16).add(2), 3);
  }

  #[test]
  fn add_i32() {
    assert_eq!(i32::from(1_i32).add(2), 3);
  }

  #[test]
  fn add_i64() {
    assert_eq!(i64::from(1_i64).add(2), 3);
  }

  #[test]
  fn add_i128() {
    assert_eq!(i128::from(1_i128).add(2), 3);
  }

  #[test]
  fn add_isize() {
    assert_eq!(isize::from(1_isize).add(2), 3);
  }

  #[test]
  fn add_f32() {
    assert_eq!(f32::from(1.0_f32).add(2.0), 3.0);
  }

  #[test]
  fn add_f64() {
    assert_eq!(f64::from(1.0_f64).add(2.0), 3.0);
  }

  #[test]
  fn add_vec() {
    assert_eq!(vec![1, 2].add(vec![3, 4]), vec![1, 2, 3, 4]);
  }

  #[test]
  fn add_linked_list() {
    let mut list = LinkedList::new();
    list.push_back(1);
    list.push_back(2);

    let mut other_list = LinkedList::new();
    other_list.push_back(3);
    other_list.push_back(4);

    assert_eq!(list.add(other_list), LinkedList::from([1, 2, 3, 4]));
  }

  #[test]
  fn add_vec_deque() {
    let mut deque = VecDeque::new();
    deque.push_back(1);
    deque.push_back(2);

    let mut other_deque = VecDeque::new();
    other_deque.push_back(3);
    other_deque.push_back(4);

    assert_eq!(deque.add(other_deque), vec![1, 2, 3, 4]);
  }

  // #[test]
  // fn add_binary_heap() {
  //   let mut heap = BinaryHeap::new();
  //   heap.push(1);
  //   heap.push(2);

  //   let mut other_heap = BinaryHeap::new();
  //   other_heap.push(3);
  //   other_heap.push(4);

  //   let mut result = BinaryHeap::new();
  //   result.push(1);
  //   result.push(2);
  //   result.push(3);
  //   result.push(4);
  //   assert_eq!(heap.add(other_heap), result);
  // }

  #[test]
  fn add_hash_set() {
    let mut set = HashSet::new();
    set.insert(1);
    set.insert(2);

    let mut other_set = HashSet::new();
    other_set.insert(3);
    other_set.insert(4);

    assert_eq!(set.add(other_set), HashSet::from([1, 2, 3, 4]));
  }

  #[test]
  fn add_btree_set() {
    let mut set = BTreeSet::new();
    set.insert(1);
    set.insert(2);

    let mut other_set = BTreeSet::new();
    other_set.insert(3);
    other_set.insert(4);

    assert_eq!(set.add(other_set), BTreeSet::from([1, 2, 3, 4]));
  }

  #[test]
  fn add_hash_map() {
    let mut map = HashMap::new();
    map.insert(1, 2);
    map.insert(2, 3);

    let mut other_map = HashMap::new();
    other_map.insert(3, 4);
    other_map.insert(4, 5);

    let mut expected = HashMap::new();
    expected.insert(1, 2);
    expected.insert(2, 3);
    expected.insert(3, 4);
    expected.insert(4, 5);

    assert_eq!(map.add(other_map), expected);
  }

  #[test]
  fn add_btree_map() {
    let mut map = BTreeMap::new();
    map.insert(1, 2);
    map.insert(2, 3);

    let mut other_map = BTreeMap::new();
    other_map.insert(3, 4);
    other_map.insert(4, 5);

    let mut expected = BTreeMap::new();
    expected.insert(1, 2);
    expected.insert(2, 3);
    expected.insert(3, 4);
    expected.insert(4, 5);

    assert_eq!(map.add(other_map), expected);
  }

  #[test]
  fn add_option() {
    assert_eq!(Some(1).add(Some(2)), Some(3));
    assert_eq!(Some(1).add(None), Some(1));
    assert_eq!(None::<i32>.add(Some(2)), Some(2));
    assert_eq!(None::<i32>.add(None), None);
  }

  #[test]
  fn add_unit() {
    assert_eq!(().add(()), ());
  }
}