{-# Language ConstraintKinds, DataKinds, FlexibleContexts, FlexibleInstances, MultiParamTypeClasses,
             OverloadedStrings, RankNTypes, ScopedTypeVariables,
             TypeApplications, TypeFamilies, TypeOperators, UndecidableInstances #-}

-- | The module exports functions that reformulate an AST in terms of the language extensions it uses.
module Language.Haskell.Extensions.Reformulator (ReformulationOf, Wrap,
                                                 dropRecordWildCards, dropNPlusKPatterns, dropNoListTuplePuns)
where

import qualified Data.Foldable1 as Foldable1
import Data.Foldable1 (Foldable1)
import Data.Functor.Compose (Compose (Compose, getCompose))
import qualified Data.List as List
import qualified Data.Map.Lazy as Map
import Data.Monoid.Textual (TextualMonoid)
import Data.Semigroup.Union (UnionWith(..))

import qualified Rank2
import qualified Transformation
import Transformation (Transformation)
import qualified Transformation.AG.Dimorphic as Di
import qualified Transformation.Full as Full

import Language.Haskell.Extensions.Abstract (DeeplyFunctor, ExtendedWithAllOf)
import Language.Haskell.Extensions (Extension, ExtensionSwitch (ExtensionSwitch), On, Off)
import qualified Language.Haskell.Extensions as Extensions
import qualified Language.Haskell.Extensions.Abstract as Abstract
import qualified Language.Haskell.Extensions.AST as AST
import Language.Haskell.Extensions.Translation (
   NameTranslation, Translation, WrapTranslation, WrappedTranslation, FullyTranslatable)
import qualified Language.Haskell.Extensions.Translation as Translation
import Language.Haskell.Extensions.Verifier (Accounting (Accounting))
import qualified Language.Haskell.Binder as Binder
import qualified Language.Haskell.Reserializer as Reserializer

type family Without (e :: Extension) (es :: [Extension]) where
   Without _ '[] = '[]
   Without e (e ': es) = Without e es
   Without e1 (e2 ': es) = e2 ': Without e1 es

type family Difference (xs :: [Extension]) (ys :: [Extension]) where
   Difference xs '[] = xs
   Difference xs (y ': ys) = Difference (Without y xs) ys

type Transpiler λ1 λ2 f = Abstract.Module λ1 λ1 f f -> Abstract.Module λ2 λ2 f f

type Reformulator xs ys λ c f = ExtendedWithAllOf xs λ =>
   forall l. (Abstract.Haskell l, ExtendedWithAllOf (Difference ys xs) l, c λ l) => Transpiler λ l f

-- | The same node wrap is used by both the original and target language.
type Wrap l pos s = Binder.WithEnvironment l (Reserializer.Wrapped pos s)

-- | Transformation to reformulate code from language @λ@ using extension @e@ to language @l@ using extensions @es@
data ReformulationOf (e :: ExtensionSwitch) (es :: [ExtensionSwitch]) λ l pos s
   = Reformulation ExtensionSwitch [ExtensionSwitch] -- e es

instance (Abstract.QualifiedName λ ~ AST.QualifiedName λ,
          Abstract.ModuleName λ ~ AST.ModuleName λ,
          Abstract.Name λ ~ AST.Name λ,
          Abstract.QualifiedName l ~ AST.QualifiedName l,
          Abstract.ModuleName l ~ AST.ModuleName l,
          Abstract.Name l ~ AST.Name l) =>
  NameTranslation (ReformulationOf e es λ l pos s) where
   type Origin (ReformulationOf e es λ l pos s) = λ
   type Target (ReformulationOf e es λ l pos s) = l

instance (Abstract.QualifiedName λ ~ AST.QualifiedName λ,
          Abstract.ModuleName λ ~ AST.ModuleName λ,
          Abstract.Name λ ~ AST.Name λ,
          Abstract.QualifiedName l ~ AST.QualifiedName l,
          Abstract.ModuleName l ~ AST.ModuleName l,
          Abstract.Name l ~ AST.Name l) =>
  WrapTranslation (ReformulationOf e es λ l pos s) where
   type Wrap (ReformulationOf e es λ l pos s) = Wrap λ pos s

type SameWrap (e :: Extension) (es :: [Extension]) pos s l1 l2 = (
   Abstract.QualifiedName l1 ~ AST.QualifiedName l1,
   Abstract.ModuleName l1 ~ AST.ModuleName l1,
   Abstract.Name l1 ~ AST.Name l1,
   Abstract.QualifiedName l2 ~ AST.QualifiedName l2,
   Abstract.ModuleName l2 ~ AST.ModuleName l2,
   Abstract.Name l2 ~ AST.Name l2,
   Abstract.Module l1 ~ AST.Module l1,
   Abstract.Export l1 ~ AST.Export l1,
   Abstract.Import l1 ~ AST.Import l1,
   Abstract.ImportSpecification l1 ~ AST.ImportSpecification l1,
   Abstract.ImportItem l1 ~ AST.ImportItem l1,
   Abstract.Declaration l1 ~ AST.Declaration l1,
   Abstract.EquationLHS l1 ~ AST.EquationLHS l1,
   Abstract.EquationRHS l1 ~ AST.EquationRHS l1,
   Abstract.ClassInstanceLHS l1 ~ AST.ClassInstanceLHS l1,
   Abstract.Context l1 ~ AST.Context l1,
   Abstract.TypeLHS l1 ~ AST.TypeLHS l1,
   Abstract.Type l1 ~ AST.Type l1,
   Abstract.Kind l1 ~ AST.Type l1,
   Abstract.TypeVarBinding l1 ~ AST.TypeVarBinding l1,
   Abstract.Constructor l1 ~ AST.Constructor l1,
   Abstract.DataConstructor l1 ~ AST.DataConstructor l1,
   Abstract.GADTConstructor l1 ~ AST.GADTConstructor l1,
   Abstract.DerivingClause l1 ~ AST.DerivingClause l1,
   Abstract.FieldDeclaration l1 ~ AST.FieldDeclaration l1,
   Abstract.FieldBinding l1 ~ AST.FieldBinding l1,
   Abstract.FieldPattern l1 ~ AST.FieldPattern l1,
   Abstract.Pattern l1 ~ AST.Pattern l1,
   Abstract.GuardedExpression l1 ~ AST.GuardedExpression l1,
   Abstract.Expression l1 ~ AST.Expression l1,
   Abstract.Statement l1 ~ AST.Statement l1,
   Abstract.CaseAlternative l1 ~ AST.CaseAlternative l1,
   Abstract.Value l1 ~ AST.Value l1,
   Binder.WithEnvironment l1 ~ Binder.WithEnvironment l2)

-- | Eliminate the @NoListTuplePuns@ extension.
dropNoListTuplePuns :: forall l1 l2 node pos s.
                       (Abstract.Haskell l2,
                        FullyTranslatable
                           (ReformulationOf (Off 'Extensions.ListTuplePuns) '[ ] l1 l2 pos s)
                           node)
                    => Wrap l1 pos s (node l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))
                    -> Wrap l1 pos s (node l2 l2 (Wrap l1 pos s) (Wrap l1 pos s))
dropNoListTuplePuns :: forall l1 l2 (node :: TreeNodeKind) pos s.
(Haskell l2,
 FullyTranslatable
   (ReformulationOf (Off 'ListTuplePuns) '[] l1 l2 pos s) node) =>
Wrap l1 pos s (node l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))
-> Wrap l1 pos s (node l2 l2 (Wrap l1 pos s) (Wrap l1 pos s))
dropNoListTuplePuns =
   ReformulationOf (Off 'ListTuplePuns) '[] l1 l2 pos s
-> Wrap
     (ReformulationOf (Off 'ListTuplePuns) '[] l1 l2 pos s)
     (node
        (Origin (ReformulationOf (Off 'ListTuplePuns) '[] l1 l2 pos s))
        (Origin (ReformulationOf (Off 'ListTuplePuns) '[] l1 l2 pos s))
        (Wrap (ReformulationOf (Off 'ListTuplePuns) '[] l1 l2 pos s))
        (Wrap (ReformulationOf (Off 'ListTuplePuns) '[] l1 l2 pos s)))
-> Wrap
     (ReformulationOf (Off 'ListTuplePuns) '[] l1 l2 pos s)
     (node
        (Target (ReformulationOf (Off 'ListTuplePuns) '[] l1 l2 pos s))
        (Target (ReformulationOf (Off 'ListTuplePuns) '[] l1 l2 pos s))
        (Wrap (ReformulationOf (Off 'ListTuplePuns) '[] l1 l2 pos s))
        (Wrap (ReformulationOf (Off 'ListTuplePuns) '[] l1 l2 pos s)))
forall t (node :: TreeNodeKind).
(FullyTranslatable t node, Functor (Wrap t)) =>
t
-> Wrap t (node (Origin t) (Origin t) (Wrap t) (Wrap t))
-> Wrap t (node (Target t) (Target t) (Wrap t) (Wrap t))
Translation.translateFully
      (ExtensionSwitch
-> [ExtensionSwitch]
-> ReformulationOf (Off 'ListTuplePuns) '[] l1 l2 pos s
forall (e :: ExtensionSwitch) (es :: [ExtensionSwitch]) λ l pos s.
ExtensionSwitch
-> [ExtensionSwitch] -> ReformulationOf e es λ l pos s
Reformulation (Extension -> ExtensionSwitch
Extensions.off Extension
Extensions.ListTuplePuns) []
       :: ReformulationOf (Off 'Extensions.ListTuplePuns) '[ ] l1 l2 pos s)

-- | Eliminate the 'Extensions.RecordWildCards' extension and replace it with 'Extensions.NamedFieldPuns'.
dropRecordWildCards :: forall l1 l2 node pos s.
                       (Abstract.Haskell l2, Abstract.ExtendedWith '[ 'Extensions.NamedFieldPuns ] l2,
                        SameWrap 'Extensions.RecordWildCards '[ 'Extensions.NamedFieldPuns ] pos s l1 l2,
                        FullyTranslatable
                           (ReformulationOf (On 'Extensions.RecordWildCards) '[ On 'Extensions.NamedFieldPuns ] l1 l2 pos s)
                           node)
                    => Wrap l1 pos s (node l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))
                    -> Wrap l1 pos s (node l2 l2 (Wrap l1 pos s) (Wrap l1 pos s))
dropRecordWildCards :: forall l1 l2 (node :: TreeNodeKind) pos s.
(Haskell l2, ExtendedWith '[ 'NamedFieldPuns] l2,
 SameWrap 'RecordWildCards '[ 'NamedFieldPuns] pos s l1 l2,
 FullyTranslatable
   (ReformulationOf
      (On 'RecordWildCards) '[On 'NamedFieldPuns] l1 l2 pos s)
   node) =>
Wrap l1 pos s (node l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))
-> Wrap l1 pos s (node l2 l2 (Wrap l1 pos s) (Wrap l1 pos s))
dropRecordWildCards =
   ReformulationOf
  (On 'RecordWildCards) '[On 'NamedFieldPuns] l1 l2 pos s
-> Wrap
     (ReformulationOf
        (On 'RecordWildCards) '[On 'NamedFieldPuns] l1 l2 pos s)
     (node
        (Origin
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] l1 l2 pos s))
        (Origin
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] l1 l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] l1 l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] l1 l2 pos s)))
-> Wrap
     (ReformulationOf
        (On 'RecordWildCards) '[On 'NamedFieldPuns] l1 l2 pos s)
     (node
        (Target
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] l1 l2 pos s))
        (Target
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] l1 l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] l1 l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] l1 l2 pos s)))
forall t (node :: TreeNodeKind).
(FullyTranslatable t node, Functor (Wrap t)) =>
t
-> Wrap t (node (Origin t) (Origin t) (Wrap t) (Wrap t))
-> Wrap t (node (Target t) (Target t) (Wrap t) (Wrap t))
Translation.translateFully
      (ExtensionSwitch
-> [ExtensionSwitch]
-> ReformulationOf
     (On 'RecordWildCards) '[On 'NamedFieldPuns] l1 l2 pos s
forall (e :: ExtensionSwitch) (es :: [ExtensionSwitch]) λ l pos s.
ExtensionSwitch
-> [ExtensionSwitch] -> ReformulationOf e es λ l pos s
Reformulation (Extension -> ExtensionSwitch
Extensions.on Extension
Extensions.RecordWildCards) [Extension -> ExtensionSwitch
Extensions.on Extension
Extensions.NamedFieldPuns]
       :: ReformulationOf (On 'Extensions.RecordWildCards) '[ On 'Extensions.NamedFieldPuns ] l1 l2 pos s)

-- | Eliminate the 'Extensions.NPlusKPatterns' extension and replace it with 'Extensions.ViewPatterns'.
dropNPlusKPatterns :: forall l1 l2 node pos s.
                      (Abstract.Haskell l2, Abstract.ExtendedWith '[ 'Extensions.ViewPatterns ] l2,
                       SameWrap 'Extensions.NPlusKPatterns '[ 'Extensions.ViewPatterns ] pos s l1 l2,
                       FullyTranslatable
                          (ReformulationOf (On 'Extensions.NPlusKPatterns) '[ On 'Extensions.ViewPatterns ] l1 l2 pos s)
                          node)
                    => Wrap l1 pos s (node l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))
                    -> Wrap l1 pos s (node l2 l2 (Wrap l1 pos s) (Wrap l1 pos s))
dropNPlusKPatterns :: forall l1 l2 (node :: TreeNodeKind) pos s.
(Haskell l2, ExtendedWith '[ 'ViewPatterns] l2,
 SameWrap 'NPlusKPatterns '[ 'ViewPatterns] pos s l1 l2,
 FullyTranslatable
   (ReformulationOf
      (On 'NPlusKPatterns) '[On 'ViewPatterns] l1 l2 pos s)
   node) =>
Wrap l1 pos s (node l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))
-> Wrap l1 pos s (node l2 l2 (Wrap l1 pos s) (Wrap l1 pos s))
dropNPlusKPatterns =
   ReformulationOf
  (On 'NPlusKPatterns) '[On 'ViewPatterns] l1 l2 pos s
-> Wrap
     (ReformulationOf
        (On 'NPlusKPatterns) '[On 'ViewPatterns] l1 l2 pos s)
     (node
        (Origin
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] l1 l2 pos s))
        (Origin
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] l1 l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] l1 l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] l1 l2 pos s)))
-> Wrap
     (ReformulationOf
        (On 'NPlusKPatterns) '[On 'ViewPatterns] l1 l2 pos s)
     (node
        (Target
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] l1 l2 pos s))
        (Target
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] l1 l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] l1 l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] l1 l2 pos s)))
forall t (node :: TreeNodeKind).
(FullyTranslatable t node, Functor (Wrap t)) =>
t
-> Wrap t (node (Origin t) (Origin t) (Wrap t) (Wrap t))
-> Wrap t (node (Target t) (Target t) (Wrap t) (Wrap t))
Translation.translateFully
      (ExtensionSwitch
-> [ExtensionSwitch]
-> ReformulationOf
     (On 'NPlusKPatterns) '[On 'ViewPatterns] l1 l2 pos s
forall (e :: ExtensionSwitch) (es :: [ExtensionSwitch]) λ l pos s.
ExtensionSwitch
-> [ExtensionSwitch] -> ReformulationOf e es λ l pos s
Reformulation (Extension -> ExtensionSwitch
Extensions.on Extension
Extensions.NPlusKPatterns) [Extension -> ExtensionSwitch
Extensions.on Extension
Extensions.ViewPatterns]
       :: ReformulationOf (On 'Extensions.NPlusKPatterns) '[ On 'Extensions.ViewPatterns ] l1 l2 pos s)

-- Generic instance to adjust the LANGUAGE pragma

instance (TextualMonoid s,
          Abstract.DeeplyFoldable (Accounting l1 pos s) l1,
          Abstract.QualifiedName l1 ~ AST.QualifiedName l1,
          Abstract.QualifiedName l2 ~ AST.QualifiedName l2,
          Abstract.ModuleName l1 ~ AST.ModuleName l1,
          Abstract.ModuleName l2 ~ AST.ModuleName l2,
          Abstract.Name l1 ~ AST.Name l1,
          Abstract.Name l2 ~ AST.Name l2,
          Abstract.Module l1 ~ AST.Module l1,
          Abstract.Module l2 ~ AST.Module l2) => Translation (ReformulationOf e es l1 l2 pos s) AST.Module
  where
   translate :: ReformulationOf e es l1 l2 pos s
-> Module
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
-> Module
     (Target (ReformulationOf e es l1 l2 pos s))
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
translate t :: ReformulationOf e es l1 l2 pos s
t@(Reformulation e :: ExtensionSwitch
e@(ExtensionSwitch (Extension
e', Bool
_)) [ExtensionSwitch]
es) (AST.ExtendedModule [ExtensionSwitch]
oldExts Wrap
  (ReformulationOf e es l1 l2 pos s)
  (Module
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s)))
m)
      | Extension -> Map Extension [(pos, pos)] -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.notMember Extension
e' (UnionWith (Map Extension) [(pos, pos)]
-> Map Extension [(pos, pos)]
forall (f :: * -> *) m. UnionWith f m -> f m
getUnionWith (UnionWith (Map Extension) [(pos, pos)]
 -> Map Extension [(pos, pos)])
-> UnionWith (Map Extension) [(pos, pos)]
-> Map Extension [(pos, pos)]
forall a b. (a -> b) -> a -> b
$ Accounting l1 pos s
-> Domain
     (Accounting l1 pos s)
     (Module
        l1
        l1
        (Domain (Accounting l1 pos s))
        (Domain (Accounting l1 pos s)))
-> UnionWith (Map Extension) [(pos, pos)]
forall m.
(Codomain (Accounting l1 pos s) ~ Const m, Monoid m) =>
Accounting l1 pos s
-> Domain
     (Accounting l1 pos s)
     (Module
        l1
        l1
        (Domain (Accounting l1 pos s))
        (Domain (Accounting l1 pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMap (Accounting l1 pos s
forall l pos s. Accounting l pos s
Accounting :: Accounting l1 pos s) Domain
  (Accounting l1 pos s)
  (Module
     l1
     l1
     (Domain (Accounting l1 pos s))
     (Domain (Accounting l1 pos s)))
Wrap
  (ReformulationOf e es l1 l2 pos s)
  (Module
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s)))
m)
      = [ExtensionSwitch]
-> Module
     (Target (ReformulationOf e es l1 l2 pos s))
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
withExtensions (ExtensionSwitch -> [ExtensionSwitch] -> [ExtensionSwitch]
forall a. Eq a => a -> [a] -> [a]
List.delete ExtensionSwitch
e [ExtensionSwitch]
oldExts)
      | Bool
otherwise = [ExtensionSwitch]
-> Module
     (Target (ReformulationOf e es l1 l2 pos s))
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
withExtensions ([ExtensionSwitch] -> [ExtensionSwitch] -> [ExtensionSwitch]
forall a. Eq a => [a] -> [a] -> [a]
List.union [ExtensionSwitch]
es ([ExtensionSwitch] -> [ExtensionSwitch])
-> [ExtensionSwitch] -> [ExtensionSwitch]
forall a b. (a -> b) -> a -> b
$ ExtensionSwitch -> [ExtensionSwitch] -> [ExtensionSwitch]
forall a. Eq a => a -> [a] -> [a]
List.delete ExtensionSwitch
e [ExtensionSwitch]
oldExts)
      where withExtensions :: [ExtensionSwitch]
-> Module
     (Target (ReformulationOf e es l1 l2 pos s))
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
withExtensions [] = ReformulationOf e es l1 l2 pos s
-> Module
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
-> Module
     (Target (ReformulationOf e es l1 l2 pos s))
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
forall t (node :: TreeNodeKind).
Translation t node =>
t
-> node (Origin t) (Origin t) (Wrap t) (Wrap t)
-> node (Target t) (Origin t) (Wrap t) (Wrap t)
Translation.translate ReformulationOf e es l1 l2 pos s
t (Compose
  ((,) (Attributes l1))
  ((,) (pos, ParsedLexemes s, pos))
  (Module l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))
-> Module l1 l1 (Wrap l1 pos s) (Wrap l1 pos s)
forall a.
Compose ((,) (Attributes l1)) ((,) (pos, ParsedLexemes s, pos)) a
-> a
forall (t :: * -> *) a. Foldable1 t => t a -> a
Foldable1.head Compose
  ((,) (Attributes l1))
  ((,) (pos, ParsedLexemes s, pos))
  (Module l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))
Wrap
  (ReformulationOf e es l1 l2 pos s)
  (Module
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s)))
m)
            withExtensions [ExtensionSwitch]
exts = [ExtensionSwitch]
-> Wrap l1 pos s (Module l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))
-> Module l2 l1 (Wrap l1 pos s) (Wrap l1 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
[ExtensionSwitch] -> s (Module l l d d) -> Module λ l d s
AST.ExtendedModule [ExtensionSwitch]
exts Wrap l1 pos s (Module l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))
Wrap
  (ReformulationOf e es l1 l2 pos s)
  (Module
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Origin (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s))
     (Wrap (ReformulationOf e es l1 l2 pos s)))
m
   translate ReformulationOf e es l1 l2 pos s
t (AST.NamedModule ModuleName (Origin (ReformulationOf e es l1 l2 pos s))
name Maybe
  [Wrap
     (ReformulationOf e es l1 l2 pos s)
     (Export
        (Origin (ReformulationOf e es l1 l2 pos s))
        (Origin (ReformulationOf e es l1 l2 pos s))
        (Wrap (ReformulationOf e es l1 l2 pos s))
        (Wrap (ReformulationOf e es l1 l2 pos s)))]
exports [Wrap
   (ReformulationOf e es l1 l2 pos s)
   (Import
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s)))]
imports [Wrap
   (ReformulationOf e es l1 l2 pos s)
   (Declaration
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s)))]
declarations) =
      ModuleName l2
-> Maybe
     [Wrap l1 pos s (Export l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))]
-> [Wrap l1 pos s (Import l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))]
-> [Wrap
      l1 pos s (Declaration l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))]
-> Module l2 l1 (Wrap l1 pos s) (Wrap l1 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
ModuleName λ
-> Maybe [s (Export l l d d)]
-> [s (Import l l d d)]
-> [s (Declaration l l d d)]
-> Module λ l d s
AST.NamedModule (ReformulationOf e es l1 l2 pos s
-> ModuleName (Origin (ReformulationOf e es l1 l2 pos s))
-> ModuleName (Target (ReformulationOf e es l1 l2 pos s))
forall t.
NameTranslation t =>
t -> ModuleName (Origin t) -> ModuleName (Target t)
Translation.translateModuleName ReformulationOf e es l1 l2 pos s
t ModuleName (Origin (ReformulationOf e es l1 l2 pos s))
name) Maybe
  [Wrap l1 pos s (Export l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))]
Maybe
  [Wrap
     (ReformulationOf e es l1 l2 pos s)
     (Export
        (Origin (ReformulationOf e es l1 l2 pos s))
        (Origin (ReformulationOf e es l1 l2 pos s))
        (Wrap (ReformulationOf e es l1 l2 pos s))
        (Wrap (ReformulationOf e es l1 l2 pos s)))]
exports [Wrap l1 pos s (Import l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))]
[Wrap
   (ReformulationOf e es l1 l2 pos s)
   (Import
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s)))]
imports [Wrap l1 pos s (Declaration l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))]
[Wrap
   (ReformulationOf e es l1 l2 pos s)
   (Declaration
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s)))]
declarations
   translate ReformulationOf e es l1 l2 pos s
t (AST.AnonymousModule [Wrap
   (ReformulationOf e es l1 l2 pos s)
   (Import
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s)))]
imports [Wrap
   (ReformulationOf e es l1 l2 pos s)
   (Declaration
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s)))]
declarations) = [Wrap l1 pos s (Import l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))]
-> [Wrap
      l1 pos s (Declaration l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))]
