PRQL
diff --git a/‎Cargo.lock
Lines changed: 3 additions & 9 deletions b/‎Cargo.lock
Lines changed: 3 additions & 9 deletions
diff --git a/‎Cargo.toml
Lines changed: 0 additions & 1 deletion b/‎Cargo.toml
Lines changed: 0 additions & 1 deletion
diff --git a/‎prqlc/Taskfile.yaml
Lines changed: 24 additions & 1 deletion b/‎prqlc/Taskfile.yaml
Lines changed: 24 additions & 1 deletion
diff --git a/‎prqlc/prqlc-parser/src/parser/expr.rs
Lines changed: 6 additions & 4 deletions b/‎prqlc/prqlc-parser/src/parser/expr.rs
Lines changed: 6 additions & 4 deletions
diff --git a/‎prqlc/prqlc-parser/src/parser/pr/expr.rs
Lines changed: 1 addition & 1 deletion b/‎prqlc/prqlc-parser/src/parser/pr/expr.rs
Lines changed: 1 addition & 1 deletion
diff --git a/‎prqlc/prqlc-parser/src/parser/pr/types.rs
Lines changed: 17 additions & 33 deletions b/‎prqlc/prqlc-parser/src/parser/pr/types.rs
Lines changed: 17 additions & 33 deletions
diff --git a/‎prqlc/prqlc-parser/src/parser/types.rs
Lines changed: 47 additions & 61 deletions b/‎prqlc/prqlc-parser/src/parser/types.rs
Lines changed: 47 additions & 61 deletions
@@ -8,7 +8,6 @@ members = [
   "prqlc/prqlc-macros",
   "prqlc/prqlc-parser",
   "prqlc/prqlc",
-  "prqlc/prqlc/examples/compile-files", # An example
   "lutra/lutra",
   "lutra/bindings/python",
   "web/book",
 
@@ -37,21 +37,44 @@ tasks:
           --ignore-unknown \
           --log-level=warn
 
+  fmt-check:
+    desc: Validate that source files are formatted
+    cmds:
+      - cargo fmt --check {{.packages_core}} {{.packages_addon}}
+        {{.packages_bindings}}
+
   test-fast:
     desc: A fast test used for feedback during compiler development
     cmds:
       - cmd: |
-          INSTA_FORCE_PASS=1 cargo nextest run {{.packages_core}} --no-fail-fast
+          INSTA_FORCE_PASS=1 cargo nextest run {{.packages_core}} -- {{.CLI_ARGS}}
 
       - cmd: cargo insta review
 
       - cmd: cargo clippy --all-targets {{.packages_core}}
 
+  test-types:
+    desc:
+      A subset of tests that should work on feat-types
+    cmds:
+      - cmd: |
+          INSTA_FORCE_PASS=1 cargo nextest run --package prqlc --test=integration -- sql:: resolving::
+
+      - cmd: cargo insta review
+
+      - cmd: cargo clippy --all-targets {{.packages_core}}
+
+      - cmd: |
+          echo -e '\n=======\nrunning just ignored tests, to see if any of them passes'
+          cargo nextest run --package prqlc --test=integration --run-ignored=ignored-only --success-output=never --failure-output=never --status-level=pass --final-status-level=none -- sql:: resolving::
+
   test:
     desc: |
       A full test of prqlc (excluding --test-dbs-external).
       Generates coverage report.
     cmds:
+      - task: fmt-check
+
       - cmd: |
           cargo \
             llvm-cov --lcov --output-path lcov.info \
 
@@ -481,9 +481,8 @@ where
         .then(ctrl(':').ignore_then(expr.clone().map(Box::new)).or_not());
 
     let generic_args = ident_part()
-        .then_ignore(ctrl(':'))
-        .then(type_expr().separated_by(ctrl('|')))
-        .map(|(name, domain)| GenericTypeParam { name, domain })
+        .then(ctrl(':').ignore_then(type_expr()).or_not())
+        .map(|(name, bound)| GenericTypeParam { name, bound })
         .separated_by(ctrl(','))
         .at_least(1)
         .delimited_by(ctrl('<'), ctrl('>'))
@@ -500,7 +499,10 @@ where
                 .allow_trailing(),
         ),
         // plain
