fn try_from(ast: AST) -> Result<Self, Self::Error> {
        // if true { todo!("SharedSymbol lookup"); }
        Ok(match ast {
            AST::Base(Base::Symbol(s)) => Pattern::Symbol(s),
            AST::Base(Base::Lit(d)) => Pattern::Lit(d),
            AST::Base(Base::Label(k)) => Err(format!(
                "This Label used in a pattern does not unwrap any data.\n\
                    To match a Label and ignore its contents, use `{:?} _`",
                k,
            ))?,
            AST::Base(Base::Tuple(t)) => {
                let mut patterns = vec![];
                for item in t {
                    patterns.push(item.try_map(Pattern::try_from)?);
                }
                Pattern::Tuple(patterns)
            }

            // AST::Sugar(Sugar::Pattern(p)) => p,
            AST::Sugar(Sugar::Form(f)) => {
                let mut patterns = vec![];
                for item in f {
                    patterns.push(item.try_map(Pattern::try_from)?);
                }
                Pattern::Chain(patterns)
            }
            AST::Sugar(Sugar::Group(e)) => e.try_map(Pattern::try_from)?.item,
            _ => Err("Unexpected construct inside pattern")?,
        })
    }
Tries to convert an `AST` into a `Pattern`.
Patterns mirror the `AST`s they are designed to
destructure. During parsing, they are just
parsed as `AST`s - When the compiler can
determine that an AST is actually a pattern,
It performs this conversion.
passerine/src/construct/tree.rs