regularize up/down cast

Author: nikomatsakis

crates/formality-core/src/cast.rs

@@ -271,34 +271,6 @@ where
     }
 }
 
-impl<A, As, B, Bs, Z> UpcastFrom<(A, B)> for Vec<Z>
-where
-    A: IntoIterator<Item = As> + Clone,
-    As: Upcast<Z>,
-    B: IntoIterator<Item = Bs> + Clone,
-    Bs: Upcast<Z>,
-{
-    fn upcast_from(term: (A, B)) -> Self {
-        let (a, b) = term;
-        let mut v: Self = vec![];
-        v.extend(a.into_iter().map(|a| a.upcast()));
-        v.extend(b.into_iter().map(|b| b.upcast()));
-        v
-    }
-}
-
-impl<A, B, C, Z> UpcastFrom<(A, B, C)> for Vec<Z>
-where
-    A: Upcast<Z>,
-    B: Upcast<Z>,
-    C: Upcast<Z>,
-{
-    fn upcast_from(term: (A, B, C)) -> Self {
-        let (a, b, c) = term;
-        vec![a.upcast(), b.upcast(), c.upcast()]
-    }
-}
-
 #[macro_export]
 macro_rules! cast_impl {
     ($e:ident :: $v:ident ($u:ty)) => {

crates/formality-core/src/collections.rs

@@ -3,7 +3,7 @@
 
 use std::collections::{BTreeMap, BTreeSet};
 
-use crate::cast::{Downcast, DowncastFrom, DowncastTo, Upcast, UpcastFrom};
+use crate::cast::{DowncastTo, Upcast, UpcastFrom, Upcasted};
 
 pub type Map<K, V> = BTreeMap<K, V>;
 pub type Set<E> = BTreeSet<E>;
@@ -58,6 +58,17 @@ macro_rules! seq {
 
 }
 
+pub trait VecExt<T>: Sized {
+    fn with_pushed(self, other: T) -> Self;
+}
+
+impl<T: Ord + Clone> VecExt<T> for Vec<T> {
+    fn with_pushed(mut self, other: T) -> Self {
+        self.push(other);
+        self
+    }
+}
+
 pub trait SetExt<T>: Sized {
     fn split_first(self) -> Option<(T, Self)>;
 
@@ -69,7 +80,9 @@ pub trait SetExt<T>: Sized {
 impl<T: Ord + Clone> SetExt<T> for Set<T> {
     fn split_first(self) -> Option<(T, Set<T>)> {
         let mut iter = self.into_iter();
-        iter.next().map(|e| (e, iter.collect()))
+        let e = iter.next()?;
+        let c = iter.collect();
+        Some((e, c))
     }
 
     fn union_with(mut self, other: Self) -> Self {
@@ -106,60 +119,67 @@ impl<T> DowncastTo<()> for Vec<T> {
 }
 
 macro_rules! tuple_upcast {
-    ($($name:ident),*) => {
+    ($coll:ident : $($name:ident),*) => {
+        /// Upcast from a tuple of iterable things into a collection.
+        /// Downcasting doesn't work, because how would we know how many
+        /// things to put in each collection? But see `Cons` below.
         #[allow(non_snake_case)]
-        impl<$($name,)* T> UpcastFrom<($($name,)*)> for Set<T>
+        impl<$($name,)* T> UpcastFrom<($($name,)*)> for $coll<T>
         where
-            $($name: Upcast<Set<T>>,)*
+            $($name: IntoIterator + Clone,)*
+            $(<$name as IntoIterator>::Item: Upcast<T>,)*
             T: Ord + Clone,
         {
             fn upcast_from(($($name,)*): ($($name,)*)) -> Self {
                 let c = None.into_iter();
                 $(
-                    let $name: Set<T> = $name.upcast();
-                    let c = c.chain($name);
+                    let c = c.chain($name.into_iter().upcasted());
                 )*
                 c.collect()
             }
         }
     }
 }
 
-tuple_upcast!(A, B);
-tuple_upcast!(A, B, C);
-tuple_upcast!(A, B, C, D);
+tuple_upcast!(Set: );
+tuple_upcast!(Set: A, B);
+tuple_upcast!(Set: A, B, C);
+tuple_upcast!(Set: A, B, C, D);
+
+tuple_upcast!(Vec: );
+tuple_upcast!(Vec: A, B);
+tuple_upcast!(Vec: A, B, C);
+tuple_upcast!(Vec: A, B, C, D);
 
-impl<A, T> DowncastTo<(A, Set<T>)> for Set<T>
+/// This type exists to be used in judgment functions.
+/// You can downcast a `Vec` or `Set` to `Cons(head, tail)`
+/// where `head` will be the first item in the collection
+/// and tail will be a collection with the remaining items.
+/// Both can also be downcast to `()` which matches an empty collection.
+pub struct Cons<T, C>(pub T, pub C);
+
+impl<T> DowncastTo<Cons<T, Set<T>>> for Set<T>
 where
-    A: DowncastFrom<T>,
     T: Ord + Clone,
 {
-    fn downcast_to(&self) -> Option<(A, Set<T>)> {
+    fn downcast_to(&self) -> Option<Cons<T, Set<T>>> {
         if self.is_empty() {
             None
         } else {
             let r = self.clone();
             let (a, bs) = r.split_first().unwrap();
-            let a: A = a.downcast()?;
-            Some((a, bs))
+            Some(Cons(a, bs))
         }
     }
 }
 
-impl<A, T> DowncastTo<(A, Vec<T>)> for Vec<T>
+impl<T> DowncastTo<Cons<T, Vec<T>>> for Vec<T>
 where
-    A: DowncastFrom<T>,
     T: Ord + Clone,
 {
-    fn downcast_to(&self) -> Option<(A, Vec<T>)> {
-        if self.is_empty() {
-            None
-        } else {
-            let r = self.clone();
-            let (a, bs) = r.split_first().unwrap();
-            let a: A = a.downcast()?;
-            Some((a, bs.to_vec()))
-        }
+    fn downcast_to(&self) -> Option<Cons<T, Vec<T>>> {
+        let (a, bs) = self.split_first()?;
+        Some(Cons(a.clone(), bs.to_vec()))
     }
 }