-        param.repeated().map(|params| (Vec::new(), params)),
+        param
+            .repeated()
+            .at_least(1)
+            .map(|params| (Vec::new(), params)),
     ))
     .then_ignore(just(TokenKind::ArrowThin))
     // return type
 
@@ -165,7 +165,7 @@ pub struct GenericTypeParam {
     /// Assigned name of this generic type argument.
     pub name: String,
 
-    pub domain: Vec<Ty>,
+    pub bound: Option<Ty>,
 }
 
 /// A value and a series of functions that are to be applied to that value one after another.
 
@@ -3,11 +3,11 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use strum::AsRefStr;
 
-use crate::lexer::lr::Literal;
 use crate::parser::pr::ident::Ident;
+use crate::parser::pr::expr::GenericTypeParam;
 use crate::span::Span;
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 pub struct Ty {
     pub kind: TyKind,
 
@@ -25,12 +25,6 @@ pub enum TyKind {
     /// Type of a built-in primitive type
     Primitive(PrimitiveSet),
 
-    /// Type that contains only a one value
-    Singleton(Literal),
-
-    /// Union of sets (sum)
-    Union(Vec<(Option<String>, Ty)>),
-
     /// Type of tuples (product)
     Tuple(Vec<TyTupleField>),
 
@@ -40,15 +34,9 @@ pub enum TyKind {
     /// Type of functions with defined params and return types.
     Function(Option<TyFunc>),
 
-    /// Type of every possible value. Super type of all other types.
-    /// The breaker of chains. Mother of types.
-    Any,
-
-    /// Type that is the largest subtype of `base` while not a subtype of `exclude`.
-    Difference { base: Box<Ty>, exclude: Box<Ty> },
-
-    /// A generic argument. Contains id of the function call node and generic type param name.
-    GenericArg((usize, String)),
+    /// Tuples that have fields of `base` tuple, but don't have fields of `except` tuple.
+    /// Implies that `base` has all fields of `except`.
+    Exclude { base: Box<Ty>, except: Box<Ty> },
 }
 
 impl TyKind {
@@ -66,9 +54,11 @@ pub enum TyTupleField {
     /// Named tuple element.
     Single(Option<String>, Option<Ty>),
 
-    /// Placeholder for possibly many elements.
-    /// Means "and other unmentioned columns". Does not mean "all columns".
-    Wildcard(Option<Ty>),
+    /// Many tuple elements contained in a type that must eventually resolve to a tuple.
+    /// In most cases, this starts as a generic type argument.
+    // TODO: make this non-optional Ty
+    // TODO: merge this into TyTuple (that does not exist at the moment)
+    Unpack(Option<Ty>),
 }
 
 /// Built-in sets.
@@ -103,9 +93,11 @@ pub enum PrimitiveSet {
 // Type of a function
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct TyFunc {
-    pub name_hint: Option<Ident>,
     pub params: Vec<Option<Ty>>,
+
     pub return_ty: Option<Box<Ty>>,
+
+    pub generic_type_params: Vec<GenericTypeParam>,
 }
 
 impl Ty {
@@ -122,14 +114,6 @@ impl Ty {
         Ty::new(TyKind::Array(Box::new(tuple)))
     }
 
-    pub fn never() -> Self {
-        Ty::new(TyKind::Union(Vec::new()))
-    }
-
-    pub fn is_never(&self) -> bool {
-        self.kind.as_union().map_or(false, |x| x.is_empty())
-    }
-
     pub fn as_relation(&self) -> Option<&Vec<TyTupleField>> {
         self.kind.as_array()?.kind.as_tuple()
     }
@@ -156,7 +140,7 @@ impl TyTupleField {
     pub fn ty(&self) -> Option<&Ty> {
         match self {
             TyTupleField::Single(_, ty) => ty.as_ref(),
-            TyTupleField::Wildcard(ty) => ty.as_ref(),
+            TyTupleField::Unpack(ty) => ty.as_ref(),
         }
     }
 }
@@ -173,8 +157,8 @@ impl From<TyFunc> for TyKind {
     }
 }
 
-impl From<Literal> for TyKind {
-    fn from(value: Literal) -> Self {
-        TyKind::Singleton(value)
+impl PartialEq for Ty {
+    fn eq(&self, other: &Self) -> bool {
+        self.kind == other.kind && self.name == other.name
     }
 }
@@ -9,15 +9,15 @@ use crate::lexer::lr::TokenKind;
 pub(crate) fn type_expr() -> impl Parser<TokenKind, Ty, Error = PError> + Clone {
     recursive(|nested_type_expr| {
         let basic = select! {
-            TokenKind::Literal(lit) => TyKind::Singleton(lit),
+            // TokenKind::Literal(lit) => TyKind::Singleton(lit),
             TokenKind::Ident(i) if i == "int"=> TyKind::Primitive(PrimitiveSet::Int),
             TokenKind::Ident(i) if i == "float"=> TyKind::Primitive(PrimitiveSet::Float),
             TokenKind::Ident(i) if i == "bool"=> TyKind::Primitive(PrimitiveSet::Bool),
             TokenKind::Ident(i) if i == "text"=> TyKind::Primitive(PrimitiveSet::Text),
             TokenKind::Ident(i) if i == "date"=> TyKind::Primitive(PrimitiveSet::Date),
             TokenKind::Ident(i) if i == "time"=> TyKind::Primitive(PrimitiveSet::Time),
             TokenKind::Ident(i) if i == "timestamp"=> TyKind::Primitive(PrimitiveSet::Timestamp),
-            TokenKind::Ident(i) if i == "anytype"=> TyKind::Any,
+            // TokenKind::Ident(i) if i == "anytype"=> TyKind::Any,
         };
 
         let ident = ident().map(TyKind::Ident);
@@ -31,9 +31,9 @@ pub(crate) fn type_expr() -> impl Parser<TokenKind, Ty, Error = PError> + Clone
                     .then_ignore(just(TokenKind::ArrowThin))
                     .then(nested_type_expr.clone().map(Box::new).map(Some))
                     .map(|(params, return_ty)| TyFunc {
-                        name_hint: None,
                         params,
                         return_ty,
+                        generic_type_params: vec![],
                     })
                     .or_not(),
             )
@@ -42,7 +42,7 @@ pub(crate) fn type_expr() -> impl Parser<TokenKind, Ty, Error = PError> + Clone
         let tuple = sequence(choice((
             select! { TokenKind::Range { bind_right: true, bind_left: _ } => () }
                 .ignore_then(nested_type_expr.clone())
-                .map(|ty| TyTupleField::Wildcard(Some(ty))),
+                .map(|ty| TyTupleField::Unpack(Some(ty))),
             ident_part()
                 .then_ignore(ctrl('='))
                 .or_not()
@@ -63,7 +63,7 @@ pub(crate) fn type_expr() -> impl Parser<TokenKind, Ty, Error = PError> + Clone
         .try_map(|fields, span| {
             let without_last = &fields[0..fields.len().saturating_sub(1)];
 
-            if let Some(unpack) = without_last.iter().find_map(|f| f.as_wildcard()) {
+            if let Some(unpack) = without_last.iter().find_map(|f| f.as_unpack()) {
                 let span = unpack.as_ref().and_then(|s| s.span).unwrap_or(span);
                 return Err(PError::custom(
                     span,
@@ -76,32 +76,32 @@ pub(crate) fn type_expr() -> impl Parser<TokenKind, Ty, Error = PError> + Clone
         .map(TyKind::Tuple)
         .labelled("tuple");
 
-        let enum_ = keyword("enum")
-            .ignore_then(
-                sequence(
-                    ident_part()
-                        .then(ctrl('=').ignore_then(nested_type_expr.clone()).or_not())
-                        .map(|(name, ty)| {
-                            (
-                                Some(name),
-                                ty.unwrap_or_else(|| Ty::new(TyKind::Tuple(vec![]))),
-                            )
-                        }),
-                )
-                .delimited_by(ctrl('{'), ctrl('}'))
-                .recover_with(nested_delimiters(
-                    TokenKind::Control('{'),
-                    TokenKind::Control('}'),
-                    [
-                        (TokenKind::Control('{'), TokenKind::Control('}')),
-                        (TokenKind::Control('('), TokenKind::Control(')')),
-                        (TokenKind::Control('['), TokenKind::Control(']')),
-                    ],
-                    |_| vec![],
-                )),
-            )
-            .map(TyKind::Union)
-            .labelled("union");
+        // let enum_ = keyword("enum")
+        //     .ignore_then(
+        //         sequence(
+        //             ident_part()
+        //                 .then(ctrl('=').ignore_then(nested_type_expr.clone()).or_not())
+        //                 .map(|(name, ty)| {
+        //                     (
+        //                         Some(name),
+        //                         ty.unwrap_or_else(|| Ty::new(TyKind::Tuple(vec![]))),
+        //                     )
+        //                 }),
+        //         )
+        //         .delimited_by(ctrl('{'), ctrl('}'))
+        //         .recover_with(nested_delimiters(
+        //             TokenKind::Control('{'),
+        //             TokenKind::Control('}'),
+        //             [
+        //                 (TokenKind::Control('{'), TokenKind::Control('}')),
+        //                 (TokenKind::Control('('), TokenKind::Control(')')),
+        //                 (TokenKind::Control('['), TokenKind::Control(']')),
+        //             ],
+        //             |_| vec![],
+        //         )),
+        //     )
+        //     .map(TyKind::Union)
+        //     .labelled("union");
 
         let array = nested_type_expr
             .map(Box::new)
@@ -120,41 +120,27 @@ pub(crate) fn type_expr() -> impl Parser<TokenKind, Ty, Error = PError> + Clone
             .map(TyKind::Array)
             .labelled("array");
 
-        let term = choice((basic, ident, func, tuple, array, enum_))
+        let term = choice((basic, ident, func, tuple, array))
             .map_with_span(TyKind::into_ty)
             .boxed();
 
         // exclude
-        // term.clone()
-        //     .then(ctrl('-').ignore_then(term).repeated())
-        //     .foldl(|left, right| {
-        //         let left_span = left.span.as_ref().unwrap();
-        //         let right_span = right.span.as_ref().unwrap();
-        //         let span = Span {
-        //             start: left_span.start,
-        //             end: right_span.end,
-        //             source_id: left_span.source_id,
-        //         };
-
-        //         let kind = TyKind::Exclude {
-        //             base: Box::new(left),
-        //             except: Box::new(right),
-        //         };
-        //         into_ty(kind, span)
-        //     });
-
-        // union
         term.clone()
-            .then(just(TokenKind::Or).ignore_then(term).repeated())
-            .map_with_span(|(first, following), span| {
-                if following.is_empty() {
-                    first
-                } else {
-                    let mut all = Vec::with_capacity(following.len() + 1);
-                    all.push((None, first));
-                    all.extend(following.into_iter().map(|x| (None, x)));
-                    TyKind::Union(all).into_ty(span)
-                }
+            .then(ctrl('-').ignore_then(term).repeated())
+            .foldl(|left, right| {
+                let left_span = left.span.as_ref().unwrap();
+                let right_span = right.span.as_ref().unwrap();
+                let span = Span {
+                    start: left_span.start,
+                    end: right_span.end,
+                    source_id: left_span.source_id,
+                };
+
+                let kind = TyKind::Exclude {
+                    base: Box::new(left),
+                    except: Box::new(right),
+                };
+                TyKind::into_ty(kind, span)
             })
     })
     .labelled("type expression")
Original file line number	Diff line number	Diff line change
`@@ -165,7 +165,7 @@ pub struct GenericTypeParam {`
`165`	`165`	`/// Assigned name of this generic type argument.`
`166`	`166`	`pub name: String,`
`167`	`167`
`168`		`- pub domain: Vec<Ty>,`
	`168`	`+ pub bound: Option<Ty>,`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`/// A value and a series of functions that are to be applied to that value one after another.`