-> Module l2 l1 (Wrap l1 pos s) (Wrap l1 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
[s (Import l l d d)] -> [s (Declaration l l d d)] -> Module λ l d s
AST.AnonymousModule [Wrap l1 pos s (Import l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))]
[Wrap
   (ReformulationOf e es l1 l2 pos s)
   (Import
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s)))]
imports [Wrap l1 pos s (Declaration l1 l1 (Wrap l1 pos s) (Wrap l1 pos s))]
[Wrap
   (ReformulationOf e es l1 l2 pos s)
   (Declaration
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Origin (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s))
      (Wrap (ReformulationOf e es l1 l2 pos s)))]
declarations

-- RecordWildCards instances

instance (SameWrap 'Extensions.RecordWildCards '[ 'Extensions.NamedFieldPuns ] pos s λ l2,
          Abstract.Supports 'Extensions.RecordWildCards λ,
          Abstract.FieldPattern l2 ~ AST.FieldPattern l2,
          Abstract.QualifiedName l2 ~ AST.QualifiedName l2,
          Abstract.ModuleName l2 ~ AST.ModuleName l2,
          Abstract.Name l2 ~ AST.Name l2) =>
   WrappedTranslation
      (ReformulationOf (On 'Extensions.RecordWildCards) '[On 'Extensions.NamedFieldPuns] λ l2 pos s)
      AST.Pattern
  where
   translateWrapped :: ReformulationOf
  (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l2 pos s
-> Wrap
     (ReformulationOf
        (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l2 pos s)
     (Pattern
        (Origin
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l2 pos s))
        (Origin
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l2 pos s)))
-> Wrap
     (ReformulationOf
        (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l2 pos s)
     (Pattern
        (Target
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l2 pos s))
        (Origin
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l2 pos s)))
translateWrapped
      Reformulation{}
      (Compose (env :: Attributes l2
env@(Di.Atts UnionWith (Map (QualifiedName l2)) (Binding l2)
inherited LocalEnvironment l2
_),
               ((pos, ParsedLexemes s, pos)
s, AST.WildcardRecordPattern () con :: QualifiedName l2
con@(AST.QualifiedName Maybe (ModuleName l2)
modName Name l2
_) [Compose
   ((,) (Attributes l2))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
fields))) =
      (Attributes l2,
 ((pos, ParsedLexemes s, pos),
  Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (Attributes l2
env, ((pos, ParsedLexemes s, pos)
s, QualifiedName l2
-> [Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
-> Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
QualifiedName λ -> [s (FieldPattern l l d d)] -> Pattern λ l d s
AST.RecordPattern QualifiedName l2
con ([Compose
    ((,) (Attributes l2))
    ((,) (pos, ParsedLexemes s, pos))
    (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
 -> Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> [Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
-> Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall a b. (a -> b) -> a -> b
$ [Compose
   ((,) (Attributes l2))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
fields [Compose
   ((,) (Attributes l2))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
-> [Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
-> [Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
forall a. [a] -> [a] -> [a]
++ [Compose
   ((,) (Attributes l2))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
[Compose
   ((,) (Attributes l2))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
implicitFields))
      where implicitFields :: [Compose
   ((,) (Attributes l2))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
implicitFields = case QualifiedName l2
-> UnionWith (Map (QualifiedName l2)) (Binding l2)
-> Maybe (ValueBinding l2)
forall l.
QualifiedName l -> Environment l -> Maybe (ValueBinding l)
Binder.lookupValue QualifiedName l2
QualifiedName l2
con UnionWith (Map (QualifiedName l2)) (Binding l2)
inherited of
               Just (Binder.RecordConstructor (UnionWith Map (Name l2) (Binding l2)
declaredFields)) ->
                  [ (Attributes l2,
 ((pos, ParsedLexemes s, pos),
  FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (UnionWith (Map (QualifiedName l2)) (Binding l2)
-> LocalEnvironment l2 -> Attributes l2
forall a b. a -> b -> Atts a b
Di.Atts UnionWith (Map (QualifiedName l2)) (Binding l2)
inherited LocalEnvironment l2
forall a. Monoid a => a
mempty, ((pos, ParsedLexemes s, pos)
s, QualifiedName l2
-> FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
QualifiedName λ -> FieldPattern λ l d s
AST.PunnedFieldPattern (QualifiedName l2
 -> FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> QualifiedName l2
-> FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall a b. (a -> b) -> a -> b
$ Name l2 -> QualifiedName l2
qualified Name l2
fieldName))
                  | Name l2
fieldName <- Map (Name l2) (Binding l2) -> [Name l2]
forall k a. Map k a -> [k]
Map.keys Map (Name l2) (Binding l2)
declaredFields, Name l2
fieldName Name l2 -> [Name l2] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Name l2]
explicitFieldNames]
               Just ValueBinding l2
_ -> [Char]
-> [Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
forall a. HasCallStack => [Char] -> a
error ([Char]
"Environment misaattributes record constructor " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ QualifiedName l2 -> [Char]
forall a. Show a => a -> [Char]
show QualifiedName l2
QualifiedName l2
con)
               Maybe (ValueBinding l2)
Nothing -> [Char]
-> [Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
forall a. HasCallStack => [Char] -> a
error ([Char]
"Environment lacks record constructor " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ QualifiedName l2 -> [Char]
forall a. Show a => a -> [Char]
show QualifiedName l2
QualifiedName l2
con)
            explicitFieldNames :: [Name l2]
explicitFieldNames = (Compose
   ((,) (Attributes l2))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
 -> Name l2)
-> [Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
-> [Name l2]
forall a b. (a -> b) -> [a] -> [b]
map (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s) -> Name l2
forall {λ} {l} {l} {d :: * -> *} {s :: * -> *}.
(QualifiedName λ ~ QualifiedName l) =>
FieldPattern λ l d s -> Name l
explicitFieldName (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s) -> Name l2)
-> (Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
    -> FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Name l2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((pos, ParsedLexemes s, pos),
 FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall a b. (a, b) -> b
snd (((pos, ParsedLexemes s, pos),
  FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
 -> FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> (Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
    -> ((pos, ParsedLexemes s, pos),
        FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Attributes l2,
 ((pos, ParsedLexemes s, pos),
  FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> ((pos, ParsedLexemes s, pos),
    FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a, b) -> b
snd ((Attributes l2,
  ((pos, ParsedLexemes s, pos),
   FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
 -> ((pos, ParsedLexemes s, pos),
     FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> (Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
    -> (Attributes l2,
        ((pos, ParsedLexemes s, pos),
         FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> ((pos, ParsedLexemes s, pos),
    FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compose
  ((,) (Attributes l2))
  ((,) (pos, ParsedLexemes s, pos))
  (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> (Attributes l2,
    ((pos, ParsedLexemes s, pos),
     FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose) [Compose
   ((,) (Attributes l2))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
[Compose
   ((,) (Attributes l2))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldPattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
fields
            explicitFieldName :: FieldPattern λ l d s -> Name l
explicitFieldName (AST.FieldPattern QualifiedName λ
name s (Pattern l l d d)
_) = QualifiedName l -> Name l
forall l. QualifiedName l -> Name l
Binder.baseName QualifiedName λ
QualifiedName l
name
            explicitFieldName (AST.PunnedFieldPattern QualifiedName λ
name) = QualifiedName l -> Name l
forall l. QualifiedName l -> Name l
Binder.baseName QualifiedName λ
QualifiedName l
name
            qualified :: Name l2 -> QualifiedName l2
qualified Name l2
name = Maybe (ModuleName l2) -> Name l2 -> QualifiedName l2
forall λ. Maybe (ModuleName λ) -> Name λ -> QualifiedName λ
AST.QualifiedName Maybe (ModuleName l2)
modName Name l2
name
   translateWrapped Reformulation{} (Compose (Attributes l2
env, ((pos, ParsedLexemes s, pos)
s, Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
p))) = (Attributes l2,
 ((pos, ParsedLexemes s, pos),
  Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (Attributes l2
env, ((pos, ParsedLexemes s, pos)
s, Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
p))

instance (SameWrap 'Extensions.RecordWildCards '[ 'Extensions.NamedFieldPuns ] pos s λ l,
          Abstract.Supports 'Extensions.RecordWildCards λ,
          Abstract.Haskell l,
          Abstract.FieldBinding l ~ AST.FieldBinding l,
          Abstract.QualifiedName l ~ AST.QualifiedName l,
          Abstract.ModuleName l ~ AST.ModuleName l,
          Abstract.Name l ~ AST.Name l) =>
   ReformulationOf (On 'Extensions.RecordWildCards) '[On 'Extensions.NamedFieldPuns] λ l pos s
   `WrappedTranslation` AST.Expression
  where
   ReformulationOf
  (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l pos s
_ translateWrapped :: ReformulationOf
  (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l pos s
-> Wrap
     (ReformulationOf
        (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l pos s)
     (Expression
        (Origin
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l pos s))
        (Origin
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l pos s))
        (Wrap
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l pos s))
        (Wrap
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l pos s)))
-> Wrap
     (ReformulationOf
        (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l pos s)
     (Expression
        (Target
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l pos s))
        (Origin
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l pos s))
        (Wrap
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l pos s))
        (Wrap
           (ReformulationOf
              (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l pos s)))
`translateWrapped` Compose (env :: Attributes l
env@(Di.Atts UnionWith (Map (QualifiedName l)) (Binding l)
inherited LocalEnvironment l
_),
                                 ((pos, ParsedLexemes s, pos)
s, AST.WildcardRecordExpression () con :: QualifiedName l
con@(AST.QualifiedName Maybe (ModuleName l)
modName Name l
_) [Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
fields)) =
      (Attributes l,
 ((pos, ParsedLexemes s, pos),
  Expression l l (Wrap l pos s) (Wrap l pos s)))
-> Compose
     ((,) (Attributes l))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l l (Wrap l pos s) (Wrap l pos s))
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (Attributes l
env, ((pos, ParsedLexemes s, pos)
s, Compose
  ((,) (Attributes l))
  ((,) (pos, ParsedLexemes s, pos))
  (Expression l l (Wrap l pos s) (Wrap l pos s))
-> [Compose
      ((,) (Attributes l))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
-> Expression l l (Wrap l pos s) (Wrap l pos s)
forall λ l (d :: * -> *) (s :: * -> *).
s (Expression l l d d)
-> [s (FieldBinding l l d d)] -> Expression λ l d s
AST.RecordExpression Compose
  ((,) (Attributes l))
  ((,) (pos, ParsedLexemes s, pos))
  (Expression l l (Wrap l pos s) (Wrap l pos s))
conExp ([Compose
    ((,) (Attributes l))
    ((,) (pos, ParsedLexemes s, pos))
    (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
 -> Expression l l (Wrap l pos s) (Wrap l pos s))
-> [Compose
      ((,) (Attributes l))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
-> Expression l l (Wrap l pos s) (Wrap l pos s)
forall a b. (a -> b) -> a -> b
$ [Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
fields [Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
-> [Compose
      ((,) (Attributes l))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
-> [Compose
      ((,) (Attributes l))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
forall a. [a] -> [a] -> [a]
++ [Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
[Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
implicitFields))
      where implicitFields :: [Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
implicitFields = case QualifiedName l
-> UnionWith (Map (QualifiedName l)) (Binding l)
-> Maybe (ValueBinding l)
forall l.
QualifiedName l -> Environment l -> Maybe (ValueBinding l)
Binder.lookupValue QualifiedName l
QualifiedName l
con UnionWith (Map (QualifiedName l)) (Binding l)
inherited of
               Just (Binder.RecordConstructor (UnionWith Map (Name l) (Binding l)
declaredFields)) ->
                  [ (Attributes l,
 ((pos, ParsedLexemes s, pos),
  FieldBinding l l (Wrap l pos s) (Wrap l pos s)))
-> Compose
     ((,) (Attributes l))
     ((,) (pos, ParsedLexemes s, pos))
     (FieldBinding l l (Wrap l pos s) (Wrap l pos s))
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (UnionWith (Map (QualifiedName l)) (Binding l)
-> LocalEnvironment l -> Attributes l
forall a b. a -> b -> Atts a b
Di.Atts UnionWith (Map (QualifiedName l)) (Binding l)
inherited LocalEnvironment l
forall a. Monoid a => a
mempty, ((pos, ParsedLexemes s, pos)
s, QualifiedName l -> FieldBinding l l (Wrap l pos s) (Wrap l pos s)
forall λ l (d :: * -> *) (s :: * -> *).
QualifiedName λ -> FieldBinding λ l d s
AST.PunnedFieldBinding (QualifiedName l -> FieldBinding l l (Wrap l pos s) (Wrap l pos s))
-> QualifiedName l
-> FieldBinding l l (Wrap l pos s) (Wrap l pos s)
forall a b. (a -> b) -> a -> b
$ Name l -> QualifiedName l
qualified Name l
fieldName))
                  | Name l
fieldName <- Map (Name l) (Binding l) -> [Name l]
forall k a. Map k a -> [k]
Map.keys Map (Name l) (Binding l)
declaredFields, Name l
fieldName Name l -> [Name l] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Name l]
explicitFieldNames]
               Just ValueBinding l
_ -> [Char]
-> [Compose
      ((,) (Attributes l))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
forall a. HasCallStack => [Char] -> a
error ([Char]
"Environment misaattributes record constructor " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ QualifiedName l -> [Char]
forall a. Show a => a -> [Char]
show QualifiedName l
QualifiedName l
con)
               Maybe (ValueBinding l)
Nothing -> [Char]
-> [Compose
      ((,) (Attributes l))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
forall a. HasCallStack => [Char] -> a
error ([Char]
"Environment lacks record constructor " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ QualifiedName l -> [Char]
forall a. Show a => a -> [Char]
show QualifiedName l
QualifiedName l
con)
            explicitFieldNames :: [AST.Name l]
            explicitFieldNames :: [Name l]
explicitFieldNames = (Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldBinding l l (Wrap l pos s) (Wrap l pos s))
 -> Name l)
-> [Compose
      ((,) (Attributes l))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
-> [Name l]
forall a b. (a -> b) -> [a] -> [b]
map (FieldBinding l l (Wrap l pos s) (Wrap l pos s) -> Name l
forall {λ} {l} {l} {d :: * -> *} {s :: * -> *}.
(QualifiedName λ ~ QualifiedName l) =>
FieldBinding λ l d s -> Name l
explicitFieldName (FieldBinding l l (Wrap l pos s) (Wrap l pos s) -> Name l)
-> (Compose
      ((,) (Attributes l))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldBinding l l (Wrap l pos s) (Wrap l pos s))
    -> FieldBinding l l (Wrap l pos s) (Wrap l pos s))
-> Compose
     ((,) (Attributes l))
     ((,) (pos, ParsedLexemes s, pos))
     (FieldBinding l l (Wrap l pos s) (Wrap l pos s))
-> Name l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((pos, ParsedLexemes s, pos),
 FieldBinding l l (Wrap l pos s) (Wrap l pos s))
-> FieldBinding l l (Wrap l pos s) (Wrap l pos s)
forall a b. (a, b) -> b
snd (((pos, ParsedLexemes s, pos),
  FieldBinding l l (Wrap l pos s) (Wrap l pos s))
 -> FieldBinding l l (Wrap l pos s) (Wrap l pos s))
-> (Compose
      ((,) (Attributes l))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldBinding l l (Wrap l pos s) (Wrap l pos s))
    -> ((pos, ParsedLexemes s, pos),
        FieldBinding l l (Wrap l pos s) (Wrap l pos s)))
-> Compose
     ((,) (Attributes l))
     ((,) (pos, ParsedLexemes s, pos))
     (FieldBinding l l (Wrap l pos s) (Wrap l pos s))
-> FieldBinding l l (Wrap l pos s) (Wrap l pos s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Attributes l,
 ((pos, ParsedLexemes s, pos),
  FieldBinding l l (Wrap l pos s) (Wrap l pos s)))
-> ((pos, ParsedLexemes s, pos),
    FieldBinding l l (Wrap l pos s) (Wrap l pos s))
forall a b. (a, b) -> b
snd ((Attributes l,
  ((pos, ParsedLexemes s, pos),
   FieldBinding l l (Wrap l pos s) (Wrap l pos s)))
 -> ((pos, ParsedLexemes s, pos),
     FieldBinding l l (Wrap l pos s) (Wrap l pos s)))
-> (Compose
      ((,) (Attributes l))
      ((,) (pos, ParsedLexemes s, pos))
      (FieldBinding l l (Wrap l pos s) (Wrap l pos s))
    -> (Attributes l,
        ((pos, ParsedLexemes s, pos),
         FieldBinding l l (Wrap l pos s) (Wrap l pos s))))
-> Compose
     ((,) (Attributes l))
     ((,) (pos, ParsedLexemes s, pos))
     (FieldBinding l l (Wrap l pos s) (Wrap l pos s))
-> ((pos, ParsedLexemes s, pos),
    FieldBinding l l (Wrap l pos s) (Wrap l pos s))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compose
  ((,) (Attributes l))
  ((,) (pos, ParsedLexemes s, pos))
  (FieldBinding l l (Wrap l pos s) (Wrap l pos s))
-> (Attributes l,
    ((pos, ParsedLexemes s, pos),
     FieldBinding l l (Wrap l pos s) (Wrap l pos s)))
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose) [Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
[Compose
   ((,) (Attributes l))
   ((,) (pos, ParsedLexemes s, pos))
   (FieldBinding l l (Wrap l pos s) (Wrap l pos s))]
fields
            explicitFieldName :: FieldBinding λ l d s -> Name l
explicitFieldName (AST.FieldBinding QualifiedName λ
name s (Expression l l d d)
_) = QualifiedName l -> Name l
forall l. QualifiedName l -> Name l
Binder.baseName QualifiedName λ
QualifiedName l
name
            explicitFieldName (AST.PunnedFieldBinding QualifiedName λ
name) = QualifiedName l -> Name l
forall l. QualifiedName l -> Name l
Binder.baseName QualifiedName λ
QualifiedName l
name
            qualified :: Name l -> QualifiedName l
qualified Name l
name = Maybe (ModuleName l) -> Name l -> QualifiedName l
forall λ. Maybe (ModuleName λ) -> Name λ -> QualifiedName λ
AST.QualifiedName Maybe (ModuleName l)
modName Name l
name
            conExp :: Compose
  ((,) (Attributes l))
  ((,) (pos, ParsedLexemes s, pos))
  (Expression l l (Wrap l pos s) (Wrap l pos s))
conExp | let (pos
start, ParsedLexemes s
_, pos
_) = (pos, ParsedLexemes s, pos)
s = (Attributes l,
 ((pos, ParsedLexemes s, pos),
  Expression l l (Wrap l pos s) (Wrap l pos s)))
-> Compose
     ((,) (Attributes l))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l l (Wrap l pos s) (Wrap l pos s))
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (Attributes l
env, ((pos
start, ParsedLexemes s
forall a. Monoid a => a
mempty, pos
start), QualifiedName l -> Expression l l (Wrap l pos s) (Wrap l pos s)
forall λ l (d :: * -> *).
Haskell λ =>
QualifiedName λ -> Expression λ l d d
forall l (d :: * -> *). QualifiedName l -> Expression l l d d
Abstract.referenceExpression QualifiedName l
con))
   ReformulationOf
  (On 'RecordWildCards) '[On 'NamedFieldPuns] λ l pos s
_ `translateWrapped` Compose (Attributes l
env, ((pos, ParsedLexemes s, pos)
s, Expression l l (Wrap l pos s) (Wrap l pos s)
p)) = (Attributes l,
 ((pos, ParsedLexemes s, pos),
  Expression l l (Wrap l pos s) (Wrap l pos s)))
-> Compose
     ((,) (Attributes l))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l l (Wrap l pos s) (Wrap l pos s))
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (Attributes l
env, ((pos, ParsedLexemes s, pos)
s, Expression l l (Wrap l pos s) (Wrap l pos s)
p))

-- NPlusKPattern instances

instance (SameWrap 'Extensions.NPlusKPatterns '[ 'Extensions.ViewPatterns ] pos s λ l2,
          Abstract.Haskell l2,
          Abstract.Supports 'Extensions.NPlusKPatterns λ,
          Abstract.Supports 'Extensions.ViewPatterns l2,
          Abstract.FieldPattern l2 ~ AST.FieldPattern l2,
          Abstract.QualifiedName l2 ~ AST.QualifiedName l2,
          Abstract.ModuleName l2 ~ AST.ModuleName l2,
          Abstract.Name l2 ~ AST.Name l2) =>
   WrappedTranslation
      (ReformulationOf (On 'Extensions.NPlusKPatterns) '[On 'Extensions.ViewPatterns] λ l2 pos s)
      AST.Pattern
  where
   translateWrapped :: ReformulationOf (On 'NPlusKPatterns) '[On 'ViewPatterns] λ l2 pos s
-> Wrap
     (ReformulationOf
        (On 'NPlusKPatterns) '[On 'ViewPatterns] λ l2 pos s)
     (Pattern
        (Origin
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] λ l2 pos s))
        (Origin
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] λ l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] λ l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] λ l2 pos s)))
-> Wrap
     (ReformulationOf
        (On 'NPlusKPatterns) '[On 'ViewPatterns] λ l2 pos s)
     (Pattern
        (Target
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] λ l2 pos s))
        (Origin
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] λ l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] λ l2 pos s))
        (Wrap
           (ReformulationOf
              (On 'NPlusKPatterns) '[On 'ViewPatterns] λ l2 pos s)))
translateWrapped
      Reformulation{}
      (Compose (Attributes l2
env, (s :: (pos, ParsedLexemes s, pos)
s@(pos
start, ParsedLexemes s
lexemes, pos
end), AST.NPlusKPattern () Name l2
n Integer
k))) =
      (Attributes l2,
 ((pos, ParsedLexemes s, pos),
  Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (Attributes l2
env,
               ((pos, ParsedLexemes s, pos)
s, If (Elem 'ViewPatterns (ExtensionsSupportedBy l2)) () Void
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
SupportFor 'ViewPatterns λ
-> s (Expression l l d d) -> s (Pattern l l d d) -> Pattern λ l d s
AST.ViewPattern () (Integer
-> Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
justGreaterOrEqual Integer
k) (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
 -> Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a -> b) -> a -> b
$ Compose
  ((,) (Attributes l2))
  ((,) (pos, ParsedLexemes s, pos))
  (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> [Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (Type l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
-> [Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
-> Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
s (Constructor l l d d)
-> [s (Type l l d d)] -> [s (Pattern l l d d)] -> Pattern λ l d s
AST.ConstructorPattern Compose
  ((,) (Attributes l2))
  ((,) (pos, ParsedLexemes s, pos))
  (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
Wrap l2 pos s (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
just [] [Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
 -> Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a -> b) -> a -> b
$ Name l2 -> Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *). Name λ -> Pattern λ l d s
AST.VariablePattern Name l2
n])))
      where justGreaterOrEqual :: Integer
-> Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
justGreaterOrEqual Integer
k =
               Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap
               (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
 -> Wrap
      l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a -> b) -> a -> b
$ [Compose
   ((,) (Attributes l2))
   ((,) (pos, ParsedLexemes s, pos))
   (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))]
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
[s (Pattern l l d d)]
-> s (Expression l l d d) -> Expression λ l d s
AST.LambdaExpression [Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
 -> Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a -> b) -> a -> b
$ Name l2 -> Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *). Name λ -> Pattern λ l d s
AST.VariablePattern Name l2
n]
               (Compose
   ((,) (Attributes l2))
   ((,) (pos, ParsedLexemes s, pos))
   (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
 -> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall a b. (a -> b) -> a -> b
$ Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
 -> Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a -> b) -> a -> b
$ Compose
  ((,) (Attributes l2))
  ((,) (pos, ParsedLexemes s, pos))
  (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
s (Expression l l d d)
-> s (Expression l l d d)
-> s (Expression l l d d)
-> Expression λ l d s
AST.ConditionalExpression
                    (Text
-> Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
nOpK Text
">=")
                    (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
 -> Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a -> b) -> a -> b
$ Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap (Compose
  ((,) (Attributes l2))
  ((,) (pos, ParsedLexemes s, pos))
  (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
s (Constructor l l d d) -> Expression λ l d s
AST.ConstructorExpression Compose
  ((,) (Attributes l2))
  ((,) (pos, ParsedLexemes s, pos))
  (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
Wrap l2 pos s (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
just) Compose
  ((,) (Attributes l2))
  ((,) (pos, ParsedLexemes s, pos))
  (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
s (Expression l l d d)
-> s (Expression l l d d) -> Expression λ l d s
`AST.ApplyExpression` Text
-> Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
nOpK Text
"-")
                    (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
 -> Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a -> b) -> a -> b
$ Compose
  ((,) (Attributes l2))
  ((,) (pos, ParsedLexemes s, pos))
  (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
s (Constructor l l d d) -> Expression λ l d s
AST.ConstructorExpression (Compose
   ((,) (Attributes l2))
   ((,) (pos, ParsedLexemes s, pos))
   (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
 -> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall a b. (a -> b) -> a -> b
$
                     Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
 -> Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a -> b) -> a -> b
$ QualifiedName l2
-> Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
QualifiedName λ -> Constructor λ l d s
AST.ConstructorReference (QualifiedName l2
 -> Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> QualifiedName l2
-> Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall a b. (a -> b) -> a -> b
$ Name l2 -> QualifiedName l2
qualifiedWithPrelude (Name l2 -> QualifiedName l2) -> Name l2 -> QualifiedName l2
forall a b. (a -> b) -> a -> b
$ Text -> Name l2
forall λ. Text -> Name λ
AST.Name Text
"Nothing")
            nOpK :: Text
-> Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
nOpK Text
op =
               Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
 -> Wrap
      l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a -> b) -> a -> b
$
               Compose
  ((,) (Attributes l2))
  ((,) (pos, ParsedLexemes s, pos))
  (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
s (Expression l l d d)
-> s (Expression l l d d)
-> s (Expression l l d d)
-> Expression λ l d s
AST.InfixExpression Compose
  ((,) (Attributes l2))
  ((,) (pos, ParsedLexemes s, pos))
  (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
nExp (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
 -> Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a -> b) -> a -> b
$ QualifiedName l2
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
QualifiedName λ -> Expression λ l d s
AST.ReferenceExpression (QualifiedName l2
 -> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> QualifiedName l2
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall a b. (a -> b) -> a -> b
$ Name l2 -> QualifiedName l2
qualifiedWithPrelude (Name l2 -> QualifiedName l2) -> Name l2 -> QualifiedName l2
forall a b. (a -> b) -> a -> b
$ Text -> Name l2
forall λ. Text -> Name λ
AST.Name Text
op) Compose
  ((,) (Attributes l2))
  ((,) (pos, ParsedLexemes s, pos))
  (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
kExp
            nExp :: Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
nExp = Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
 -> Wrap
      l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a -> b) -> a -> b
$ QualifiedName l2
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
QualifiedName λ -> Expression λ l d s
AST.ReferenceExpression (QualifiedName l2
 -> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> QualifiedName l2
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall a b. (a -> b) -> a -> b
$ Name l2 -> QualifiedName l2
forall l. Haskell l => Name l -> QualifiedName l
Binder.unqualifiedName Name l2
n
            kExp :: Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
kExp = Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
 -> Wrap
      l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Wrap l2 pos s (Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a -> b) -> a -> b
$ Compose
  ((,) (Attributes l2))
  ((,) (pos, ParsedLexemes s, pos))
  (Value l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
s (Value l l d d) -> Expression λ l d s
AST.LiteralExpression (Compose
   ((,) (Attributes l2))
   ((,) (pos, ParsedLexemes s, pos))
   (Value l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
 -> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Value l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> Expression l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall a b. (a -> b) -> a -> b
$ Value l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Value l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap (Value l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
 -> Compose
      ((,) (Attributes l2))
      ((,) (pos, ParsedLexemes s, pos))
      (Value l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Value l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Value l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a -> b) -> a -> b
$ Integer -> Value l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *). Integer -> Value λ l d s
AST.IntegerLiteral Integer
k
            just :: Wrap l2 pos s (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
just = Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Wrap
     l2 pos s (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall node. node -> Wrap l2 pos s node
rewrap (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
 -> Wrap
      l2 pos s (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
-> Wrap
     l2 pos s (Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall a b. (a -> b) -> a -> b
$ QualifiedName l2
-> Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall λ l (d :: * -> *) (s :: * -> *).
QualifiedName λ -> Constructor λ l d s
AST.ConstructorReference (QualifiedName l2
 -> Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
-> QualifiedName l2
-> Constructor l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
forall a b. (a -> b) -> a -> b
$ Name l2 -> QualifiedName l2
qualifiedWithPrelude (Name l2 -> QualifiedName l2) -> Name l2 -> QualifiedName l2
forall a b. (a -> b) -> a -> b
$ Text -> Name l2
forall λ. Text -> Name λ
AST.Name Text
"Just"
            qualifiedWithPrelude :: Name l2 -> QualifiedName l2
qualifiedWithPrelude = Maybe (ModuleName l2) -> Name l2 -> QualifiedName l2
forall λ. Maybe (ModuleName λ) -> Name λ -> QualifiedName λ
AST.QualifiedName (ModuleName l2 -> Maybe (ModuleName l2)
forall a. a -> Maybe a
Just ModuleName l2
ModuleName l2
forall l. Haskell l => ModuleName l
Binder.preludeName)
            rewrap :: node -> Wrap l2 pos s node
            rewrap :: forall node. node -> Wrap l2 pos s node
rewrap node
node = (Attributes l2, Wrapped pos s node)
-> Compose
     ((,) (Attributes l2)) ((,) (pos, ParsedLexemes s, pos)) node
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (Attributes l2
env, ((pos
start, ParsedLexemes s
forall a. Monoid a => a
mempty, pos
end), node
node))
   translateWrapped Reformulation{} (Compose (Attributes l2
env, ((pos, ParsedLexemes s, pos)
s, Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
p))) = (Attributes l2,
 ((pos, ParsedLexemes s, pos),
  Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)))
-> Compose
     ((,) (Attributes l2))
     ((,) (pos, ParsedLexemes s, pos))
     (Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s))
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (Attributes l2
env, ((pos, ParsedLexemes s, pos)
s, Pattern l2 l2 (Wrap l2 pos s) (Wrap l2 pos s)
p))

-- auxiliary functions

mapImport :: (Abstract.ExtendedHaskell λ2,
              Abstract.ModuleName λ1 ~ AST.ModuleName λ1,
              Abstract.Name λ1 ~ AST.Name λ1) => AST.Import λ1 l d s -> Abstract.Import λ2 l d s
mapImport :: forall λ2 λ1 l (d :: * -> *) (s :: * -> *).
(ExtendedHaskell λ2, ModuleName λ1 ~ ModuleName λ1,
 Name λ1 ~ Name λ1) =>
Import λ1 l d s -> Import λ2 l d s
mapImport (AST.Import Bool
False Bool
qualified Maybe Text
Nothing ModuleName λ1
modName Maybe (ModuleName λ1)
alias Maybe (s (ImportSpecification l l d d))
detail) =
   Bool
-> ModuleName λ2
-> Maybe (ModuleName λ2)
-> Maybe (s (ImportSpecification l l d d))
-> Import λ2 l d s
forall λ (s :: * -> *) l (d :: * -> *).
Haskell λ =>
Bool
-> ModuleName λ
-> Maybe (ModuleName λ)
-> Maybe (s (ImportSpecification l l d d))
-> Import λ l d s
forall (s :: * -> *) l (d :: * -> *).
Bool
-> ModuleName λ2
-> Maybe (ModuleName λ2)
-> Maybe (s (ImportSpecification l l d d))
-> Import λ2 l d s
Abstract.importDeclaration Bool
qualified (ModuleName λ1 -> ModuleName λ2
forall λ2 λ1.
(Haskell λ2, Name λ1 ~ Name λ1) =>
ModuleName λ1 -> ModuleName λ2
mapModuleName ModuleName λ1
ModuleName λ1
modName) (ModuleName λ1 -> ModuleName λ2
forall λ2 λ1.
(Haskell λ2, Name λ1 ~ Name λ1) =>
ModuleName λ1 -> ModuleName λ2
mapModuleName (ModuleName λ1 -> ModuleName λ2)
-> Maybe (ModuleName λ1) -> Maybe (ModuleName λ2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (ModuleName λ1)
Maybe (ModuleName λ1)
alias) Maybe (s (ImportSpecification l l d d))
detail
mapImport (AST.Import Bool
True Bool
qualified Maybe Text
Nothing ModuleName λ1
modName Maybe (ModuleName λ1)
alias Maybe (s (ImportSpecification l l d d))
detail) =
   Bool
-> ModuleName λ2
-> Maybe (ModuleName λ2)
-> Maybe (s (ImportSpecification l l d d))
-> Import λ2 l d s
forall λ (s :: * -> *) l (d :: * -> *).
ExtendedHaskell λ =>
Bool
-> ModuleName λ
-> Maybe (ModuleName λ)
-> Maybe (s (ImportSpecification l l d d))
-> Import λ l d s
forall (s :: * -> *) l (d :: * -> *).
Bool
-> ModuleName λ2
-> Maybe (ModuleName λ2)
-> Maybe (s (ImportSpecification l l d d))
-> Import λ2 l d s
Abstract.safeImportDeclaration Bool
qualified (ModuleName λ1 -> ModuleName λ2
forall λ2 λ1.
(Haskell λ2, Name λ1 ~ Name λ1) =>
ModuleName λ1 -> ModuleName λ2
mapModuleName ModuleName λ1
ModuleName λ1
modName) (ModuleName λ1 -> ModuleName λ2
forall λ2 λ1.
(Haskell λ2, Name λ1 ~ Name λ1) =>
ModuleName λ1 -> ModuleName λ2
mapModuleName (ModuleName λ1 -> ModuleName λ2)
-> Maybe (ModuleName λ1) -> Maybe (ModuleName λ2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (ModuleName λ1)
Maybe (ModuleName λ1)
alias) Maybe (s (ImportSpecification l l d d))
detail
mapImport (AST.Import Bool
False Bool
qualified (Just Text
package) ModuleName λ1
modName Maybe (ModuleName λ1)
alias Maybe (s (ImportSpecification l l d d))
detail) =
   Bool
-> Text
-> ModuleName λ2
-> Maybe (ModuleName λ2)
-> Maybe (s (ImportSpecification l l d d))
-> Import λ2 l d s
forall λ (s :: * -> *) l (d :: * -> *).
ExtendedHaskell λ =>
Bool
-> Text
-> ModuleName λ
-> Maybe (ModuleName λ)
-> Maybe (s (ImportSpecification l l d d))
-> Import λ l d s
forall (s :: * -> *) l (d :: * -> *).
Bool
-> Text
-> ModuleName λ2
-> Maybe (ModuleName λ2)
-> Maybe (s (ImportSpecification l l d d))
-> Import λ2 l d s
Abstract.packageQualifiedImportDeclaration Bool
qualified Text
package (ModuleName λ1 -> ModuleName λ2
forall λ2 λ1.
(Haskell λ2, Name λ1 ~ Name λ1) =>
ModuleName λ1 -> ModuleName λ2
mapModuleName ModuleName λ1
ModuleName λ1
modName) (ModuleName λ1 -> ModuleName λ2
forall λ2 λ1.
(Haskell λ2, Name λ1 ~ Name λ1) =>
ModuleName λ1 -> ModuleName λ2
mapModuleName (ModuleName λ1 -> ModuleName λ2)
-> Maybe (ModuleName λ1) -> Maybe (ModuleName λ2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (ModuleName λ1)
Maybe (ModuleName λ1)
alias) Maybe (s (ImportSpecification l l d d))
detail
mapImport (AST.Import Bool
True Bool
qualified (Just Text
package) ModuleName λ1
modName Maybe (ModuleName λ1)
alias Maybe (s (ImportSpecification l l d d))
detail) =
   Bool
-> Text
-> ModuleName λ2
-> Maybe (ModuleName λ2)
-> Maybe (s (ImportSpecification l l d d))
-> Import λ2 l d s
forall λ (s :: * -> *) l (d :: * -> *).
ExtendedHaskell λ =>
Bool
-> Text
-> ModuleName λ
-> Maybe (ModuleName λ)
-> Maybe (s (ImportSpecification l l d d))
-> Import λ l d s
forall (s :: * -> *) l (d :: * -> *).
Bool
-> Text
-> ModuleName λ2
-> Maybe (ModuleName λ2)
-> Maybe (s (ImportSpecification l l d d))
-> Import λ2 l d s
Abstract.safePackageQualifiedImportDeclaration Bool
qualified Text
package (ModuleName λ1 -> ModuleName λ2
forall λ2 λ1.
(Haskell λ2, Name λ1 ~ Name λ1) =>
ModuleName λ1 -> ModuleName λ2
mapModuleName ModuleName λ1
ModuleName λ1
modName) (ModuleName λ1 -> ModuleName λ2
forall λ2 λ1.
(Haskell λ2, Name λ1 ~ Name λ1) =>
ModuleName λ1 -> ModuleName λ2
mapModuleName (ModuleName λ1 -> ModuleName λ2)
-> Maybe (ModuleName λ1) -> Maybe (ModuleName λ2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (ModuleName λ1)
Maybe (ModuleName λ1)
alias) Maybe (s (ImportSpecification l l d d))
detail

mapFieldBinding :: (Abstract.Haskell λ2,
                    Abstract.ExtendedWith '[ 'Extensions.NamedFieldPuns ] λ2,
                    Abstract.QualifiedName λ1 ~ AST.QualifiedName λ1,
                    Abstract.ModuleName λ1 ~ AST.ModuleName λ1,
                    Abstract.Name λ1 ~ AST.Name λ1) => AST.FieldBinding λ1 l d s -> Abstract.FieldBinding λ2 l d s
mapFieldBinding :: forall λ2 λ1 l (d :: * -> *) (s :: * -> *).
(Haskell λ2, ExtendedWith '[ 'NamedFieldPuns] λ2,
 QualifiedName λ1 ~ QualifiedName λ1, ModuleName λ1 ~ ModuleName λ1,
 Name λ1 ~ Name λ1) =>
FieldBinding λ1 l d s -> FieldBinding λ2 l d s
mapFieldBinding (AST.FieldBinding QualifiedName λ1
name s (Expression l l d d)
value) = QualifiedName λ2 -> s (Expression l l d d) -> FieldBinding λ2 l d s
forall λ (s :: * -> *) l (d :: * -> *).
Haskell λ =>
QualifiedName λ -> s (Expression l l d d) -> FieldBinding λ l d s
forall (s :: * -> *) l (d :: * -> *).
QualifiedName λ2 -> s (Expression l l d d) -> FieldBinding λ2 l d s
Abstract.fieldBinding (QualifiedName λ1 -> QualifiedName λ2
forall λ2 λ1.
(Haskell λ2, ModuleName λ1 ~ ModuleName λ1, Name λ1 ~ Name λ1) =>
QualifiedName λ1 -> QualifiedName λ2
mapQualifiedName QualifiedName λ1
QualifiedName λ1
name) s (Expression l l d d)
value
mapFieldBinding (AST.PunnedFieldBinding QualifiedName λ1
name) = Construct '[ 'NamedFieldPuns] λ2 l d s
-> QualifiedName λ2 -> FieldBinding λ2 l d s
forall λ l (d :: * -> *) (s :: * -> *).
Construct '[ 'NamedFieldPuns] λ l d s
-> QualifiedName λ -> FieldBinding λ l d s
Abstract.punnedFieldBinding' Construct '[ 'NamedFieldPuns] λ2 l d s
forall (es :: [Extension]) λ l (d :: * -> *) (s :: * -> *).
ExtendedWith es λ =>
Construct es λ l d s
forall l (d :: * -> *) (s :: * -> *).
Construct '[ 'NamedFieldPuns] λ2 l d s
Abstract.build (QualifiedName λ1 -> QualifiedName λ2
forall λ2 λ1.
(Haskell λ2, ModuleName λ1 ~ ModuleName λ1, Name λ1 ~ Name λ1) =>
QualifiedName λ1 -> QualifiedName λ2
mapQualifiedName QualifiedName λ1
QualifiedName λ1
name)

mapQualifiedName :: (Abstract.Haskell λ2,
                     Abstract.ModuleName λ1 ~ AST.ModuleName λ1,
                     Abstract.Name λ1 ~ AST.Name λ1)
                 => AST.QualifiedName λ1 -> Abstract.QualifiedName λ2
mapQualifiedName :: forall λ2 λ1.
(Haskell λ2, ModuleName λ1 ~ ModuleName λ1, Name λ1 ~ Name λ1) =>
QualifiedName λ1 -> QualifiedName λ2
mapQualifiedName (AST.QualifiedName Maybe (ModuleName λ1)
modName Name λ1
localName) =
   Maybe (ModuleName λ2) -> Name λ2 -> QualifiedName λ2
forall λ.
Haskell λ =>
Maybe (ModuleName λ) -> Name λ -> QualifiedName λ
Abstract.qualifiedName (ModuleName λ1 -> ModuleName λ2
forall λ2 λ1.
(Haskell λ2, Name λ1 ~ Name λ1) =>
ModuleName λ1 -> ModuleName λ2
mapModuleName (ModuleName λ1 -> ModuleName λ2)
-> Maybe (ModuleName λ1) -> Maybe (ModuleName λ2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (ModuleName λ1)
modName) (Name λ1 -> Name λ2
forall λ2 λ1. Haskell λ2 => Name λ1 -> Name λ2
mapName Name λ1
localName)

mapModuleName :: (Abstract.Haskell λ2, Abstract.Name λ1 ~ AST.Name λ1) => AST.ModuleName λ1 -> Abstract.ModuleName λ2
mapModuleName :: forall λ2 λ1.
(Haskell λ2, Name λ1 ~ Name λ1) =>
ModuleName λ1 -> ModuleName λ2
mapModuleName (AST.ModuleName NonEmpty (Name λ1)
parts) = NonEmpty (Name λ2) -> ModuleName λ2
forall λ. Haskell λ => NonEmpty (Name λ) -> ModuleName λ
Abstract.moduleName (Name λ1 -> Name λ2
forall λ2 λ1. Haskell λ2 => Name λ1 -> Name λ2
mapName (Name λ1 -> Name λ2) -> NonEmpty (Name λ1) -> NonEmpty (Name λ2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty (Name λ1)
parts)

mapName :: Abstract.Haskell λ2 => AST.Name λ1 -> Abstract.Name λ2
mapName :: forall λ2 λ1. Haskell λ2 => Name λ1 -> Name λ2
mapName (AST.Name Text
name) = Text -> Name λ2
forall λ. Haskell λ => Text -> Name λ
Abstract.name Text
name