remove difference type

PRQL · Jan 27, 2025 · d3c8d0c · d3c8d0c
1 parent c17725f
commit d3c8d0c
Show file tree

Hide file tree

Showing 6 changed files with 2 additions and 37 deletions.
diff --git a/prqlc/prqlc-parser/src/parser/pr/types.rs b/prqlc/prqlc-parser/src/parser/pr/types.rs
@@ -36,9 +36,6 @@ pub enum TyKind {
 
     /// Type of functions with defined params and return types.
     Function(Option<TyFunc>),
-
-    /// Type that is the largest subtype of `base` while not a subtype of `exclude`.
-    Difference { base: Box<Ty>, exclude: Box<Ty> },
 }
 
 impl TyKind {

diff --git a/prqlc/prqlc/src/codegen/types.rs b/prqlc/prqlc/src/codegen/types.rs
@@ -59,11 +59,6 @@ impl WriteSource for pr::TyKind {
                 r += &func.return_ty.as_deref().write(opt)?;
                 Some(r)
             }
-            Difference { base, exclude } => {
-                let base = base.write(opt.clone())?;
-                let exclude = exclude.write(opt.clone())?;
-                Some(format!("{base} - {exclude}"))
-            }
         }
     }
 }

diff --git a/prqlc/prqlc/src/ir/pl/fold.rs b/prqlc/prqlc/src/ir/pl/fold.rs
@@ -347,10 +347,6 @@ pub fn fold_type<T: ?Sized + PlFold>(fold: &mut T, ty: Ty) -> Result<Ty> {
                 })
                 .transpose()?,
             ),
-            TyKind::Difference { base, exclude } => TyKind::Difference {
-                base: Box::new(fold.fold_type(*base)?),
-                exclude: Box::new(fold.fold_type(*exclude)?),
-            },
             TyKind::Ident(_) | TyKind::Primitive(_) | TyKind::Singleton(_) => ty.kind,
         },
         span: ty.span,

diff --git a/prqlc/prqlc/src/semantic/resolver/expr.rs b/prqlc/prqlc/src/semantic/resolver/expr.rs
@@ -173,7 +173,7 @@ impl pl::PlFold for Resolver<'_> {
 
                 // fold function
                 let func = self.apply_args_to_closure(func, args, named_args)?;
-                self.fold_function(func,  *span)?
+                self.fold_function(func, *span)?
             }
 
             pl::ExprKind::Func(closure) => self.fold_function(closure, *span)?,

diff --git a/prqlc/prqlc/src/semantic/resolver/functions.rs b/prqlc/prqlc/src/semantic/resolver/functions.rs
@@ -13,11 +13,7 @@ use crate::Result;
 use crate::{Error, Span, WithErrorInfo};
 
 impl Resolver<'_> {
-    pub fn fold_function(
-        &mut self,
-        closure: Box<Func>,
-        span: Option<Span>,
-    ) -> Result<Expr> {
+    pub fn fold_function(&mut self, closure: Box<Func>, span: Option<Span>) -> Result<Expr> {
         let closure = self.fold_function_types(closure)?;
 
         log::debug!(

diff --git a/prqlc/prqlc/src/semantic/resolver/types.rs b/prqlc/prqlc/src/semantic/resolver/types.rs
@@ -73,13 +73,6 @@ impl Resolver<'_> {
                 TyKind::Array(items_ty)
             }
 
-            ExprKind::All { within, except } => {
-                let base = Box::new(Resolver::infer_type(within)?.unwrap());
-                let exclude = Box::new(Resolver::infer_type(except)?.unwrap());
-
-                TyKind::Difference { base, exclude }
-            }
-
             _ => return Ok(None),
         };
         Ok(Some(Ty {
@@ -390,18 +383,6 @@ fn maybe_type_intersection(a: Option<Ty>, b: Option<Ty>) -> Option<Ty> {
 
 pub fn type_intersection(a: Ty, b: Ty) -> Ty {
     match (a.kind, b.kind) {
-        // difference
-        (TyKind::Difference { base, exclude }, b_kind) => {
-            let b = Ty { kind: b_kind, ..b };
-            let base = Box::new(type_intersection(*base, b));
-            Ty::new(TyKind::Difference { base, exclude })
-        }
-        (a_kind, TyKind::Difference { base, exclude }) => {
-            let a = Ty { kind: a_kind, ..a };
-            let base = Box::new(type_intersection(a, *base));
-            Ty::new(TyKind::Difference { base, exclude })
-        }
-
         (a_kind, b_kind) if a_kind == b_kind => Ty { kind: a_kind, ..a },
 
         // tuple