================================================================================
instance: minimal
================================================================================

instance A a

--------------------------------------------------------------------------------

(haskell
  (declarations
    (instance
      (name)
      (type_patterns
        (variable)))))

================================================================================
instance: type
================================================================================

instance A A a A

--------------------------------------------------------------------------------

(haskell
  (declarations
    (instance
      (name)
      (type_patterns
        (name)
        (variable)
        (name)))))

================================================================================
instance: forall
================================================================================

instance forall a (a :: *) . A

--------------------------------------------------------------------------------

(haskell
  (declarations
    (instance
      (forall
        (quantified_variables
          (variable)
          (parens
            (annotated
              (variable)
              (star)))))
      (name))))

================================================================================
instance: context
================================================================================

instance A a => A
instance (A a, A a) => A

--------------------------------------------------------------------------------

(haskell
  (declarations
    (instance
      (context
        (apply
          (name)
          (variable)))
      (name))
    (instance
      (context
        (tuple
          (apply
            (name)
            (variable))
          (apply
            (name)
            (variable))))
      (name))))

================================================================================
instance: method inline
================================================================================

instance A a where a a = Just a

--------------------------------------------------------------------------------

(haskell
  (declarations
    (instance
      (name)
      (type_patterns
        (variable))
      (instance_declarations
        (function
          (variable)
          (patterns
            (variable))
          (match
            (apply
              (constructor)
              (variable))))))))

================================================================================
instance: signature
================================================================================

instance A a where
  a :: A a => a -> a
  a a = a

--------------------------------------------------------------------------------

(haskell
  (declarations
    (instance
      (name)
      (type_patterns
        (variable))
      (instance_declarations
        (signature
          (variable)
          (context
            (apply
              (name)
              (variable))
            (function
              (variable)
              (variable))))
        (function
          (variable)
          (patterns
            (variable))
          (match
            (variable)))))))

================================================================================
instance: infix context
================================================================================

instance a + a => A

--------------------------------------------------------------------------------

(haskell
  (declarations
    (instance
      (context
        (infix
          (variable)
          (operator)
          (variable)))
      (name))))

================================================================================
instance: equality constraint
================================================================================

instance A a ~ A a => A a
instance A ~~ A => ((A) a)

--------------------------------------------------------------------------------

(haskell
  (declarations
    (instance
      (context
        (infix
          (apply
            (name)
            (variable))
          (operator)
          (apply
            (name)
            (variable))))
      (name)
      (type_patterns
        (variable)))
    (instance
      (context
        (infix
          (name)
          (operator)
          (name)))
      (parens
        (parens
          (name))
        (type_patterns
          (variable))))))

================================================================================
instance: associated type instance
================================================================================

instance A where
  type A A a = A a
  type instance A @A a = A

--------------------------------------------------------------------------------

(haskell
  (declarations
    (instance
      (name)
      (instance_declarations
        (type_instance
          (name)
          (type_patterns
            (name)
            (variable))
          (apply
            (name)
            (variable)))
        (type_instance
          (name)
          (type_patterns
            (kind_application
              (name))
            (variable))
          (name))))))

================================================================================
instance: associated data instance
================================================================================

instance A where
  data A a = A a | A { a :: A }

  data instance ∀ a . A a => A a = A

  newtype A A where
    A :: A %1 -> A A

--------------------------------------------------------------------------------

(haskell
  (declarations
    (instance
      (name)
      (instance_declarations
        (data_instance
          (data_type
            (name)
            (type_patterns
              (variable))
            (data_constructors
              (data_constructor
                (prefix
                  (constructor)
                  (variable)))
              (data_constructor
                (record
                  (constructor)
                  (fields
                    (field
                      (field_name
                        (variable))
                      (name))))))))
        (data_instance
          (data_type
            (forall
              (quantified_variables
                (variable)))
            (context
              (apply
                (name)
                (variable)))
            (name)
            (type_patterns
              (variable))
            (data_constructors
              (data_constructor
                (prefix
                  (constructor))))))
        (data_instance
          (newtype
            (name)
            (type_patterns
              (name))
            (gadt_constructors
              (gadt_constructor
                (constructor)
                (prefix
                  (linear_function
                    (name)
                    (modifier
                      (literal
                        (integer)))
                    (apply
                      (name)
                      (name))))))))))))

================================================================================
instance: infix pattern lhs method
================================================================================

instance A where
  a == a = a

--------------------------------------------------------------------------------

(haskell
  (declarations
    (instance
      (name)
      (instance_declarations
        (function
          (infix
            (variable)
            (operator)
            (variable))
          (match
            (variable)))))))

================================================================================
instance: standalone deriving
================================================================================

deriving instance A (A a)
deriving instance A ++ A
deriving instance A a => A (A a)
deriving instance (A a, A a a) => A (A a)

--------------------------------------------------------------------------------

(haskell
  (declarations
    (deriving_instance
      (name)
      (type_patterns
        (parens
          (apply
            (name)
            (variable)))))
    (deriving_instance
      (infix
        (name)
        (operator)
        (name)))
    (deriving_instance
      (context
        (apply
          (name)
          (variable)))
      (name)
      (type_patterns
        (parens
          (apply
            (name)
            (variable)))))
    (deriving_instance
      (context
        (tuple
          (apply
            (name)
            (variable))
          (apply
            (apply
              (name)
              (variable))
            (variable))))
      (name)
      (type_patterns
        (parens
          (apply
            (name)
            (variable)))))))

================================================================================
instance: deriving via
================================================================================

deriving via (A a) instance A a

--------------------------------------------------------------------------------

(haskell
  (declarations
    (deriving_instance
      (via
        (parens
          (apply
            (name)
            (variable))))
      (name)
      (type_patterns
        (variable)))))

================================================================================
instance: qualified class
================================================================================

instance A.A a

--------------------------------------------------------------------------------

(haskell
  (declarations
    (instance
      (qualified
        (module
          (module_id))
        (name))
      (type_patterns
        (variable)))))

================================================================================
instance: nullary method
================================================================================

instance A where
  a = a

--------------------------------------------------------------------------------

(haskell
  (declarations
    (instance
      (name)
      (instance_declarations
        (bind
          (variable)
          (match
            (variable)))))))

================================================================================
instance: annotation
================================================================================

instance (A :: Constraint)
instance ((A :: Type -> Constraint) A :: Constraint)

--------------------------------------------------------------------------------

(haskell
  declarations: (declarations
    (instance
      (parens
        name: (name)
        kind: (name)))
    (instance
      (parens
        (parens
          name: (name)
          kind: (function
            parameter: (name)
            result: (name)))
        patterns: (type_patterns
          (name))
        kind: (name)))))

================================================================================
instance: minus
================================================================================

instance a - b where

--------------------------------------------------------------------------------

(haskell
  (declarations
    (instance
      (infix
        (variable)
        (operator)
        (variable)))))
