haskell_match 0.1.0

data/ext/haskell_match/src/core/pretty.rs

@@ -0,0 +1,373 @@
+//! Haskell-style rendering of patterns, used for diagnostics.
+
+use super::ast::{HKey, Lit, Pat};
+use super::types::{TypeEnv, TypeKind, CON_CONS, CON_NIL};
+
+/// A witness pattern produced by the exhaustiveness checker.
+#[derive(Clone, Debug, PartialEq)]
+pub enum WPat {
+    Wild,
+    /// A literal position where the listed literals *are* handled: any other
+    /// value of that type is unmatched.
+    NotLit(Vec<Lit>),
+    Lit(Lit),
+    Con(super::types::ConId, Vec<WPat>),
+    /// A Hash with these keys (and any others).
+    Hash(Vec<(HKey, WPat)>),
+    /// A Hash lacking a key from each of the listed key sets: the Hash
+    /// patterns with those keys are handled, any other Hash is not.
+    NoKeys(Vec<Vec<HKey>>),
+}
+
+impl WPat {
+    pub fn from_pat(p: &Pat) -> WPat {
+        match p {
+            Pat::Wild | Pat::Var(_) | Pat::Lazy(_) => WPat::Wild,
+            Pat::As(_, p) => WPat::from_pat(p),
+            Pat::Lit(l) => WPat::Lit(l.clone()),
+            Pat::Con(c, args) => WPat::Con(*c, args.iter().map(WPat::from_pat).collect()),
+            Pat::Hash(fields) => WPat::Hash(
+                fields
+                    .iter()
+                    .map(|(k, p)| (k.clone(), WPat::from_pat(p)))
+                    .collect(),
+            ),
+        }
+    }
+}
+
+fn render_keys(keys: &[HKey]) -> String {
+    let shown: Vec<String> = keys.iter().map(|k| k.to_string()).collect();
+    if keys.len() == 1 {
+        format!("the key {}", shown[0])
+    } else {
+        format!("the keys {{{}}}", shown.join(", "))
+    }
+}
+
+/// Render a witness vector the way GHC lists unmatched patterns:
+/// `Just (Just _) []` plus a trailing note for literal positions.
+pub fn render_witness(env: &TypeEnv, pats: &[WPat]) -> String {
+    let mut parts = Vec::new();
+    let mut notes: Vec<String> = Vec::new();
+    // GHC parenthesises constructor applications only when a clause has
+    // several arguments: `Just (Just _)` but `(Circle _) (Rect _ _)`.
+    let atomic = pats.len() > 1;
+    for p in pats {
+        parts.push(render(env, p, atomic, &mut notes));
+    }
+    let mut s = parts.join(" ");
+    if !notes.is_empty() {
+        s.push_str(" where ");
+        s.push_str(&notes.join(" and "));
+    }
+    s
+}
+
+fn render(env: &TypeEnv, p: &WPat, atomic: bool, notes: &mut Vec<String>) -> String {
+    match p {
+        WPat::Wild => "_".to_string(),
+        WPat::Lit(l) => render_lit(l, atomic),
+        WPat::NotLit(lits) => {
+            let name = format!("p{}", notes.len() + 1);
+            let shown: Vec<String> = lits.iter().map(|l| l.to_string()).collect();
+            notes.push(format!("{} is not one of {{{}}}", name, shown.join(", ")));
+            name
+        }
+        WPat::Hash(fields) => {
+            let inner: Vec<String> = fields
+                .iter()
+                .map(|(k, p)| format!("{} = {}", k, render(env, p, false, notes)))
+                .collect();
+            format!("{{{}}}", inner.join(", "))
+        }
+        WPat::NoKeys(sets) => {
+            let name = format!("p{}", notes.len() + 1);
+            let parts: Vec<String> = sets
+                .iter()
+                .map(|k| format!("without {}", render_keys(k)))
+                .collect();
+            notes.push(format!("{} is a Hash {}", name, parts.join(" or ")));
+            name
+        }
+        WPat::Con(c, args) => {
+            let con = env.con(*c);
+            match env.ty(con.ty).kind {
+                TypeKind::Bool => con.name.clone(),
+                TypeKind::Tuple(_) => {
+                    let inner: Vec<String> =
+                        args.iter().map(|a| render(env, a, false, notes)).collect();
+                    format!("({})", inner.join(", "))
+                }
+                TypeKind::List => {
+                    if *c == CON_NIL {
+                        return "[]".to_string();
+                    }
+                    // try to render as a list literal when the spine is fully known
+                    let mut items = Vec::new();
+                    let mut cur = p;
+                    loop {
+                        match cur {
+                            WPat::Con(cc, a) if *cc == CON_CONS => {
+                                items.push(&a[0]);
+                                cur = &a[1];
+                            }
+                            WPat::Con(cc, _) if *cc == CON_NIL => {
+                                let inner: Vec<String> =
+                                    items.iter().map(|a| render(env, a, false, notes)).collect();
+                                return format!("[{}]", inner.join(", "));
+                            }
+                            _ => break,
+                        }
+                    }
+                    let head = render(env, &args[0], true, notes);
+                    let tail = render_cons_tail(env, &args[1], notes);
+                    format!("({}:{})", head, tail)
+                }
+                TypeKind::Adt => {
+                    if args.is_empty() {
+                        con.name.clone()
+                    } else {
+                        let inner: Vec<String> =
+                            args.iter().map(|a| render(env, a, true, notes)).collect();
+                        let s = if con.name.starts_with(':') && inner.len() == 2 {
+                            format!("{} {} {}", inner[0], con.name, inner[1])
+                        } else {
+                            format!("{} {}", con.name, inner.join(" "))
+                        };
+                        if atomic {
+                            format!("({})", s)
+                        } else {
+                            s
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn render_lit(l: &Lit, atomic: bool) -> String {
+    let negative = match l {
+        Lit::Int(i) => *i < 0,
+        Lit::Big(s) => s.starts_with('-'),
+        Lit::Float(f) => *f < 0.0,
+        _ => false,
+    };
+    if negative && atomic {
+        format!("({})", l)
+    } else {
+        l.to_string()
+    }
+}
+
+/// Inside `(h:t)`, a cons tail is rendered without its own parentheses.
+fn render_cons_tail(env: &TypeEnv, p: &WPat, notes: &mut Vec<String>) -> String {
+    match p {
+        WPat::Con(c, args) if *c == CON_CONS => {
+            let head = render(env, &args[0], true, notes);
+            let tail = render_cons_tail(env, &args[1], notes);
+            format!("{}:{}", head, tail)
+        }
+        other => render(env, other, true, notes),
+    }
+}
+
+/// Render a resolved pattern (used for messages about user clauses).
+pub fn render_pat(env: &TypeEnv, p: &Pat, names: &[String]) -> String {
+    render_pat_inner(env, p, names, false)
+}
+
+fn render_pat_inner(env: &TypeEnv, p: &Pat, names: &[String], atomic: bool) -> String {
+    match p {
+        Pat::Wild => "_".into(),
+        Pat::Var(v) => names.get(*v).cloned().unwrap_or_else(|| format!("v{}", v)),
+        Pat::As(v, inner) => format!(
+            "{}@{}",
+            names.get(*v).cloned().unwrap_or_else(|| format!("v{}", v)),
+            render_pat_inner(env, inner, names, true)
+        ),
+        Pat::Lazy(inner) => format!("~{}", render_pat_inner(env, inner, names, true)),
+        Pat::Lit(l) => render_lit(l, atomic),
+        Pat::Hash(fields) => {
+            let inner: Vec<String> = fields
+                .iter()
+                .map(|(k, p)| format!("{} = {}", k, render_pat_inner(env, p, names, false)))
+                .collect();
+            format!("{{{}}}", inner.join(", "))
+        }
+        Pat::Con(c, args) => {
+            let con = env.con(*c);
+            match env.ty(con.ty).kind {
+                TypeKind::Bool => con.name.clone(),
+                TypeKind::Tuple(_) => {
+                    let inner: Vec<String> = args
+                        .iter()
+                        .map(|a| render_pat_inner(env, a, names, false))
+                        .collect();
+                    format!("({})", inner.join(", "))
+                }
+                TypeKind::List => {
+                    if *c == CON_NIL {
+                        return "[]".into();
+                    }
+                    let mut items = Vec::new();
+                    let mut cur = p;
+                    loop {
+                        match cur {
+                            Pat::Con(cc, a) if *cc == CON_CONS => {
+                                items.push(&a[0]);
+                                cur = &a[1];
+                            }
+                            Pat::Con(cc, _) if *cc == CON_NIL => {
+                                let inner: Vec<String> = items
+                                    .iter()
+                                    .map(|a| render_pat_inner(env, a, names, false))
+                                    .collect();
+                                return format!("[{}]", inner.join(", "));
+                            }
+                            _ => break,
+                        }
+                    }
+                    let mut parts = vec![render_pat_inner(env, &args[0], names, true)];
+                    let mut tail = &args[1];
+                    while let Pat::Con(cc, a) = tail {
+                        if *cc != CON_CONS {
+                            break;
+                        }
+                        parts.push(render_pat_inner(env, &a[0], names, true));
+                        tail = &a[1];
+                    }
+                    parts.push(render_pat_inner(env, tail, names, true));
+                    format!("({})", parts.join(":"))
+                }
+                TypeKind::Adt => {
+                    if args.is_empty() {
+                        con.name.clone()
+                    } else {
+                        let inner: Vec<String> = args
+                            .iter()
+                            .map(|a| render_pat_inner(env, a, names, true))
+                            .collect();
+                        let s = if con.name.starts_with(':') && inner.len() == 2 {
+                            format!("{} {} {}", inner[0], con.name, inner[1])
+                        } else {
+                            format!("{} {}", con.name, inner.join(" "))
+                        };
+                        if atomic {
+                            format!("({})", s)
+                        } else {
+                            s
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::core::parser::parse_pattern;
+    use crate::core::resolve::resolve_clause;
+    use crate::core::types::ConSpec;
+
+    fn env() -> TypeEnv {
+        let mut env = TypeEnv::new();
+        env.register(
+            "Maybe",
+            &[
+                ConSpec {
+                    name: "Nothing".into(),
+                    arity: 0,
+                    fields: None,
+                    handle: 0,
+                },
+                ConSpec {
+                    name: "Just".into(),
+                    arity: 1,
+                    fields: None,
+                    handle: 0,
+                },
+            ],
+        )
+        .unwrap();
+        env
+    }
+
+    fn roundtrip(env: &mut TypeEnv, src: &str) -> String {
+        let raw = parse_pattern(src).unwrap();
+        let (pats, b) = resolve_clause(env, &[raw]).unwrap();
+        render_pat(env, &pats[0], &b.names)
+    }
+
+    #[test]
+    fn renders_patterns() {
+        let mut env = env();
+        for (src, want) in [
+            ("Just x", "Just x"),
+            ("Just (Just _)", "Just (Just _)"),
+            ("(x:xs)", "(x:xs)"),
+            ("x:y:rest", "(x:y:rest)"),
+            ("[a, b]", "[a, b]"),
+            ("[]", "[]"),
+            ("(a, Nothing, [])", "(a, Nothing, [])"),
+            ("()", "()"),
+            ("all@(x:_)", "all@(x:_)"),
+            ("~(Just y)", "~(Just y)"),
+            ("Just (-1)", "Just (-1)"),
+            ("-1", "-1"),
+            ("Just \"s\"", "Just ['s']"),
+            ("Just 'c'", "Just 'c'"),
+            ("\"ab\"", "['a', 'b']"),
+            ("\"\"", "[]"),
+            ("Just :ok", "Just :ok"),
+            ("Just 1.5", "Just 1.5"),
+            ("True", "True"),
+            ("Just (x:xs)", "Just (x:xs)"),
+        ] {
+            assert_eq!(roundtrip(&mut env, src), want);
+        }
+    }
+
+    #[test]
+    fn renders_witnesses() {
+        let mut env = env();
+        let just = env.lookup_con("Just").unwrap();
+        let nothing = env.lookup_con("Nothing").unwrap();
+        let t2 = env.tuple_con(2);
+        let w = vec![
+            WPat::Con(just, vec![WPat::Con(nothing, vec![])]),
+            WPat::Con(
+                CON_CONS,
+                vec![
+                    WPat::Wild,
+                    WPat::Con(CON_CONS, vec![WPat::Wild, WPat::Wild]),
+                ],
+            ),
+        ];
+        assert_eq!(render_witness(&env, &w), "(Just Nothing) (_:_:_)");
+        assert_eq!(render_witness(&env, &w[..1]), "Just Nothing");
+        assert_eq!(
+            render_witness(&env, &[WPat::Con(just, vec![WPat::Lit(Lit::Int(-1))])]),
+            "Just (-1)"
+        );
+        let w = vec![WPat::Con(
+            t2,
+            vec![
+                WPat::NotLit(vec![Lit::Int(0), Lit::Int(1)]),
+                WPat::Con(CON_NIL, vec![]),
+            ],
+        )];
+        assert_eq!(
+            render_witness(&env, &w),
+            "(p1, []) where p1 is not one of {0, 1}"
+        );
+        let w = vec![WPat::Con(
+            CON_CONS,
+            vec![WPat::Wild, WPat::Con(CON_NIL, vec![])],
+        )];
+        assert_eq!(render_witness(&env, &w), "[_]");
+    }
+}

data/ext/haskell_match/src/core/resolve.rs

@@ -0,0 +1,336 @@
+//! Resolution of `RawPat` into `Pat`: constructor lookup, arity checking,
+//! record field handling, variable numbering and duplicate detection.
+
+use super::ast::{Pat, RawPat, VarId};
+use super::error::{CoreError, ErrorKind, Result};
+use super::types::{TypeEnv, CON_CONS, CON_FALSE, CON_NIL, CON_TRUE};
+
+/// Per-clause binding table.  Variables are numbered in order of first
+/// appearance, left to right across all argument patterns of the clause.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Bindings {
+    pub names: Vec<String>,
+}
+
+impl Bindings {
+    fn bind(&mut self, name: &str) -> Result<VarId> {
+        if self.names.iter().any(|n| n == name) {
+            return Err(CoreError::new(
+                ErrorKind::DuplicateVariable,
+                format!("conflicting definitions for '{}' in the same clause", name),
+            ));
+        }
+        self.names.push(name.to_string());
+        Ok(self.names.len() - 1)
+    }
+}
+
+/// Resolve one clause consisting of `arity` argument patterns.
+pub fn resolve_clause(env: &mut TypeEnv, raws: &[RawPat]) -> Result<(Vec<Pat>, Bindings)> {
+    let mut b = Bindings::default();
+    let mut pats = Vec::with_capacity(raws.len());
+    for raw in raws {
+        pats.push(resolve(env, raw, &mut b)?);
+    }
+    Ok((pats, b))
+}
+
+fn resolve(env: &mut TypeEnv, raw: &RawPat, b: &mut Bindings) -> Result<Pat> {
+    Ok(match raw {
+        RawPat::Wild => Pat::Wild,
+        RawPat::Var(v) => Pat::Var(b.bind(v)?),
+        RawPat::As(v, p) => {
+            let id = b.bind(v)?;
+            Pat::As(id, Box::new(resolve(env, p, b)?))
+        }
+        RawPat::Lazy(p) => {
+            let inner = resolve(env, p, b)?;
+            // `~_`, `~x` are already irrefutable; keep the tree small
+            match inner {
+                Pat::Wild | Pat::Var(_) | Pat::Lazy(_) => inner,
+                other => Pat::Lazy(Box::new(other)),
+            }
+        }
+        RawPat::Bang(p) => resolve(env, p, b)?,
+        RawPat::Lit(l) => Pat::Lit(l.clone()),
+        RawPat::Tuple(items) => {
+            let con = env.tuple_con(items.len());
+            let mut args = Vec::with_capacity(items.len());
+            for it in items {
+                args.push(resolve(env, it, b)?);
+            }
+            Pat::Con(con, args)
+        }
+        RawPat::List(items) => {
+            let mut acc = Pat::Con(CON_NIL, vec![]);
+            let mut resolved = Vec::with_capacity(items.len());
+            for it in items {
+                resolved.push(resolve(env, it, b)?);
+            }
+            for p in resolved.into_iter().rev() {
+                acc = Pat::Con(CON_CONS, vec![p, acc]);
+            }
+            acc
+        }
+        RawPat::Cons(h, t) => {
+            let h = resolve(env, h, b)?;
+            let t = resolve(env, t, b)?;
+            Pat::Con(CON_CONS, vec![h, t])
+        }
+        RawPat::Con(name, args) => {
+            let con = lookup(env, name)?;
+            let arity = env.con(con).arity;
+            if arity != args.len() {
+                return Err(CoreError::new(
+                    ErrorKind::Arity,
+                    format!(
+                        "the constructor '{}' should have {} argument{}, but has been given {}",
+                        name,
+                        arity,
+                        if arity == 1 { "" } else { "s" },
+                        args.len()
+                    ),
+                ));
+            }
+            let mut rargs = Vec::with_capacity(args.len());
+            for a in args {
+                rargs.push(resolve(env, a, b)?);
+            }
+            Pat::Con(con, rargs)
+        }
+        RawPat::Hash(fields) => {
+            let mut out = Vec::with_capacity(fields.len());
+            for (k, p) in fields {
+                out.push((k.clone(), resolve(env, p, b)?));
+            }
+            Pat::Hash(out)
+        }
+        RawPat::Record(name, fields, wildcard) => {
+            let con = lookup(env, name)?;
+            let (arity, field_names) = {
+                let c = env.con(con);
+                (c.arity, c.fields.clone())
+            };
+            let mut args = vec![None; arity];
+            if !fields.is_empty() || *wildcard {
+                let field_names = field_names.ok_or_else(|| {
+                    CoreError::new(
+                        ErrorKind::Field,
+                        format!("constructor '{}' does not have named fields", name),
+                    )
+                })?;
+                for (f, p) in fields {
+                    let idx = field_names.iter().position(|n| n == f).ok_or_else(|| {
+                        CoreError::new(
+                            ErrorKind::Field,
+                            format!(
+                                "constructor '{}' does not have a field named '{}' (fields: {})",
+                                name,
+                                f,
+                                field_names.join(", ")
+                            ),
+                        )
+                    })?;
+                    args[idx] = Some(resolve(env, p, b)?);
+                }
+                if *wildcard {
+                    // RecordWildCards: bind every remaining field to its own name
+                    for (i, slot) in args.iter_mut().enumerate() {
+                        if slot.is_none() {
+                            *slot = Some(Pat::Var(b.bind(&field_names[i])?));
+                        }
+                    }
+                }
+            }
+            Pat::Con(
+                con,
+                args.into_iter().map(|a| a.unwrap_or(Pat::Wild)).collect(),
+            )
+        }
+    })
+}
+
+fn lookup(env: &TypeEnv, name: &str) -> Result<super::types::ConId> {
+    match name {
+        "True" => return Ok(CON_TRUE),
+        "False" => return Ok(CON_FALSE),
+        _ => {}
+    }
+    env.lookup_con(name).ok_or_else(|| {
+        CoreError::new(
+            ErrorKind::UnknownConstructor,
+            format!("not in scope: data constructor '{}'", name),
+        )
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::core::ast::Lit;
+    use crate::core::parser::parse_pattern;
+    use crate::core::types::ConSpec;
+
+    fn env() -> TypeEnv {
+        let mut env = TypeEnv::new();
+        env.register(
+            "Maybe",
+            &[
+                ConSpec {
+                    name: "Nothing".into(),
+                    arity: 0,
+                    fields: None,
+                    handle: 0,
+                },
+                ConSpec {
+                    name: "Just".into(),
+                    arity: 1,
+                    fields: None,
+                    handle: 0,
+                },
+            ],
+        )
+        .unwrap();
+        env.register(
+            "Person",
+            &[ConSpec {
+                name: "Person".into(),
+                arity: 2,
+                fields: Some(vec!["name".into(), "age".into()]),
+                handle: 0,
+            }],
+        )
+        .unwrap();
+        env
+    }
+
+    fn res(env: &mut TypeEnv, srcs: &[&str]) -> Result<(Vec<Pat>, Bindings)> {
+        let mut raws: Vec<RawPat> = Vec::new();
+        for s in srcs {
+            raws.push(parse_pattern(s)?);
+        }
+        resolve_clause(env, &raws)
+    }
+
+    #[test]
+    fn resolves_constructors_and_sugar() {
+        let mut env = env();
+        let just = env.lookup_con("Just").unwrap();
+        let (pats, b) = res(&mut env, &["Just x"]).unwrap();
+        assert_eq!(pats, vec![Pat::Con(just, vec![Pat::Var(0)])]);
+        assert_eq!(b.names, vec!["x"]);
+
+        let (pats, b) = res(&mut env, &["[a, b]"]).unwrap();
+        assert_eq!(
+            pats[0],
+            Pat::Con(
+                CON_CONS,
+                vec![
+                    Pat::Var(0),
+                    Pat::Con(CON_CONS, vec![Pat::Var(1), Pat::Con(CON_NIL, vec![])])
+                ]
+            )
+        );
+        assert_eq!(b.names, vec!["a", "b"]);
+
+        let t2 = env.tuple_con(2);
+        let (pats, _) = res(&mut env, &["(True, False)"]).unwrap();
+        assert_eq!(
+            pats[0],
+            Pat::Con(
+                t2,
+                vec![Pat::Con(CON_TRUE, vec![]), Pat::Con(CON_FALSE, vec![])]
+            )
+        );
+
+        let (pats, b) = res(&mut env, &["all@(x:xs)", "~(Just y)", "!z"]).unwrap();
+        assert_eq!(b.names, vec!["all", "x", "xs", "y", "z"]);
+        assert_eq!(
+            pats[0],
+            Pat::As(
+                0,
+                Box::new(Pat::Con(CON_CONS, vec![Pat::Var(1), Pat::Var(2)]))
+            )
+        );
+        assert_eq!(
+            pats[1],
+            Pat::Lazy(Box::new(Pat::Con(just, vec![Pat::Var(3)])))
+        );
+        assert_eq!(pats[2], Pat::Var(4));
+        // ~x is just x
+        let (pats, _) = res(&mut env, &["~x"]).unwrap();
+        assert_eq!(pats[0], Pat::Var(0));
+    }
+
+    #[test]
+    fn records() {
+        let mut env = env();
+        let person = env.lookup_con("Person").unwrap();
+        let (pats, b) = res(&mut env, &["Person { age = a }"]).unwrap();
+        assert_eq!(pats[0], Pat::Con(person, vec![Pat::Wild, Pat::Var(0)]));
+        assert_eq!(b.names, vec!["a"]);
+        let (pats, b) = res(&mut env, &["Person { name, .. }"]).unwrap();
+        assert_eq!(pats[0], Pat::Con(person, vec![Pat::Var(0), Pat::Var(1)]));
+        assert_eq!(b.names, vec!["name", "age"]);
+        let (pats, _) = res(&mut env, &["Person {}"]).unwrap();
+        assert_eq!(pats[0], Pat::Con(person, vec![Pat::Wild, Pat::Wild]));
+        // `Con {}` is allowed for positional constructors too
+        let (pats, _) = res(&mut env, &["Just {}"]).unwrap();
+        assert_eq!(
+            pats[0],
+            Pat::Con(env.lookup_con("Just").unwrap(), vec![Pat::Wild])
+        );
+        let (pats, _) = res(&mut env, &["Person 'b' 3"]).unwrap();
+        assert_eq!(
+            pats[0],
+            Pat::Con(
+                person,
+                vec![Pat::Lit(Lit::Char('b')), Pat::Lit(Lit::Int(3))]
+            )
+        );
+    }
+
+    #[test]
+    fn errors() {
+        let mut env = env();
+        assert_eq!(
+            res(&mut env, &["Nope x"]).unwrap_err().kind,
+            ErrorKind::UnknownConstructor
+        );
+        assert_eq!(res(&mut env, &["Just"]).unwrap_err().kind, ErrorKind::Arity);
+        assert_eq!(
+            res(&mut env, &["Just a b"]).unwrap_err().kind,
+            ErrorKind::Arity
+        );
+        assert_eq!(
+            res(&mut env, &["Nothing x"]).unwrap_err().kind,
+            ErrorKind::Arity
+        );
+        assert_eq!(
+            res(&mut env, &["(x, x)"]).unwrap_err().kind,
+            ErrorKind::DuplicateVariable
+        );
+        assert_eq!(
+            res(&mut env, &["x", "Just x"]).unwrap_err().kind,
+            ErrorKind::DuplicateVariable
+        );
+        assert_eq!(
+            res(&mut env, &["Person { nome = n }"]).unwrap_err().kind,
+            ErrorKind::Field
+        );
+        assert_eq!(
+            res(&mut env, &["Just { value = v }"]).unwrap_err().kind,
+            ErrorKind::Field
+        );
+        assert_eq!(
+            res(&mut env, &["Just { .. }"]).unwrap_err().kind,
+            ErrorKind::Field
+        );
+        assert_eq!(
+            res(&mut env, &["Person { name = n, name = m }"])
+                .unwrap_err()
+                .kind,
+            ErrorKind::Field
+        );
+    }
+}