{-# OPTIONS_HADDOCK hide #-}

{-# LANGUAGE CPP                    #-}
{-# LANGUAGE PartialTypeSignatures  #-}
{-# LANGUAGE TemplateHaskell        #-}
{-# LANGUAGE UndecidableInstances   #-}

#ifdef ONLY_ONE_LANGUAGE
module Cubix.Language.Python.Parametric.Common.Trans () where
#else
module Cubix.Language.Python.Parametric.Common.Trans
  (
    translate
  , untranslate
  ) where

import Data.Default ( Default(..) )
import Data.List( (\\) )
import Language.Haskell.TH.Syntax ( Type(ConT), Exp(VarE) )

import Data.Comp.Multi ( project, stripA, pattern (::&::), inject, unTerm, caseCxt, caseCxt', HFunctor(..), All, Sum, (:-<:), (:&:)(..) )

import Cubix.Language.Python.Parametric.Common.Types
import qualified Cubix.Language.Python.Parametric.Full as F
import Cubix.Language.Parametric.Derive
import Cubix.Language.Parametric.InjF
import Cubix.Language.Parametric.Syntax

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


------------------------------------------------------------------------------------
---------------- Forward translation: Modularized syntax to IPS  -------------------
------------------------------------------------------------------------------------

--------------------------------
------------- Top-level translate
--------------------------------

------ Top-level definition

translate :: (Default a) => F.PythonTermAnn a l -> MPythonTermAnn a l
translate :: forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate = (:&:) (Sum PythonSig) a (PythonTermAnn a) l -> MPythonTermAnn a l
forall a l.
Default a =>
(:&:) (Sum PythonSig) a (PythonTermAnn a) l -> MPythonTermAnn a l
forall (f :: Fragment) a l.
(Trans f, Default a) =>
(:&:) f a (PythonTermAnn a) l -> MPythonTermAnn a l
trans ((:&:) (Sum PythonSig) a (PythonTermAnn a) l -> MPythonTermAnn a l)
-> (PythonTermAnn a l
    -> (:&:) (Sum PythonSig) a (PythonTermAnn a) l)
-> PythonTermAnn a l
-> MPythonTermAnn a l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PythonTermAnn a l -> (:&:) (Sum PythonSig) a (PythonTermAnn a) l
forall (f :: Fragment) t. HFix f t -> f (HFix f) t
unTerm

translate' :: (InjF MPythonSig l l', Default a) => F.PythonTermAnn a l -> MPythonTermAnn a l'
translate' :: forall l l' a.
(InjF MPythonSig l l', Default a) =>
PythonTermAnn a l -> MPythonTermAnn a l'
translate' = AnnTerm a MPythonSig l -> AnnTerm a MPythonSig l'
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig l -> AnnTerm a MPythonSig l')
-> (PythonTermAnn a l -> AnnTerm a MPythonSig l)
-> PythonTermAnn a l
-> AnnTerm a MPythonSig l'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PythonTermAnn a l -> AnnTerm a MPythonSig l
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate

------ Class

class Trans f where
  trans :: (Default a) => (f :&: a) (F.PythonTermAnn a) l -> MPythonTermAnn a l

------ Default and standard cases

instance {-# OVERLAPPING #-} (All Trans fs) => Trans (Sum fs) where
  trans :: forall a l.
Default a =>
(:&:) (Sum fs) a (PythonTermAnn a) l -> MPythonTermAnn a l
trans = forall (cxt :: Fragment -> Constraint) (fs :: [Fragment]) a
       (e :: * -> *) l t.
All cxt fs =>
(forall (f :: Fragment). cxt f => (:&:) f a e l -> t)
-> (:&:) (Sum fs) a e l -> t
caseCxt' @Trans (:&:) f a (PythonTermAnn a) l -> MPythonTermAnn a l
forall a l.
Default a =>
(:&:) f a (PythonTermAnn a) l -> MPythonTermAnn a l
forall (f :: Fragment).
Trans f =>
(:&:) f a (PythonTermAnn a) l -> MPythonTermAnn a l
forall (f :: Fragment) a l.
(Trans f, Default a) =>
(:&:) f a (PythonTermAnn a) l -> MPythonTermAnn a l
trans

transDefault :: (HFunctor f, f :-<: MPythonSig, f :-<: F.PythonSig, Default a) => (f :&: a) (F.PythonTermAnn a) l -> MPythonTermAnn a l
transDefault :: forall (f :: Fragment) a l.
(HFunctor f, f :-<: MPythonSig, f :-<: PythonSig, Default a) =>
(:&:) f a (PythonTermAnn a) l -> MPythonTermAnn a l
transDefault = (:&:) f a (Cxt NoHole (Sum MPythonSig :&: a) (K ())) l
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) l
(:&:) f a (Cxt NoHole (Sum MPythonSig :&: a) (K ()))
:-> Cxt NoHole (Sum MPythonSig :&: a) (K ())
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
g (Cxt h f a) :-> Cxt h f a
inject ((:&:) f a (Cxt NoHole (Sum MPythonSig :&: a) (K ())) l
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) l)
-> ((:&:) f a (PythonTermAnn a) l
    -> (:&:) f a (Cxt NoHole (Sum MPythonSig :&: a) (K ())) l)
-> (:&:) f a (PythonTermAnn a) l
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PythonTermAnn a :-> Cxt NoHole (Sum MPythonSig :&: a) (K ()))
-> (:&:) f a (PythonTermAnn a)
   :-> (:&:) f a (Cxt NoHole (Sum MPythonSig :&: a) (K ()))
forall (f :: * -> *) (g :: * -> *).
(f :-> g) -> (:&:) f a f :-> (:&:) f a g
forall (h :: Fragment) (f :: * -> *) (g :: * -> *).
HFunctor h =>
(f :-> g) -> h f :-> h g
hfmap PythonTermAnn a i -> MPythonTermAnn a i
PythonTermAnn a :-> Cxt NoHole (Sum MPythonSig :&: a) (K ())
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate

instance {-# OVERLAPPABLE #-} (HFunctor f, f :-<: MPythonSig, f :-<: F.PythonSig) => Trans f where
  trans :: forall a l.
Default a =>
(:&:) f a (PythonTermAnn a) l -> MPythonTermAnn a l
trans = (:&:) f a (PythonTermAnn a) l -> MPythonTermAnn a l
forall (f :: Fragment) a l.
(HFunctor f, f :-<: MPythonSig, f :-<: PythonSig, Default a) =>
(:&:) f a (PythonTermAnn a) l -> MPythonTermAnn a l
transDefault


---------------------------------
-------------- Per-fragment Instances
---------------------------------


-------- Identifiers

transIdent :: (Default a) => F.PythonTermAnn a F.IdentL -> MPythonTermAnn a IdentL
transIdent :: forall a.
Default a =>
PythonTermAnn a IdentL -> MPythonTermAnn a IdentL
transIdent (F.Ident String
s ::&:: a
a) = String -> Ident (Cxt NoHole (Sum MPythonSig :&: a) (K ())) IdentL
forall (a :: * -> *). String -> Ident a IdentL
Ident String
s Ident (Cxt NoHole (Sum MPythonSig :&: a) (K ())) IdentL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a

instance Trans F.Ident where
  trans :: forall a l.
Default a =>
(:&:) Ident a (PythonTermAnn a) l -> MPythonTermAnn a l
trans (F.Ident String
s :&: a
a) = (:&:) Ident a (AnnTerm a MPythonSig) IdentL
-> AnnTerm a MPythonSig l
forall (fs :: [Fragment]) l l' (f :: Fragment) a.
(InjF fs l l', f :-<: fs, All HTraversable fs, All HFoldable fs,
 Default a) =>
(:&:) f a (AnnTerm a fs) l -> AnnTerm a fs l'
injectFAnnDef (String -> Ident (AnnTerm a MPythonSig) IdentL
forall (a :: * -> *). String -> Ident a IdentL
Ident String
s Ident (AnnTerm a MPythonSig) IdentL
-> a -> (:&:) Ident a (AnnTerm a MPythonSig) IdentL
forall (f :: Fragment) a (g :: * -> *) e.
f g e -> a -> (:&:) f a g e
:&: a
a)

-------- Functions

transArgs :: (Default a) => F.PythonTermAnn a [F.ArgumentL] -> MPythonTermAnn a [FunctionArgumentL]
transArgs :: forall a.
Default a =>
PythonTermAnn a [ArgumentL] -> MPythonTermAnn a [FunctionArgumentL]
transArgs = (Cxt NoHole (Sum PythonSig :&: a) (K ()) ArgumentL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionArgumentL)
-> Cxt NoHole (Sum PythonSig :&: a) (K ()) [ArgumentL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [FunctionArgumentL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF Cxt NoHole (Sum PythonSig :&: a) (K ()) ArgumentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionArgumentL
forall a.
Default a =>
PythonTermAnn a ArgumentL -> MPythonTermAnn a FunctionArgumentL
transArg
  where
    transArg :: (Default a) => F.PythonTermAnn a F.ArgumentL -> MPythonTermAnn a FunctionArgumentL
    transArg :: forall a.
Default a =>
PythonTermAnn a ArgumentL -> MPythonTermAnn a FunctionArgumentL
transArg (F.ArgExpr           Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e ::&:: a
a) = Cxt NoHole (Sum MPythonSig :&: a) (K ()) PositionalArgExpL
-> PositionalArgument
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionArgumentL
forall (a :: * -> *).
a PositionalArgExpL -> PositionalArgument a FunctionArgumentL
PositionalArgument (AnnTerm a MPythonSig ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PositionalArgExpL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig ExprL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PositionalArgExpL)
-> AnnTerm a MPythonSig ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PositionalArgExpL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> AnnTerm a MPythonSig ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e) PositionalArgument
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionArgumentL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionArgumentL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
    transArg (F.ArgVarArgsPos     Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e ::&:: a
a) = AnnTerm a MPythonSig ExprL
-> PythonArg
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionArgumentL
forall (e :: * -> *). e ExprL -> PythonArg e FunctionArgumentL
PythonArgSplat (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> AnnTerm a MPythonSig ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e) PythonArg
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionArgumentL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionArgumentL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
    transArg (F.ArgVarArgsKeyword Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e ::&:: a
a) = AnnTerm a MPythonSig ExprL
-> PythonArg
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionArgumentL
forall (e :: * -> *). e ExprL -> PythonArg e FunctionArgumentL
PythonArgKWSplat (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> AnnTerm a MPythonSig ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e) PythonArg
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionArgumentL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionArgumentL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
    transArg (F.ArgKeyword      Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
n Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e ::&:: a
a) = Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
-> AnnTerm a MPythonSig ExprL
-> PythonArg
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionArgumentL
forall (e :: * -> *).
e IdentL -> e ExprL -> PythonArg e FunctionArgumentL
PythonArgKeyword (Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
forall a.
Default a =>
PythonTermAnn a IdentL -> MPythonTermAnn a IdentL
transIdent Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
n) (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> AnnTerm a MPythonSig ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e) PythonArg
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionArgumentL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionArgumentL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a

isCompOp :: (Default a) => F.PythonTermAnn a F.OpL -> Bool
isCompOp :: forall a. Default a => PythonTermAnn a OpL -> Bool
isCompOp (Op (Cxt NoHole (Sum PythonSig :&: a) (K ())) OpL
F.LessThan          ::&:: a
_) = Bool
True
isCompOp (Op (Cxt NoHole (Sum PythonSig :&: a) (K ())) OpL
F.LessThanEquals    ::&:: a
_) = Bool
True
isCompOp (Op (Cxt NoHole (Sum PythonSig :&: a) (K ())) OpL
F.GreaterThan       ::&:: a
_) = Bool
True
isCompOp (Op (Cxt NoHole (Sum PythonSig :&: a) (K ())) OpL
F.GreaterThanEquals ::&:: a
_) = Bool
True
isCompOp (Op (Cxt NoHole (Sum PythonSig :&: a) (K ())) OpL
F.Equality          ::&:: a
_) = Bool
True
isCompOp (Op (Cxt NoHole (Sum PythonSig :&: a) (K ())) OpL
F.NotEquals         ::&:: a
_) = Bool
True
isCompOp (Op (Cxt NoHole (Sum PythonSig :&: a) (K ())) OpL
F.In                ::&:: a
_) = Bool
True
isCompOp (Op (Cxt NoHole (Sum PythonSig :&: a) (K ())) OpL
F.Is                ::&:: a
_) = Bool
True
isCompOp (Op (Cxt NoHole (Sum PythonSig :&: a) (K ())) OpL
F.IsNot             ::&:: a
_) = Bool
True
isCompOp (Op (Cxt NoHole (Sum PythonSig :&: a) (K ())) OpL
F.NotIn             ::&:: a
_) = Bool
True
isCompOp Cxt NoHole (Sum PythonSig :&: a) (K ()) OpL
_                             = Bool
False

-- The parser groups "a > b > c" as "(a > b) > c". However, PyComp needs the
-- left element to be an expression, and not another comparison. This function
-- flips the grouping to "a > (b > c)".
-- NOTE 2023.11.13: I'm just going to let this translation drop the annotations on the comparisons rather than trying to figure this out.
--                  Note that, in the present case where the annotations are actually source spans, the reassociation will mess with things.
reassociateComp :: (Default a) => F.PythonTermAnn a F.OpL -> F.PythonTermAnn a F.ExprL -> F.PythonTermAnn a F.ExprL -> a -> MPythonTermAnn a F.ExprL
reassociateComp :: forall a.
Default a =>
PythonTermAnn a OpL
-> PythonTermAnn a ExprL
-> PythonTermAnn a ExprL
-> a
-> MPythonTermAnn a ExprL
reassociateComp PythonTermAnn a OpL
op PythonTermAnn a ExprL
l PythonTermAnn a ExprL
r a
_ = AnnTerm a MPythonSig PyCompL -> AnnTerm a MPythonSig ExprL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig PyCompL -> AnnTerm a MPythonSig ExprL)
-> AnnTerm a MPythonSig PyCompL -> AnnTerm a MPythonSig ExprL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig :&: a) (K ()) OpL
-> AnnTerm a MPythonSig ExprL
-> AnnTerm a MPythonSig ExprL
-> AnnTerm a MPythonSig PyCompL
forall {fs :: [Fragment]} {x}.
(KnownNat (Position PyCompIsExpr fs),
 KnownNat (Position PyComp fs), Default x, All HFunctor fs,
 All HTraversable fs, All HFoldable fs) =>
Cxt NoHole (Sum fs :&: x) (K ()) OpL
-> Cxt NoHole (Sum fs :&: x) (K ()) ExprL
-> Cxt NoHole (Sum fs :&: x) (K ()) ExprL
-> Cxt NoHole (Sum fs :&: x) (K ()) PyCompL
reassociate (PythonTermAnn a OpL -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) OpL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate PythonTermAnn a OpL
op) (PythonTermAnn a ExprL -> AnnTerm a MPythonSig ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate PythonTermAnn a ExprL
l) (PythonTermAnn a ExprL -> AnnTerm a MPythonSig ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate PythonTermAnn a ExprL
r)
  where
    reassociate :: Cxt NoHole (Sum fs :&: x) (K ()) OpL
-> Cxt NoHole (Sum fs :&: x) (K ()) ExprL
-> Cxt NoHole (Sum fs :&: x) (K ()) ExprL
-> Cxt NoHole (Sum fs :&: x) (K ()) PyCompL
reassociate Cxt NoHole (Sum fs :&: x) (K ()) OpL
outer_op (PyCompIsExpr (PyChainComp Cxt NoHole (Sum fs :&: x) (K ()) OpL
inner_op Cxt NoHole (Sum fs :&: x) (K ()) ExprL
left Cxt NoHole (Sum fs :&: x) (K ()) PyCompL
inner_right ::&:: x
_) ::&:: x
_) Cxt NoHole (Sum fs :&: x) (K ()) ExprL
outer_right =
      Cxt NoHole (Sum fs :&: x) (K ()) OpL
-> Cxt NoHole (Sum fs :&: x) (K ()) ExprL
-> Cxt NoHole (Sum fs :&: x) (K ()) PyCompL
-> Cxt NoHole (Sum fs :&: x) (K ()) PyCompL
forall {f :: Fragment} {h} {a :: * -> *}.
(PyComp :<: f) =>
Cxt h f a OpL
-> Cxt h f a ExprL -> Cxt h f a PyCompL -> Cxt h f a PyCompL
jPyChainComp Cxt NoHole (Sum fs :&: x) (K ()) OpL
inner_op Cxt NoHole (Sum fs :&: x) (K ()) ExprL
left (Cxt NoHole (Sum fs :&: x) (K ()) OpL
-> Cxt NoHole (Sum fs :&: x) (K ()) ExprL
-> Cxt NoHole (Sum fs :&: x) (K ()) ExprL
-> Cxt NoHole (Sum fs :&: x) (K ()) PyCompL
reassociate Cxt NoHole (Sum fs :&: x) (K ()) OpL
outer_op (Cxt NoHole (Sum fs :&: x) (K ()) PyCompL
-> Cxt NoHole (Sum fs :&: x) (K ()) ExprL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef Cxt NoHole (Sum fs :&: x) (K ()) PyCompL
inner_right) Cxt NoHole (Sum fs :&: x) (K ()) ExprL
outer_right)
    reassociate Cxt NoHole (Sum fs :&: x) (K ()) OpL
outer_op (PyCompIsExpr (PyBaseComp Cxt NoHole (Sum fs :&: x) (K ()) OpL
inner_op Cxt NoHole (Sum fs :&: x) (K ()) ExprL
left Cxt NoHole (Sum fs :&: x) (K ()) ExprL
inner_right ::&:: x
_) ::&:: x
_) Cxt NoHole (Sum fs :&: x) (K ()) ExprL
outer_right =
      Cxt NoHole (Sum fs :&: x) (K ()) OpL
-> Cxt NoHole (Sum fs :&: x) (K ()) ExprL
-> Cxt NoHole (Sum fs :&: x) (K ()) PyCompL
-> Cxt NoHole (Sum fs :&: x) (K ()) PyCompL
forall {f :: Fragment} {h} {a :: * -> *}.
(PyComp :<: f) =>
Cxt h f a OpL
-> Cxt h f a ExprL -> Cxt h f a PyCompL -> Cxt h f a PyCompL
jPyChainComp Cxt NoHole (Sum fs :&: x) (K ()) OpL
inner_op Cxt NoHole (Sum fs :&: x) (K ()) ExprL
left (Cxt NoHole (Sum fs :&: x) (K ()) OpL
-> Cxt NoHole (Sum fs :&: x) (K ()) ExprL
-> Cxt NoHole (Sum fs :&: x) (K ()) ExprL
-> Cxt NoHole (Sum fs :&: x) (K ()) PyCompL
forall {f :: Fragment} {h} {a :: * -> *}.
(PyComp :<: f) =>
Cxt h f a OpL
-> Cxt h f a ExprL -> Cxt h f a ExprL -> Cxt h f a PyCompL
jPyBaseComp Cxt NoHole (Sum fs :&: x) (K ()) OpL
outer_op Cxt NoHole (Sum fs :&: x) (K ()) ExprL
inner_right Cxt NoHole (Sum fs :&: x) (K ()) ExprL
outer_right)
    reassociate Cxt NoHole (Sum fs :&: x) (K ()) OpL
op Cxt NoHole (Sum fs :&: x) (K ()) ExprL
left Cxt NoHole (Sum fs :&: x) (K ()) ExprL
right = Cxt NoHole (Sum fs :&: x) (K ()) OpL
-> Cxt NoHole (Sum fs :&: x) (K ()) ExprL
-> Cxt NoHole (Sum fs :&: x) (K ()) ExprL
-> Cxt NoHole (Sum fs :&: x) (K ()) PyCompL
forall {f :: Fragment} {h} {a :: * -> *}.
(PyComp :<: f) =>
Cxt h f a OpL
-> Cxt h f a ExprL -> Cxt h f a ExprL -> Cxt h f a PyCompL
jPyBaseComp Cxt NoHole (Sum fs :&: x) (K ()) OpL
op Cxt NoHole (Sum fs :&: x) (K ()) ExprL
left Cxt NoHole (Sum fs :&: x) (K ()) ExprL
right

-- FIXME: This can erroneously capture a module/class as a receiver
-- FIXME: I think I intended to translate "f(x)" to use a FunctionIdent for f
instance Trans F.Expr where
  trans :: forall a l.
Default a =>
(:&:) Expr a (PythonTermAnn a) l -> MPythonTermAnn a l
trans (F.Call PythonTermAnn a ExprL
f PythonTermAnn a [ArgumentL]
args :&: a
a) = AnnTerm a MPythonSig FunctionCallL -> AnnTerm a MPythonSig l
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig FunctionCallL -> AnnTerm a MPythonSig l)
-> AnnTerm a MPythonSig FunctionCallL -> AnnTerm a MPythonSig l
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionCallAttrsL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionExpL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionArgumentsL
-> FunctionCall
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionCallL
forall (e :: * -> *).
e FunctionCallAttrsL
-> e FunctionExpL
-> e FunctionArgumentsL
-> FunctionCall e FunctionCallL
FunctionCall Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionCallAttrsL
forall h (f :: Fragment) (a :: * -> *).
(EmptyFunctionCallAttrs :<: f) =>
Cxt h f a FunctionCallAttrsL
jEmptyFunctionCallAttrs Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionExpL
fun (Cxt NoHole (Sum MPythonSig :&: a) (K ()) [FunctionArgumentL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionArgumentsL
forall {f :: Fragment} {h} {a :: * -> *}.
(FunctionArgumentList :<: f) =>
Cxt h f a [FunctionArgumentL] -> Cxt h f a FunctionArgumentsL
jFunctionArgumentList Cxt NoHole (Sum MPythonSig :&: a) (K ()) [FunctionArgumentL]
args') FunctionCall
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionCallL
-> a -> AnnTerm a MPythonSig FunctionCallL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
    where
      (Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionExpL
fun, Cxt NoHole (Sum MPythonSig :&: a) (K ()) [FunctionArgumentL]
args') = case PythonTermAnn a ExprL
f of
        (F.Dot PythonTermAnn a ExprL
l Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
n ::&:: a
_) -> (Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionExpL
forall {f :: Fragment} {h} {a :: * -> *}.
(FunctionIdent :<: f) =>
Cxt h f a IdentL -> Cxt h f a FunctionExpL
jFunctionIdent (Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
forall a.
Default a =>
PythonTermAnn a IdentL -> MPythonTermAnn a IdentL
transIdent Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
n), Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionArgumentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [FunctionArgumentL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [FunctionArgumentL]
forall (f :: Fragment) l h (a :: * -> *).
(ListF :<: f, Typeable l) =>
Cxt h f a l -> Cxt h f a [l] -> Cxt h f a [l]
jConsF (Cxt NoHole (Sum MPythonSig :&: a) (K ()) ReceiverL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionArgumentL
forall {f :: Fragment} {h} {a :: * -> *}.
(ReceiverArg :<: f) =>
Cxt h f a ReceiverL -> Cxt h f a FunctionArgumentL
jReceiverArg (Cxt NoHole (Sum MPythonSig :&: a) (K ()) ReceiverL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionArgumentL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ReceiverL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionArgumentL
forall a b. (a -> b) -> a -> b
$ AnnTerm a MPythonSig ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ReceiverL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig ExprL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ReceiverL)
-> AnnTerm a MPythonSig ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ReceiverL
forall a b. (a -> b) -> a -> b
$ PythonTermAnn a ExprL -> AnnTerm a MPythonSig ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate PythonTermAnn a ExprL
l) (PythonTermAnn a [ArgumentL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [FunctionArgumentL]
forall a.
Default a =>
PythonTermAnn a [ArgumentL] -> MPythonTermAnn a [FunctionArgumentL]
transArgs PythonTermAnn a [ArgumentL]
args))
        PythonTermAnn a ExprL
_                   -> (AnnTerm a MPythonSig ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionExpL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig ExprL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionExpL)
-> AnnTerm a MPythonSig ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionExpL
forall a b. (a -> b) -> a -> b
$ PythonTermAnn a ExprL -> AnnTerm a MPythonSig ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate PythonTermAnn a ExprL
f, PythonTermAnn a [ArgumentL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [FunctionArgumentL]
forall a.
Default a =>
PythonTermAnn a [ArgumentL] -> MPythonTermAnn a [FunctionArgumentL]
transArgs PythonTermAnn a [ArgumentL]
args)

  trans t :: (:&:) Expr a (PythonTermAnn a) l
t@(F.BinaryOp PythonTermAnn a OpL
op PythonTermAnn a ExprL
l PythonTermAnn a ExprL
r :&: a
a) =
    if PythonTermAnn a OpL -> Bool
forall a. Default a => PythonTermAnn a OpL -> Bool
isCompOp PythonTermAnn a OpL
op
    then PythonTermAnn a OpL
-> PythonTermAnn a ExprL
-> PythonTermAnn a ExprL
-> a
-> AnnTerm a MPythonSig ExprL
forall a.
Default a =>
PythonTermAnn a OpL
-> PythonTermAnn a ExprL
-> PythonTermAnn a ExprL
-> a
-> MPythonTermAnn a ExprL
reassociateComp PythonTermAnn a OpL
op PythonTermAnn a ExprL
l PythonTermAnn a ExprL
r a
a
    else (:&:) Expr a (PythonTermAnn a) l -> AnnTerm a MPythonSig l
forall (f :: Fragment) a l.
(HFunctor f, f :-<: MPythonSig, f :-<: PythonSig, Default a) =>
(:&:) f a (PythonTermAnn a) l -> MPythonTermAnn a l
transDefault (:&:) Expr a (PythonTermAnn a) l
t
  trans (F.CondExpr PythonTermAnn a ExprL
t PythonTermAnn a ExprL
c PythonTermAnn a ExprL
e :&: a
a) = AnnTerm a MPythonSig ExprL -> AnnTerm a MPythonSig l
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig ExprL -> AnnTerm a MPythonSig l)
-> AnnTerm a MPythonSig ExprL -> AnnTerm a MPythonSig l
forall a b. (a -> b) -> a -> b
$ AnnTerm a MPythonSig ExprL
-> AnnTerm a MPythonSig ExprL
-> AnnTerm a MPythonSig ExprL
-> PyCondExpr (Cxt NoHole (Sum MPythonSig :&: a) (K ())) ExprL
forall (e :: * -> *).
e ExprL -> e ExprL -> e ExprL -> PyCondExpr e ExprL
PyCondExpr (PythonTermAnn a ExprL -> AnnTerm a MPythonSig ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate PythonTermAnn a ExprL
c) (PythonTermAnn a ExprL -> AnnTerm a MPythonSig ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate PythonTermAnn a ExprL
t) (PythonTermAnn a ExprL -> AnnTerm a MPythonSig ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate PythonTermAnn a ExprL
e) PyCondExpr (Cxt NoHole (Sum MPythonSig :&: a) (K ())) ExprL
-> a -> AnnTerm a MPythonSig ExprL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
  trans (F.ListComp PythonTermAnn a ComprehensionL
comp  :&: a
a) = AnnTerm a MPythonSig ExprL -> AnnTerm a MPythonSig l
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig ExprL -> AnnTerm a MPythonSig l)
-> AnnTerm a MPythonSig ExprL -> AnnTerm a MPythonSig l
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
-> PyComprehensionExpr
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) ExprL
forall (e :: * -> *).
e PyComprehensionL -> PyComprehensionExpr e ExprL
PyListComprehension (PythonTermAnn a ComprehensionL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
forall a.
Default a =>
PythonTermAnn a ComprehensionL -> MPythonTermAnn a PyComprehensionL
transComprehension PythonTermAnn a ComprehensionL
comp) PyComprehensionExpr
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) ExprL
-> a -> AnnTerm a MPythonSig ExprL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
  trans (F.DictComp PythonTermAnn a ComprehensionL
comp  :&: a
a) = AnnTerm a MPythonSig ExprL -> AnnTerm a MPythonSig l
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig ExprL -> AnnTerm a MPythonSig l)
-> AnnTerm a MPythonSig ExprL -> AnnTerm a MPythonSig l
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
-> PyComprehensionExpr
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) ExprL
forall (e :: * -> *).
e PyComprehensionL -> PyComprehensionExpr e ExprL
PyDictComprehension (PythonTermAnn a ComprehensionL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
forall a.
Default a =>
PythonTermAnn a ComprehensionL -> MPythonTermAnn a PyComprehensionL
transComprehension PythonTermAnn a ComprehensionL
comp) PyComprehensionExpr
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) ExprL
-> a -> AnnTerm a MPythonSig ExprL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
  trans (F.SetComp PythonTermAnn a ComprehensionL
comp   :&: a
a) = AnnTerm a MPythonSig ExprL -> AnnTerm a MPythonSig l
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig ExprL -> AnnTerm a MPythonSig l)
-> AnnTerm a MPythonSig ExprL -> AnnTerm a MPythonSig l
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
-> PyComprehensionExpr
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) ExprL
forall (e :: * -> *).
e PyComprehensionL -> PyComprehensionExpr e ExprL
PySetComprehension (PythonTermAnn a ComprehensionL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
forall a.
Default a =>
PythonTermAnn a ComprehensionL -> MPythonTermAnn a PyComprehensionL
transComprehension PythonTermAnn a ComprehensionL
comp) PyComprehensionExpr
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) ExprL
-> a -> AnnTerm a MPythonSig ExprL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
  trans (:&:) Expr a (PythonTermAnn a) l
x                        = (:&:) Expr a (PythonTermAnn a) l -> AnnTerm a MPythonSig l
forall (f :: Fragment) a l.
(HFunctor f, f :-<: MPythonSig, f :-<: PythonSig, Default a) =>
(:&:) f a (PythonTermAnn a) l -> MPythonTermAnn a l
transDefault (:&:) Expr a (PythonTermAnn a) l
x

transComprehension :: (Default a) => F.PythonTermAnn a F.ComprehensionL -> MPythonTermAnn a PyComprehensionL
transComprehension :: forall a.
Default a =>
PythonTermAnn a ComprehensionL -> MPythonTermAnn a PyComprehensionL
transComprehension (F.Comprehension Cxt NoHole (Sum PythonSig :&: a) (K ()) ComprehensionExprL
cexpr Cxt NoHole (Sum PythonSig :&: a) (K ()) CompForL
cfor ::&:: a
a) = Cxt NoHole (Sum PythonSig :&: a) (K ()) ComprehensionExprL
-> Cxt NoHole (Sum PythonSig :&: a) (K ()) CompForL
-> a
-> MPythonTermAnn a PyComprehensionL
forall a.
Default a =>
PythonTermAnn a ComprehensionExprL
-> PythonTermAnn a CompForL
-> a
-> MPythonTermAnn a PyComprehensionL
transComprehensionFor Cxt NoHole (Sum PythonSig :&: a) (K ()) ComprehensionExprL
cexpr Cxt NoHole (Sum PythonSig :&: a) (K ()) CompForL
cfor a
a

-- NOTE 2023.11.13: Totally unsure I got the annotation threading correct. What is the comp_if_iter case in language-python anyhow?
transComprehensionIf :: (Default a) => F.PythonTermAnn a F.ComprehensionExprL -> F.PythonTermAnn a F.CompIfL -> a -> MPythonTermAnn a PyComprehensionL
transComprehensionIf :: forall a.
Default a =>
PythonTermAnn a ComprehensionExprL
-> PythonTermAnn a CompIfL
-> a
-> MPythonTermAnn a PyComprehensionL
transComprehensionIf PythonTermAnn a ComprehensionExprL
cexp (F.CompIf Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe CompIterL)
mi ::&:: a
_) a
a =
  let comp :: Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
comp = case Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe CompIterL)
-> Maybe (Cxt NoHole (Sum PythonSig :&: a) (K ()) CompIterL)
forall l.
Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe l)
-> Maybe (Cxt NoHole (Sum PythonSig :&: a) (K ()) l)
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe CompIterL)
mi of
        Just (F.IterFor Cxt NoHole (Sum PythonSig :&: a) (K ()) CompForL
i ::&:: a
a') -> PythonTermAnn a ComprehensionExprL
-> Cxt NoHole (Sum PythonSig :&: a) (K ()) CompForL
-> a
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
forall a.
Default a =>
PythonTermAnn a ComprehensionExprL
-> PythonTermAnn a CompForL
-> a
-> MPythonTermAnn a PyComprehensionL
transComprehensionFor PythonTermAnn a ComprehensionExprL
cexp Cxt NoHole (Sum PythonSig :&: a) (K ()) CompForL
i a
a'
        Just (F.IterIf  Cxt NoHole (Sum PythonSig :&: a) (K ()) CompIfL
i ::&:: a
a') -> PythonTermAnn a ComprehensionExprL
-> Cxt NoHole (Sum PythonSig :&: a) (K ()) CompIfL
-> a
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
forall a.
Default a =>
PythonTermAnn a ComprehensionExprL
-> PythonTermAnn a CompIfL
-> a
-> MPythonTermAnn a PyComprehensionL
transComprehensionIf  PythonTermAnn a ComprehensionExprL
cexp Cxt NoHole (Sum PythonSig :&: a) (K ()) CompIfL
i a
a'
        Maybe (Cxt NoHole (Sum PythonSig :&: a) (K ()) CompIterL)
Nothing -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ComprehensionExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
forall {f :: Fragment} {h} {a :: * -> *}.
(PyComprehension :<: f) =>
Cxt h f a ComprehensionExprL -> Cxt h f a PyComprehensionL
jPyComprehensionBody (PythonTermAnn a ComprehensionExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ComprehensionExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate PythonTermAnn a ComprehensionExprL
cexp) -- Very unsure of annotations here
  in Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
-> PyComprehension
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyComprehensionL
forall (e :: * -> *).
e ExprL -> e PyComprehensionL -> PyComprehension e PyComprehensionL
PyComprehensionIf (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e) Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
comp PyComprehension
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyComprehensionL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a

transComprehensionFor :: (Default a) => F.PythonTermAnn a F.ComprehensionExprL -> F.PythonTermAnn a F.CompForL -> a -> MPythonTermAnn a PyComprehensionL
transComprehensionFor :: forall a.
Default a =>
PythonTermAnn a ComprehensionExprL
-> PythonTermAnn a CompForL
-> a
-> MPythonTermAnn a PyComprehensionL
transComprehensionFor PythonTermAnn a ComprehensionExprL
cexp (F.CompFor Bool
b Cxt NoHole (Sum PythonSig :&: a) (K ()) [ExprL]
es Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
v Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe CompIterL)
mi ::&:: a
a) a
a' =
  let comp :: Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
comp = case Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe CompIterL)
-> Maybe (Cxt NoHole (Sum PythonSig :&: a) (K ()) CompIterL)
forall l.
Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe l)
-> Maybe (Cxt NoHole (Sum PythonSig :&: a) (K ()) l)
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe CompIterL)
mi of
        Just (F.IterFor Cxt NoHole (Sum PythonSig :&: a) (K ()) CompForL
i ::&:: a
a'') -> PythonTermAnn a ComprehensionExprL
-> Cxt NoHole (Sum PythonSig :&: a) (K ()) CompForL
-> a
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
forall a.
Default a =>
PythonTermAnn a ComprehensionExprL
-> PythonTermAnn a CompForL
-> a
-> MPythonTermAnn a PyComprehensionL
transComprehensionFor PythonTermAnn a ComprehensionExprL
cexp Cxt NoHole (Sum PythonSig :&: a) (K ()) CompForL
i a
a''
        Just (F.IterIf  Cxt NoHole (Sum PythonSig :&: a) (K ()) CompIfL
i ::&:: a
a'') -> PythonTermAnn a ComprehensionExprL
-> Cxt NoHole (Sum PythonSig :&: a) (K ()) CompIfL
-> a
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
forall a.
Default a =>
PythonTermAnn a ComprehensionExprL
-> PythonTermAnn a CompIfL
-> a
-> MPythonTermAnn a PyComprehensionL
transComprehensionIf  PythonTermAnn a ComprehensionExprL
cexp Cxt NoHole (Sum PythonSig :&: a) (K ()) CompIfL
i a
a''
        Maybe (Cxt NoHole (Sum PythonSig :&: a) (K ()) CompIterL)
Nothing -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ComprehensionExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
forall {f :: Fragment} {h} {a :: * -> *}.
(PyComprehension :<: f) =>
Cxt h f a ComprehensionExprL -> Cxt h f a PyComprehensionL
jPyComprehensionBody (PythonTermAnn a ComprehensionExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ComprehensionExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate PythonTermAnn a ComprehensionExprL
cexp) -- Very unsure of annotations here
  in Bool
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [ExprL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
-> PyComprehension
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyComprehensionL
forall (e :: * -> *).
Bool
-> e [ExprL]
-> e ExprL
-> e PyComprehensionL
-> PyComprehension e PyComprehensionL
PyComprehensionFor Bool
b ((Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL)
-> Cxt NoHole (Sum PythonSig :&: a) (K ()) [ExprL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [ExprL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) [ExprL]
es) (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
v) Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
comp PyComprehension
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyComprehensionL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyComprehensionL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a

translateLValue :: (Default a) => F.PythonTermAnn a F.ExprL -> MPythonTermAnn a PyLValueL
translateLValue :: forall a.
Default a =>
PythonTermAnn a ExprL -> MPythonTermAnn a PyLValueL
translateLValue (F.Tuple Cxt NoHole (Sum PythonSig :&: a) (K ()) [ExprL]
xs        ::&:: a
a) = Cxt NoHole (Sum MPythonSig :&: a) (K ()) [PyLValueL]
-> TupleLValue (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyLValueL
forall (e :: * -> *). e [PyLValueL] -> TupleLValue e PyLValueL
TupleLValue ((Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL)
-> Cxt NoHole (Sum PythonSig :&: a) (K ()) [ExprL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [PyLValueL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall a.
Default a =>
PythonTermAnn a ExprL -> MPythonTermAnn a PyLValueL
translateLValue Cxt NoHole (Sum PythonSig :&: a) (K ()) [ExprL]
xs)       TupleLValue (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyLValueL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
translateLValue (F.List Cxt NoHole (Sum PythonSig :&: a) (K ()) [ExprL]
xs         ::&:: a
a) = Cxt NoHole (Sum MPythonSig :&: a) (K ()) [PyLValueL]
-> ListLValue (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyLValueL
forall (e :: * -> *). e [PyLValueL] -> ListLValue e PyLValueL
ListLValue  ((Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL)
-> Cxt NoHole (Sum PythonSig :&: a) (K ()) [ExprL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [PyLValueL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall a.
Default a =>
PythonTermAnn a ExprL -> MPythonTermAnn a PyLValueL
translateLValue Cxt NoHole (Sum PythonSig :&: a) (K ()) [ExprL]
xs)       ListLValue (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyLValueL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
translateLValue (F.Dot Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
i         ::&:: a
a) = Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
-> DotLValue (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyLValueL
forall (e :: * -> *). e ExprL -> e IdentL -> DotLValue e PyLValueL
DotLValue (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e) (Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
forall a.
Default a =>
PythonTermAnn a IdentL -> MPythonTermAnn a IdentL
transIdent Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
i)      DotLValue (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyLValueL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
translateLValue (F.Starred Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e       ::&:: a
a) = Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
-> StarLValue (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyLValueL
forall (e :: * -> *). e PyLValueL -> StarLValue e PyLValueL
StarLValue (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall a.
Default a =>
PythonTermAnn a ExprL -> MPythonTermAnn a PyLValueL
translateLValue Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e)              StarLValue (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyLValueL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
translateLValue (F.Subscript Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
x   ::&:: a
a) = Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
-> SubscriptLValue
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyLValueL
forall (e :: * -> *).
e ExprL -> e ExprL -> SubscriptLValue e PyLValueL
SubscriptLValue (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e) (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
x) SubscriptLValue
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyLValueL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
translateLValue (F.SlicedExpr Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e Cxt NoHole (Sum PythonSig :&: a) (K ()) [SliceL]
sl ::&:: a
a) = Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [SliceL]
-> SliceLValue (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyLValueL
forall (e :: * -> *).
e ExprL -> e [SliceL] -> SliceLValue e PyLValueL
SliceLValue (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e) (Cxt NoHole (Sum PythonSig :&: a) (K ()) [SliceL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [SliceL]
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) [SliceL]
sl)    SliceLValue (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyLValueL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
translateLValue (F.Paren Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e         ::&:: a
a) = Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
-> ParenLValue (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyLValueL
forall (e :: * -> *). e PyLValueL -> ParenLValue e PyLValueL
ParenLValue (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall a.
Default a =>
PythonTermAnn a ExprL -> MPythonTermAnn a PyLValueL
translateLValue Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
e)             ParenLValue (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyLValueL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
translateLValue (F.Var Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
n           ::&:: a
a) = Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
forall a.
Default a =>
PythonTermAnn a IdentL -> MPythonTermAnn a IdentL
transIdent Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
n)
translateLValue Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
x                           = String -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall a. HasCallStack => String -> a
error (String
"Invalid expression appeared in lvalue: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Cxt NoHole (Sum PythonSig) (K ()) ExprL -> String
forall a. Show a => a -> String
show (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
CxtFun (Sum PythonSig :&: a) (Sum PythonSig)
forall (g :: Fragment) (f :: Fragment).
(RemA g f, HFunctor g) =>
CxtFun g f
stripA Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
x))


transBinder :: (Default a) => F.PythonTermAnn a (F.ExprL, Maybe F.ExprL) -> MPythonTermAnn a PyWithBinderL
transBinder :: forall a.
Default a =>
PythonTermAnn a (ExprL, Maybe ExprL)
-> MPythonTermAnn a PyWithBinderL
transBinder (PairF Cxt NoHole (Sum PythonSig :&: a) (K ()) i
x Cxt NoHole (Sum PythonSig :&: a) (K ()) j
y ::&:: a
a) = AnnTerm a MPythonSig PyWithBinderL
-> AnnTerm a MPythonSig PyWithBinderL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig PyWithBinderL
 -> AnnTerm a MPythonSig PyWithBinderL)
-> AnnTerm a MPythonSig PyWithBinderL
-> AnnTerm a MPythonSig PyWithBinderL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyLValueL)
-> PyWithBinder
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyWithBinderL
forall (e :: * -> *).
e ExprL -> e (Maybe PyLValueL) -> PyWithBinder e PyWithBinderL
PyWithBinder (PythonTermAnn a ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) i
PythonTermAnn a ExprL
x) ((PythonTermAnn a ExprL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL)
-> Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyLValueL)
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF PythonTermAnn a ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall a.
Default a =>
PythonTermAnn a ExprL -> MPythonTermAnn a PyLValueL
translateLValue Cxt NoHole (Sum PythonSig :&: a) (K ()) j
Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
y) PyWithBinder
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyWithBinderL
-> a -> AnnTerm a MPythonSig PyWithBinderL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a

transParam :: (Default a) => F.PythonTermAnn a F.ParameterL -> MPythonTermAnn a FunctionParameterL
transParam :: forall a.
Default a =>
PythonTermAnn a ParameterL -> MPythonTermAnn a FunctionParameterL
transParam (F.Param          Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
n Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
ann Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
d ::&:: a
a) = AnnTerm a MPythonSig FunctionParameterL
-> AnnTerm a MPythonSig FunctionParameterL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig FunctionParameterL
 -> AnnTerm a MPythonSig FunctionParameterL)
-> AnnTerm a MPythonSig FunctionParameterL
-> AnnTerm a MPythonSig FunctionParameterL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig :&: a) (K ()) ParameterAttrsL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
-> PositionalParameter
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionParameterL
forall (e :: * -> *).
e ParameterAttrsL
-> e IdentL -> PositionalParameter e FunctionParameterL
PositionalParameter (Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ParameterAttrsL
forall {f :: Fragment} {h} {a :: * -> *}.
(PyParamAttrs :<: f) =>
Cxt h f a (Maybe ExprL)
-> Cxt h f a (Maybe ExprL) -> Cxt h f a ParameterAttrsL
jPyParamAttrs (Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe ExprL)
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
ann) (Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe ExprL)
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
d)) (Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
forall a.
Default a =>
PythonTermAnn a IdentL -> MPythonTermAnn a IdentL
transIdent Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
n) PositionalParameter
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionParameterL
-> a -> AnnTerm a MPythonSig FunctionParameterL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
transParam (F.VarArgsPos     Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
n Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
ann   ::&:: a
a) = AnnTerm a MPythonSig FunctionParameterL
-> AnnTerm a MPythonSig FunctionParameterL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig FunctionParameterL
 -> AnnTerm a MPythonSig FunctionParameterL)
-> AnnTerm a MPythonSig FunctionParameterL
-> AnnTerm a MPythonSig FunctionParameterL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe ExprL)
-> PythonParam
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionParameterL
forall (e :: * -> *).
e IdentL -> e (Maybe ExprL) -> PythonParam e FunctionParameterL
PythonParamVarArgs     (Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
forall a.
Default a =>
PythonTermAnn a IdentL -> MPythonTermAnn a IdentL
transIdent Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
n) (Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe ExprL)
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
ann) PythonParam
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionParameterL
-> a -> AnnTerm a MPythonSig FunctionParameterL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
transParam (F.VarArgsKeyword Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
n Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
ann   ::&:: a
a) = AnnTerm a MPythonSig FunctionParameterL
-> AnnTerm a MPythonSig FunctionParameterL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig FunctionParameterL
 -> AnnTerm a MPythonSig FunctionParameterL)
-> AnnTerm a MPythonSig FunctionParameterL
-> AnnTerm a MPythonSig FunctionParameterL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe ExprL)
-> PythonParam
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionParameterL
forall (e :: * -> *).
e IdentL -> e (Maybe ExprL) -> PythonParam e FunctionParameterL
PythonParamVarArgsKW   (Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
forall a.
Default a =>
PythonTermAnn a IdentL -> MPythonTermAnn a IdentL
transIdent Cxt NoHole (Sum PythonSig :&: a) (K ()) IdentL
n) (Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe ExprL)
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
ann) PythonParam
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionParameterL
-> a -> AnnTerm a MPythonSig FunctionParameterL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
transParam (Parameter (Cxt NoHole (Sum PythonSig :&: a) (K ())) ParameterL
F.EndPositional          ::&:: a
a) = AnnTerm a MPythonSig FunctionParameterL
-> AnnTerm a MPythonSig FunctionParameterL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig FunctionParameterL
 -> AnnTerm a MPythonSig FunctionParameterL)
-> AnnTerm a MPythonSig FunctionParameterL
-> AnnTerm a MPythonSig FunctionParameterL
forall a b. (a -> b) -> a -> b
$ PythonParam
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionParameterL
forall (e :: * -> *). PythonParam e FunctionParameterL
PythonEndPosParam                                     PythonParam
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionParameterL
-> a -> AnnTerm a MPythonSig FunctionParameterL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
transParam (F.UnPackTuple Cxt NoHole (Sum PythonSig :&: a) (K ()) ParamTupleL
t    Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
ann   ::&:: a
a) = AnnTerm a MPythonSig FunctionParameterL
-> AnnTerm a MPythonSig FunctionParameterL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig FunctionParameterL
 -> AnnTerm a MPythonSig FunctionParameterL)
-> AnnTerm a MPythonSig FunctionParameterL
-> AnnTerm a MPythonSig FunctionParameterL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig :&: a) (K ()) ParamTupleL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe ExprL)
-> PythonParam
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionParameterL
forall (e :: * -> *).
e ParamTupleL
-> e (Maybe ExprL) -> PythonParam e FunctionParameterL
PythonParamUnpackTuple (Cxt NoHole (Sum PythonSig :&: a) (K ()) ParamTupleL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) ParamTupleL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) ParamTupleL
t) (Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe ExprL)
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate Cxt NoHole (Sum PythonSig :&: a) (K ()) (Maybe ExprL)
ann)  PythonParam
  (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionParameterL
-> a -> AnnTerm a MPythonSig FunctionParameterL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a

extractString :: (Default a) => F.PythonTermAnn a [CharL] -> String
extractString :: forall a. Default a => PythonTermAnn a [CharL] -> String
extractString PythonTermAnn a [CharL]
cs = (PythonTermAnn a CharL -> Char)
-> [PythonTermAnn a CharL] -> String
forall a b. (a -> b) -> [a] -> [b]
map PythonTermAnn a CharL -> Char
forall a. Default a => PythonTermAnn a CharL -> Char
getChar ([PythonTermAnn a CharL] -> String)
-> [PythonTermAnn a CharL] -> String
forall a b. (a -> b) -> a -> b
$ PythonTermAnn a [CharL] -> [PythonTermAnn a CharL]
forall l.
Cxt NoHole (Sum PythonSig :&: a) (K ()) [l]
-> [Cxt NoHole (Sum PythonSig :&: a) (K ()) l]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF PythonTermAnn a [CharL]
cs
  where
    getChar :: (Default a) => F.PythonTermAnn a CharL -> Char
    getChar :: forall a. Default a => PythonTermAnn a CharL -> Char
getChar (CharF' Char
c) = Char
c

extractStrings :: (Default a) => F.PythonTermAnn a [[CharL]] -> [String]
extractStrings :: forall a. Default a => PythonTermAnn a [[CharL]] -> [String]
extractStrings PythonTermAnn a [[CharL]]
strs = (PythonTermAnn a [CharL] -> String)
-> [PythonTermAnn a [CharL]] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map PythonTermAnn a [CharL] -> String
forall a. Default a => PythonTermAnn a [CharL] -> String
extractString ([PythonTermAnn a [CharL]] -> [String])
-> [PythonTermAnn a [CharL]] -> [String]
forall a b. (a -> b) -> a -> b
$ PythonTermAnn a [[CharL]] -> [PythonTermAnn a [CharL]]
forall l.
Cxt NoHole (Sum PythonSig :&: a) (K ()) [l]
-> [Cxt NoHole (Sum PythonSig :&: a) (K ()) l]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF PythonTermAnn a [[CharL]]
strs

makePyBlock :: forall a. (Default a) => F.PythonTermAnn a [F.StatementL] -> MPythonTermAnn a PyBlockL
makePyBlock :: forall a.
Default a =>
PythonTermAnn a [StatementL] -> MPythonTermAnn a PyBlockL
makePyBlock PythonTermAnn a [StatementL]
stmts = Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyBlockL
forall {f :: Fragment} {h} {a :: * -> *}.
(PyBlock :<: f) =>
Cxt h f a (Maybe PyStringLitL)
-> Cxt h f a BlockL -> Cxt h f a PyBlockL
jPyBlock Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL)
docstring (Cxt NoHole (Sum MPythonSig :&: a) (K ()) [BlockItemL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockEndL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockL
forall {f :: Fragment} {h} {a :: * -> *}.
(Block :<: f) =>
Cxt h f a [BlockItemL] -> Cxt h f a BlockEndL -> Cxt h f a BlockL
jBlock ([Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockItemL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [BlockItemL]
forall l.
Typeable l =>
[Cxt NoHole (Sum MPythonSig :&: a) (K ()) l]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [l]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockItemL]
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [BlockItemL])
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockItemL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [BlockItemL]
forall a b. (a -> b) -> a -> b
$ (PythonTermAnn a StatementL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockItemL)
-> [PythonTermAnn a StatementL]
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockItemL]
forall a b. (a -> b) -> [a] -> [b]
map (AnnTerm a MPythonSig StatementL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockItemL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef(AnnTerm a MPythonSig StatementL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockItemL)
-> (PythonTermAnn a StatementL -> AnnTerm a MPythonSig StatementL)
-> PythonTermAnn a StatementL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockItemL
forall b c a. (b -> c) -> (a -> b) -> a -> c
.PythonTermAnn a StatementL -> AnnTerm a MPythonSig StatementL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate) [PythonTermAnn a StatementL]
body) Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockEndL
forall h (f :: Fragment) (a :: * -> *).
(EmptyBlockEnd :<: f) =>
Cxt h f a BlockEndL
jEmptyBlockEnd)
  where
    docstring :: MPythonTermAnn a (Maybe PyStringLitL)
    body :: [F.PythonTermAnn a F.StatementL]
    (Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL)
docstring, [PythonTermAnn a StatementL]
body) = case PythonTermAnn a [StatementL] -> [PythonTermAnn a StatementL]
forall l.
Cxt NoHole (Sum PythonSig :&: a) (K ()) [l]
-> [Cxt NoHole (Sum PythonSig :&: a) (K ()) l]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF PythonTermAnn a [StatementL]
stmts of
      [] -> (Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL)
forall (f :: Fragment) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a (Maybe l)
Nothing', [])
      (PythonTermAnn a StatementL
fst : [PythonTermAnn a StatementL]
rest) ->
        case PythonTermAnn a StatementL
fst of
          (F.StmtExpr Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
exp ::&:: a
_) ->
            case Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
exp of
              (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Maybe
     ((:&:) Expr a (Cxt NoHole (Sum PythonSig :&: a) (K ())) ExprL)
NatM
  Maybe
  (Cxt NoHole (Sum PythonSig :&: a) (K ()))
  ((:&:) Expr a (Cxt NoHole (Sum PythonSig :&: a) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Strings        Cxt NoHole (Sum PythonSig :&: a) (K ()) [[CharL]]
strs :&: a
a)) -> (Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyStringLitL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL)
forall (f :: Fragment) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a l -> Cxt h f a (Maybe l)
Just' (Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyStringLitL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL))
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyStringLitL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL)
forall a b. (a -> b) -> a -> b
$ [String]
-> PyStringLit
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyStringLitL
forall (a :: * -> *). [String] -> PyStringLit a PyStringLitL
PyStrings        (Cxt NoHole (Sum PythonSig :&: a) (K ()) [[CharL]] -> [String]
forall a. Default a => PythonTermAnn a [[CharL]] -> [String]
extractStrings Cxt NoHole (Sum PythonSig :&: a) (K ()) [[CharL]]
strs) PyStringLit (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyStringLitL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyStringLitL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a, [PythonTermAnn a StatementL]
rest)
              (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Maybe
     ((:&:) Expr a (Cxt NoHole (Sum PythonSig :&: a) (K ())) ExprL)
NatM
  Maybe
  (Cxt NoHole (Sum PythonSig :&: a) (K ()))
  ((:&:) Expr a (Cxt NoHole (Sum PythonSig :&: a) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.UnicodeStrings Cxt NoHole (Sum PythonSig :&: a) (K ()) [[CharL]]
strs :&: a
a)) -> (Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyStringLitL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL)
forall (f :: Fragment) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a l -> Cxt h f a (Maybe l)
Just' (Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyStringLitL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL))
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyStringLitL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL)
forall a b. (a -> b) -> a -> b
$ [String]
-> PyStringLit
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyStringLitL
forall (a :: * -> *). [String] -> PyStringLit a PyStringLitL
PyUnicodeStrings (Cxt NoHole (Sum PythonSig :&: a) (K ()) [[CharL]] -> [String]
forall a. Default a => PythonTermAnn a [[CharL]] -> [String]
extractStrings Cxt NoHole (Sum PythonSig :&: a) (K ()) [[CharL]]
strs) PyStringLit (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyStringLitL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyStringLitL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a, [PythonTermAnn a StatementL]
rest)
              (Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
-> Maybe
     ((:&:) Expr a (Cxt NoHole (Sum PythonSig :&: a) (K ())) ExprL)
NatM
  Maybe
  (Cxt NoHole (Sum PythonSig :&: a) (K ()))
  ((:&:) Expr a (Cxt NoHole (Sum PythonSig :&: a) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.ByteStrings    Cxt NoHole (Sum PythonSig :&: a) (K ()) [[CharL]]
strs :&: a
a)) -> (Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyStringLitL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL)
forall (f :: Fragment) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a l -> Cxt h f a (Maybe l)
Just' (Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyStringLitL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL))
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyStringLitL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL)
forall a b. (a -> b) -> a -> b
$ [String]
-> PyStringLit
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyStringLitL
forall (a :: * -> *). [String] -> PyStringLit a PyStringLitL
PyByteStrings    (Cxt NoHole (Sum PythonSig :&: a) (K ()) [[CharL]] -> [String]
forall a. Default a => PythonTermAnn a [[CharL]] -> [String]
extractStrings Cxt NoHole (Sum PythonSig :&: a) (K ()) [[CharL]]
strs) PyStringLit (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyStringLitL
-> a -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyStringLitL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a, [PythonTermAnn a StatementL]
rest)
              Cxt NoHole (Sum PythonSig :&: a) (K ()) ExprL
_                                              -> (Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL)
forall (f :: Fragment) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a (Maybe l)
Nothing', PythonTermAnn a StatementL
fst PythonTermAnn a StatementL
-> [PythonTermAnn a StatementL] -> [PythonTermAnn a StatementL]
forall a. a -> [a] -> [a]
: [PythonTermAnn a StatementL]
rest)
          PythonTermAnn a StatementL
_ -> (Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe PyStringLitL)
forall (f :: Fragment) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a (Maybe l)
Nothing', PythonTermAnn a StatementL
fst PythonTermAnn a StatementL
-> [PythonTermAnn a StatementL] -> [PythonTermAnn a StatementL]
forall a. a -> [a] -> [a]
: [PythonTermAnn a StatementL]
rest)

instance Trans F.Statement where
  trans :: forall a l.
Default a =>
(:&:) Statement a (PythonTermAnn a) l -> MPythonTermAnn a l
trans (F.Assign PythonTermAnn a [ExprL]
es PythonTermAnn a ExprL
e           :&: a
a) = AnnTerm a MPythonSig AssignL -> AnnTerm a MPythonSig l
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig AssignL -> AnnTerm a MPythonSig l)
-> AnnTerm a MPythonSig AssignL -> AnnTerm a MPythonSig l
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig :&: a) (K ()) LhsL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) AssignOpL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) RhsL
-> Assign (Cxt NoHole (Sum MPythonSig :&: a) (K ())) AssignL
forall (e :: * -> *).
e LhsL -> e AssignOpL -> e RhsL -> Assign e AssignL
Assign (Cxt NoHole (Sum MPythonSig :&: a) (K ()) [PyLValueL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) LhsL
forall {f :: Fragment} {h} {a :: * -> *}.
(PyLhs :<: f) =>
Cxt h f a [PyLValueL] -> Cxt h f a LhsL
jPyLhs (Cxt NoHole (Sum MPythonSig :&: a) (K ()) [PyLValueL]
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) LhsL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [PyLValueL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) LhsL
forall a b. (a -> b) -> a -> b
$ (PythonTermAnn a ExprL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL)
-> PythonTermAnn a [ExprL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [PyLValueL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF PythonTermAnn a ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyLValueL
forall a.
Default a =>
PythonTermAnn a ExprL -> MPythonTermAnn a PyLValueL
translateLValue PythonTermAnn a [ExprL]
es) Cxt NoHole (Sum MPythonSig :&: a) (K ()) AssignOpL
forall h (f :: Fragment) (a :: * -> *).
(AssignOpEquals :<: f) =>
Cxt h f a AssignOpL
jAssignOpEquals (AnnTerm a MPythonSig ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) RhsL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig ExprL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) RhsL)
-> AnnTerm a MPythonSig ExprL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) RhsL
forall a b. (a -> b) -> a -> b
$ PythonTermAnn a ExprL -> AnnTerm a MPythonSig ExprL
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate PythonTermAnn a ExprL
e) Assign (Cxt NoHole (Sum MPythonSig :&: a) (K ())) AssignL
-> a -> AnnTerm a MPythonSig AssignL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
  trans (F.Fun PythonTermAnn a IdentL
n PythonTermAnn a [ParameterL]
params PythonTermAnn a (Maybe ExprL)
ann PythonTermAnn a [StatementL]
body :&: a
a) = AnnTerm a MPythonSig FunctionDefL -> AnnTerm a MPythonSig l
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig FunctionDefL -> AnnTerm a MPythonSig l)
-> AnnTerm a MPythonSig FunctionDefL -> AnnTerm a MPythonSig l
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionDefAttrsL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [FunctionParameterL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionBodyL
-> FunctionDef
     (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionDefL
forall (e :: * -> *).
e FunctionDefAttrsL
-> e IdentL
-> e [FunctionParameterL]
-> e FunctionBodyL
-> FunctionDef e FunctionDefL
FunctionDef (Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionDefAttrsL
forall {f :: Fragment} {h} {a :: * -> *}.
(PyFunDefAttrs :<: f) =>
Cxt h f a (Maybe ExprL) -> Cxt h f a FunctionDefAttrsL
jPyFunDefAttrs (Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe ExprL)
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionDefAttrsL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionDefAttrsL
forall a b. (a -> b) -> a -> b
$ PythonTermAnn a (Maybe ExprL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) (Maybe ExprL)
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate PythonTermAnn a (Maybe ExprL)
ann) (PythonTermAnn a IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
forall a.
Default a =>
PythonTermAnn a IdentL -> MPythonTermAnn a IdentL
transIdent PythonTermAnn a IdentL
n) ((Cxt NoHole (Sum PythonSig :&: a) (K ()) ParameterL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionParameterL)
-> PythonTermAnn a [ParameterL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [FunctionParameterL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF Cxt NoHole (Sum PythonSig :&: a) (K ()) ParameterL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionParameterL
forall a.
Default a =>
PythonTermAnn a ParameterL -> MPythonTermAnn a FunctionParameterL
transParam PythonTermAnn a [ParameterL]
params) (AnnTerm a MPythonSig PyBlockL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionBodyL
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig PyBlockL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionBodyL)
-> AnnTerm a MPythonSig PyBlockL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) FunctionBodyL
forall a b. (a -> b) -> a -> b
$ PythonTermAnn a [StatementL] -> AnnTerm a MPythonSig PyBlockL
forall a.
Default a =>
PythonTermAnn a [StatementL] -> MPythonTermAnn a PyBlockL
makePyBlock PythonTermAnn a [StatementL]
body) FunctionDef (Cxt NoHole (Sum MPythonSig :&: a) (K ())) FunctionDefL
-> a -> AnnTerm a MPythonSig FunctionDefL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
  trans (F.With PythonTermAnn a [(ExprL, Maybe ExprL)]
binders PythonTermAnn a [StatementL]
body     :&: a
a) = AnnTerm a MPythonSig StatementL -> AnnTerm a MPythonSig l
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig StatementL -> AnnTerm a MPythonSig l)
-> AnnTerm a MPythonSig StatementL -> AnnTerm a MPythonSig l
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig :&: a) (K ()) [PyWithBinderL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [StatementL]
-> PyWith (Cxt NoHole (Sum MPythonSig :&: a) (K ())) StatementL
forall (e :: * -> *).
e [PyWithBinderL] -> e [StatementL] -> PyWith e StatementL
PyWith ((Cxt NoHole (Sum PythonSig :&: a) (K ()) (ExprL, Maybe ExprL)
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL)
-> PythonTermAnn a [(ExprL, Maybe ExprL)]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [PyWithBinderL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF Cxt NoHole (Sum PythonSig :&: a) (K ()) (ExprL, Maybe ExprL)
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL
forall a.
Default a =>
PythonTermAnn a (ExprL, Maybe ExprL)
-> MPythonTermAnn a PyWithBinderL
transBinder PythonTermAnn a [(ExprL, Maybe ExprL)]
binders) (PythonTermAnn a [StatementL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [StatementL]
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate PythonTermAnn a [StatementL]
body) PyWith (Cxt NoHole (Sum MPythonSig :&: a) (K ())) StatementL
-> a -> AnnTerm a MPythonSig StatementL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
  trans (F.Class PythonTermAnn a IdentL
id PythonTermAnn a [ArgumentL]
args PythonTermAnn a [StatementL]
body    :&: a
a) = AnnTerm a MPythonSig PyClassL -> AnnTerm a MPythonSig l
forall (fs :: [Fragment]) l l' a.
(InjF fs l l', All HTraversable fs, Default a, All HFoldable fs) =>
AnnTerm a fs l -> AnnTerm a fs l'
injFAnnDef (AnnTerm a MPythonSig PyClassL -> AnnTerm a MPythonSig l)
-> AnnTerm a MPythonSig PyClassL -> AnnTerm a MPythonSig l
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [ArgumentL]
-> AnnTerm a MPythonSig PyBlockL
-> PyClass (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyClassL
forall (e :: * -> *).
e IdentL -> e [ArgumentL] -> e PyBlockL -> PyClass e PyClassL
PyClass (PythonTermAnn a IdentL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) IdentL
forall a.
Default a =>
PythonTermAnn a IdentL -> MPythonTermAnn a IdentL
transIdent PythonTermAnn a IdentL
id) (PythonTermAnn a [ArgumentL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [ArgumentL]
forall a l. Default a => PythonTermAnn a l -> MPythonTermAnn a l
translate PythonTermAnn a [ArgumentL]
args) (PythonTermAnn a [StatementL] -> AnnTerm a MPythonSig PyBlockL
forall a.
Default a =>
PythonTermAnn a [StatementL] -> MPythonTermAnn a PyBlockL
makePyBlock PythonTermAnn a [StatementL]
body) PyClass (Cxt NoHole (Sum MPythonSig :&: a) (K ())) PyClassL
-> a -> AnnTerm a MPythonSig PyClassL
forall (g :: Fragment) (fs :: [Fragment]) h x (a :: * -> *) l.
(g :-<: fs) =>
g (Cxt h (Sum fs :&: x) a) l -> x -> Cxt h (Sum fs :&: x) a l
::&:: a
a
  trans (:&:) Statement a (PythonTermAnn a) l
x                               = (:&:) Statement a (PythonTermAnn a) l -> AnnTerm a MPythonSig l
forall (f :: Fragment) a l.
(HFunctor f, f :-<: MPythonSig, f :-<: PythonSig, Default a) =>
(:&:) f a (PythonTermAnn a) l -> MPythonTermAnn a l
transDefault (:&:) Statement a (PythonTermAnn a) l
x

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

class Untrans f where
  untrans :: f MPythonTerm l -> F.PythonTerm l

instance {-# OVERLAPPING #-} (All Untrans fs) => Untrans (Sum fs) where
  untrans :: forall l.
Sum fs (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
untrans = forall (cxt :: Fragment -> Constraint) (fs :: [Fragment])
       (a :: * -> *) e b.
All cxt fs =>
(forall (f :: Fragment). cxt f => f a e -> b) -> Sum fs a e -> b
caseCxt @Untrans f (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
forall l. f (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
forall (f :: Fragment).
Untrans f =>
f (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
forall (f :: Fragment) l.
Untrans f =>
f (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
untrans

untransError :: (HFunctor f, f :-<: MPythonSig) => f MPythonTerm l -> F.PythonTerm l
untransError :: forall (f :: Fragment) l.
(HFunctor f, f :-<: MPythonSig) =>
f (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
untransError f (Cxt NoHole (Sum MPythonSig) (K ())) l
t = String -> PythonTerm l
forall a. HasCallStack => String -> a
error (String -> PythonTerm l) -> String -> PythonTerm l
forall a b. (a -> b) -> a -> b
$ String
"Cannot untranslate root node: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ (Cxt NoHole (Sum MPythonSig) (K ()) l -> String
forall a. Show a => a -> String
show (Cxt NoHole (Sum MPythonSig) (K ()) l -> String)
-> Cxt NoHole (Sum MPythonSig) (K ()) l -> String
forall a b. (a -> b) -> a -> b
$ f (Cxt NoHole (Sum MPythonSig) (K ())) l
-> Cxt NoHole (Sum MPythonSig) (K ()) l
f (Cxt NoHole (Sum MPythonSig) (K ()))
:-> Cxt NoHole (Sum MPythonSig) (K ())
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
g (Cxt h f a) :-> Cxt h f a
inject f (Cxt NoHole (Sum MPythonSig) (K ())) l
t)

do ipsNames <- sumToNames ''MPythonSig
   modNames <- sumToNames ''F.PythonSig
   let targTs = map ConT $ (ipsNames \\ modNames) \\ [''PyWith, ''PyClassIsStatement, ''AssignIsStatement, ''IdentIsIdent, ''FunctionCallIsExpr, ''FunctionDefIsStatement, ''PyCompIsExpr, ''PyCondExpr, ''PyComprehensionExpr]
   return $ makeDefaultInstances targTs ''Untrans 'untrans (VarE 'untransError)


untransDefault :: (HFunctor f, f :-<: F.PythonSig) => f MPythonTerm l -> F.PythonTerm l
untransDefault :: forall (f :: Fragment) l.
(HFunctor f, f :-<: PythonSig) =>
f (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
untransDefault = f (Cxt NoHole (Sum PythonSig) (K ())) l
-> Cxt NoHole (Sum PythonSig) (K ()) l
f (Cxt NoHole (Sum PythonSig) (K ()))
:-> Cxt NoHole (Sum PythonSig) (K ())
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
g (Cxt h f a) :-> Cxt h f a
inject (f (Cxt NoHole (Sum PythonSig) (K ())) l
 -> Cxt NoHole (Sum PythonSig) (K ()) l)
-> (f (Cxt NoHole (Sum MPythonSig) (K ())) l
    -> f (Cxt NoHole (Sum PythonSig) (K ())) l)
-> f (Cxt NoHole (Sum MPythonSig) (K ())) l
-> Cxt NoHole (Sum PythonSig) (K ()) l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Cxt NoHole (Sum MPythonSig) (K ())
 :-> Cxt NoHole (Sum PythonSig) (K ()))
-> f (Cxt NoHole (Sum MPythonSig) (K ()))
   :-> f (Cxt NoHole (Sum PythonSig) (K ()))
forall (f :: * -> *) (g :: * -> *). (f :-> g) -> f f :-> f g
forall (h :: Fragment) (f :: * -> *) (g :: * -> *).
HFunctor h =>
(f :-> g) -> h f :-> h g
hfmap MPythonTerm i -> PythonTerm i
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate

instance {-# OVERLAPPABLE #-} (HFunctor f, f :-<: F.PythonSig) => Untrans f where
  untrans :: forall l. f (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
untrans = f (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
forall (f :: Fragment) l.
(HFunctor f, f :-<: PythonSig) =>
f (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
untransDefault

untransIdent :: MPythonTerm IdentL -> F.PythonTerm F.IdentL
untransIdent :: MPythonTerm IdentL -> PythonTerm IdentL
untransIdent (Ident' String
x) = String -> PythonTerm IdentL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Ident :-<: fs, InjF fs IdentL j) =>
String -> CxtS h fs a j
F.iIdent String
x

instance {-# OVERLAPPING #-} Untrans IdentIsIdent where
  untrans :: forall l.
IdentIsIdent (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
untrans (IdentIsIdent (Ident' String
x)) = String -> CxtS NoHole PythonSig (K ()) l
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Ident :-<: fs, InjF fs IdentL j) =>
String -> CxtS h fs a j
F.iIdent String
x

untransLValue :: MPythonTerm PyLValueL -> F.PythonTerm F.ExprL
untransLValue :: MPythonTerm PyLValueL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL
untransLValue (MPythonTerm PyLValueL
-> Maybe
     (TupleLValue (Cxt NoHole (Sum MPythonSig) (K ())) PyLValueL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (TupleLValue (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (TupleLValue Cxt NoHole (Sum MPythonSig) (K ()) [PyLValueL]
xs))      = CxtS NoHole PythonSig (K ()) [ExprL]
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a [ExprL] -> CxtS h fs a j
F.iTuple ((MPythonTerm PyLValueL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> Cxt NoHole (Sum MPythonSig) (K ()) [PyLValueL]
-> CxtS NoHole PythonSig (K ()) [ExprL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF MPythonTerm PyLValueL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL
untransLValue Cxt NoHole (Sum MPythonSig) (K ()) [PyLValueL]
xs)
untransLValue (MPythonTerm PyLValueL
-> Maybe
     (ListLValue (Cxt NoHole (Sum MPythonSig) (K ())) PyLValueL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (ListLValue (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (ListLValue Cxt NoHole (Sum MPythonSig) (K ()) [PyLValueL]
xs))       = CxtS NoHole PythonSig (K ()) [ExprL]
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a [ExprL] -> CxtS h fs a j
F.iList  ((MPythonTerm PyLValueL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> Cxt NoHole (Sum MPythonSig) (K ()) [PyLValueL]
-> CxtS NoHole PythonSig (K ()) [ExprL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF MPythonTerm PyLValueL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL
untransLValue Cxt NoHole (Sum MPythonSig) (K ()) [PyLValueL]
xs)
untransLValue (MPythonTerm PyLValueL
-> Maybe (DotLValue (Cxt NoHole (Sum MPythonSig) (K ())) PyLValueL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (DotLValue (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (DotLValue Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e MPythonTerm IdentL
i))       = Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> PythonTerm IdentL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a ExprL -> CxtS h fs a IdentL -> CxtS h fs a j
F.iDot (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e) (MPythonTerm IdentL -> PythonTerm IdentL
untransIdent MPythonTerm IdentL
i)
untransLValue (MPythonTerm PyLValueL
-> Maybe
     (StarLValue (Cxt NoHole (Sum MPythonSig) (K ())) PyLValueL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (StarLValue (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (StarLValue MPythonTerm PyLValueL
e))        = Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a ExprL -> CxtS h fs a j
F.iStarred (MPythonTerm PyLValueL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL
untransLValue MPythonTerm PyLValueL
e)
untransLValue (MPythonTerm PyLValueL
-> Maybe
     (SubscriptLValue (Cxt NoHole (Sum MPythonSig) (K ())) PyLValueL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (SubscriptLValue (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (SubscriptLValue Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e Cxt NoHole (Sum MPythonSig) (K ()) ExprL
x)) = Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a ExprL -> CxtS h fs a ExprL -> CxtS h fs a j
F.iSubscript (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e) (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
x)
untransLValue (MPythonTerm PyLValueL
-> Maybe
     (SliceLValue (Cxt NoHole (Sum MPythonSig) (K ())) PyLValueL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (SliceLValue (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (SliceLValue Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e Cxt NoHole (Sum MPythonSig) (K ()) [SliceL]
sl))    = Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole PythonSig (K ()) [SliceL]
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a ExprL -> CxtS h fs a [SliceL] -> CxtS h fs a j
F.iSlicedExpr (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e) (Cxt NoHole (Sum MPythonSig) (K ()) [SliceL]
-> CxtS NoHole PythonSig (K ()) [SliceL]
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) [SliceL]
sl)
untransLValue (MPythonTerm PyLValueL
-> Maybe
     (ParenLValue (Cxt NoHole (Sum MPythonSig) (K ())) PyLValueL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (ParenLValue (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (ParenLValue MPythonTerm PyLValueL
e))       = Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a ExprL -> CxtS h fs a j
F.iParen (MPythonTerm PyLValueL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL
untransLValue MPythonTerm PyLValueL
e)
untransLValue (MPythonTerm PyLValueL
-> Maybe
     (IdentIsPyLValue (Cxt NoHole (Sum MPythonSig) (K ())) PyLValueL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (IdentIsPyLValue (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (IdentIsPyLValue MPythonTerm IdentL
n))   = PythonTerm IdentL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a IdentL -> CxtS h fs a j
F.iVar (MPythonTerm IdentL -> PythonTerm IdentL
untransIdent MPythonTerm IdentL
n)

instance {-# OVERLAPPING #-} Untrans AssignIsStatement where
  untrans :: forall l.
AssignIsStatement (Cxt NoHole (Sum MPythonSig) (K ())) l
-> PythonTerm l
untrans (AssignIsStatement (Assign' Cxt NoHole (Sum MPythonSig) (K ()) LhsL
l Cxt NoHole (Sum MPythonSig) (K ()) AssignOpL
AssignOpEquals' Cxt NoHole (Sum MPythonSig) (K ()) RhsL
r)) = CxtS NoHole PythonSig (K ()) [ExprL]
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole PythonSig (K ()) l
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Statement :-<: fs, InjF fs StatementL j) =>
CxtS h fs a [ExprL] -> CxtS h fs a ExprL -> CxtS h fs a j
F.iAssign ((MPythonTerm PyLValueL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> Cxt NoHole (Sum MPythonSig) (K ()) [PyLValueL]
-> CxtS NoHole PythonSig (K ()) [ExprL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF MPythonTerm PyLValueL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL
untransLValue (Cxt NoHole (Sum MPythonSig) (K ()) [PyLValueL]
 -> CxtS NoHole PythonSig (K ()) [ExprL])
-> Cxt NoHole (Sum MPythonSig) (K ()) [PyLValueL]
-> CxtS NoHole PythonSig (K ()) [ExprL]
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig) (K ()) LhsL
-> Cxt NoHole (Sum MPythonSig) (K ()) [PyLValueL]
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF Cxt NoHole (Sum MPythonSig) (K ()) LhsL
l) (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
 -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig) (K ()) RhsL
-> Cxt NoHole (Sum MPythonSig) (K ()) ExprL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF Cxt NoHole (Sum MPythonSig) (K ()) RhsL
r)


untransBinder :: MPythonTerm PyWithBinderL -> F.PythonTerm (F.ExprL, Maybe F.ExprL)
untransBinder :: MPythonTerm PyWithBinderL -> PythonTerm (ExprL, Maybe ExprL)
untransBinder (MPythonTerm PyWithBinderL
-> Maybe
     (PyWithBinder (Cxt NoHole (Sum MPythonSig) (K ())) PyWithBinderL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PyWithBinder (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PyWithBinder Cxt NoHole (Sum MPythonSig) (K ()) ExprL
x Cxt NoHole (Sum MPythonSig) (K ()) (Maybe PyLValueL)
y)) = Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> PythonTerm (ExprL, Maybe ExprL)
forall (f :: Fragment) l l' h (a :: * -> *).
(PairF :<: f, Typeable l, Typeable l', HFunctor f) =>
Cxt h f a l -> Cxt h f a l' -> Cxt h f a (l, l')
PairF' (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
x) ((MPythonTerm PyLValueL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> Cxt NoHole (Sum MPythonSig) (K ()) (Maybe PyLValueL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF MPythonTerm PyLValueL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL
untransLValue Cxt NoHole (Sum MPythonSig) (K ()) (Maybe PyLValueL)
y)

instance {-# OVERLAPPING #-} Untrans PyWith where
  untrans :: forall l.
PyWith (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
untrans (PyWith MPythonTerm [PyWithBinderL]
binders MPythonTerm [StatementL]
body) = CxtS NoHole PythonSig (K ()) [(ExprL, Maybe ExprL)]
-> CxtS NoHole PythonSig (K ()) [StatementL]
-> CxtS NoHole PythonSig (K ()) l
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Statement :-<: fs, InjF fs StatementL j) =>
CxtS h fs a [(ExprL, Maybe ExprL)]
-> CxtS h fs a [StatementL] -> CxtS h fs a j
F.iWith ((MPythonTerm PyWithBinderL -> PythonTerm (ExprL, Maybe ExprL))
-> MPythonTerm [PyWithBinderL]
-> CxtS NoHole PythonSig (K ()) [(ExprL, Maybe ExprL)]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF MPythonTerm PyWithBinderL -> PythonTerm (ExprL, Maybe ExprL)
untransBinder MPythonTerm [PyWithBinderL]
binders) (MPythonTerm [StatementL]
-> CxtS NoHole PythonSig (K ()) [StatementL]
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate MPythonTerm [StatementL]
body)

untransPyStrLit :: MPythonTerm PyStringLitL -> F.PythonTerm F.ExprL
untransPyStrLit :: MPythonTerm PyStringLitL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL
untransPyStrLit (MPythonTerm PyStringLitL
-> Maybe
     (PyStringLit (Cxt NoHole (Sum MPythonSig) (K ())) PyStringLitL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PyStringLit (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PyStrings        [String]
strs)) = CxtS NoHole PythonSig (K ()) [[CharL]]
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a [[CharL]] -> CxtS h fs a j
F.iStrings        ([String] -> CxtS NoHole PythonSig (K ()) [[CharL]]
insertStrings [String]
strs)
untransPyStrLit (MPythonTerm PyStringLitL
-> Maybe
     (PyStringLit (Cxt NoHole (Sum MPythonSig) (K ())) PyStringLitL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PyStringLit (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PyUnicodeStrings [String]
strs)) = CxtS NoHole PythonSig (K ()) [[CharL]]
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a [[CharL]] -> CxtS h fs a j
F.iUnicodeStrings ([String] -> CxtS NoHole PythonSig (K ()) [[CharL]]
insertStrings [String]
strs)
untransPyStrLit (MPythonTerm PyStringLitL
-> Maybe
     (PyStringLit (Cxt NoHole (Sum MPythonSig) (K ())) PyStringLitL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PyStringLit (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PyByteStrings    [String]
strs)) = CxtS NoHole PythonSig (K ()) [[CharL]]
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a [[CharL]] -> CxtS h fs a j
F.iByteStrings    ([String] -> CxtS NoHole PythonSig (K ()) [[CharL]]
insertStrings [String]
strs)

untransBlock :: MPythonTerm BlockL -> F.PythonTerm [F.StatementL]
untransBlock :: MPythonTerm BlockL -> CxtS NoHole PythonSig (K ()) [StatementL]
untransBlock (Block' Cxt NoHole (Sum MPythonSig) (K ()) [BlockItemL]
ss Cxt NoHole (Sum MPythonSig) (K ()) BlockEndL
EmptyBlockEnd') = (Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL
 -> Cxt NoHole (Sum PythonSig) (K ()) StatementL)
-> Cxt NoHole (Sum MPythonSig) (K ()) [BlockItemL]
-> CxtS NoHole PythonSig (K ()) [StatementL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF (MPythonTerm StatementL
-> Cxt NoHole (Sum PythonSig) (K ()) StatementL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate(MPythonTerm StatementL
 -> Cxt NoHole (Sum PythonSig) (K ()) StatementL)
-> (Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL
    -> MPythonTerm StatementL)
-> Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL
-> Cxt NoHole (Sum PythonSig) (K ()) StatementL
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL
-> MPythonTerm StatementL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF) Cxt NoHole (Sum MPythonSig) (K ()) [BlockItemL]
ss

untransPyBlock :: MPythonTerm PyBlockL -> F.PythonTerm [F.StatementL]
untransPyBlock :: MPythonTerm PyBlockL -> CxtS NoHole PythonSig (K ()) [StatementL]
untransPyBlock (PyBlock' Cxt NoHole (Sum MPythonSig) (K ()) (Maybe PyStringLitL)
docStr MPythonTerm BlockL
body) = [Cxt NoHole (Sum PythonSig) (K ()) StatementL]
-> CxtS NoHole PythonSig (K ()) [StatementL]
forall l.
Typeable l =>
[Cxt NoHole (Sum PythonSig) (K ()) l]
-> Cxt NoHole (Sum PythonSig) (K ()) [l]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([Cxt NoHole (Sum PythonSig) (K ()) StatementL]
 -> CxtS NoHole PythonSig (K ()) [StatementL])
-> [Cxt NoHole (Sum PythonSig) (K ()) StatementL]
-> CxtS NoHole PythonSig (K ()) [StatementL]
forall a b. (a -> b) -> a -> b
$ [Cxt NoHole (Sum PythonSig) (K ()) StatementL]
docStrStmt [Cxt NoHole (Sum PythonSig) (K ()) StatementL]
-> [Cxt NoHole (Sum PythonSig) (K ()) StatementL]
-> [Cxt NoHole (Sum PythonSig) (K ()) StatementL]
forall a. [a] -> [a] -> [a]
++ (CxtS NoHole PythonSig (K ()) [StatementL]
-> [Cxt NoHole (Sum PythonSig) (K ()) StatementL]
forall l.
Cxt NoHole (Sum PythonSig) (K ()) [l]
-> [Cxt NoHole (Sum PythonSig) (K ()) l]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF (CxtS NoHole PythonSig (K ()) [StatementL]
 -> [Cxt NoHole (Sum PythonSig) (K ()) StatementL])
-> CxtS NoHole PythonSig (K ()) [StatementL]
-> [Cxt NoHole (Sum PythonSig) (K ()) StatementL]
forall a b. (a -> b) -> a -> b
$ MPythonTerm BlockL -> CxtS NoHole PythonSig (K ()) [StatementL]
untransBlock MPythonTerm BlockL
body)
  where
    docStrStmt :: [Cxt NoHole (Sum PythonSig) (K ()) StatementL]
docStrStmt = case Cxt NoHole (Sum MPythonSig) (K ()) (Maybe PyStringLitL)
docStr of
      Cxt NoHole (Sum MPythonSig) (K ()) (Maybe PyStringLitL)
Nothing' -> []
      Just' MPythonTerm PyStringLitL
lit -> [Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) StatementL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Statement :-<: fs, InjF fs StatementL j) =>
CxtS h fs a ExprL -> CxtS h fs a j
F.iStmtExpr (MPythonTerm PyStringLitL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL
untransPyStrLit MPythonTerm PyStringLitL
lit)]

instance {-# OVERLAPPING #-} Untrans PyClassIsStatement where
  untrans :: forall l.
PyClassIsStatement (Cxt NoHole (Sum MPythonSig) (K ())) l
-> PythonTerm l
untrans (PyClassIsStatement (MPythonTerm PyClassL
-> Maybe (PyClass (Cxt NoHole (Sum MPythonSig) (K ())) PyClassL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PyClass (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PyClass MPythonTerm IdentL
id Cxt NoHole (Sum MPythonSig) (K ()) [ArgumentL]
args MPythonTerm PyBlockL
body))) = PythonTerm IdentL
-> CxtS NoHole PythonSig (K ()) [ArgumentL]
-> CxtS NoHole PythonSig (K ()) [StatementL]
-> CxtS NoHole PythonSig (K ()) l
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Statement :-<: fs, InjF fs StatementL j) =>
CxtS h fs a IdentL
-> CxtS h fs a [ArgumentL]
-> CxtS h fs a [StatementL]
-> CxtS h fs a j
F.iClass (MPythonTerm IdentL -> PythonTerm IdentL
untransIdent MPythonTerm IdentL
id) (Cxt NoHole (Sum MPythonSig) (K ()) [ArgumentL]
-> CxtS NoHole PythonSig (K ()) [ArgumentL]
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) [ArgumentL]
args) (MPythonTerm PyBlockL -> CxtS NoHole PythonSig (K ()) [StatementL]
untransPyBlock MPythonTerm PyBlockL
body)

undoReassociateComp :: F.PythonTerm F.OpL -> F.PythonTerm F.ExprL -> F.PythonTerm F.ExprL -> F.PythonTerm F.ExprL
undoReassociateComp :: PythonTerm OpL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
undoReassociateComp PythonTerm OpL
outer_op Cxt NoHole (Sum PythonSig) (K ()) ExprL
outer_left (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Maybe (Expr (Cxt NoHole (Sum PythonSig) (K ())) ExprL)
NatM
  Maybe
  (Cxt NoHole (Sum PythonSig) (K ()))
  (Expr (Cxt NoHole (Sum PythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (F.BinaryOp PythonTerm OpL
inner_op Cxt NoHole (Sum PythonSig) (K ()) ExprL
inner_left Cxt NoHole (Sum PythonSig) (K ()) ExprL
right))) =
  PythonTerm OpL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a OpL
-> CxtS h fs a ExprL -> CxtS h fs a ExprL -> CxtS h fs a j
F.iBinaryOp PythonTerm OpL
inner_op (PythonTerm OpL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
undoReassociateComp PythonTerm OpL
outer_op Cxt NoHole (Sum PythonSig) (K ()) ExprL
outer_left Cxt NoHole (Sum PythonSig) (K ()) ExprL
inner_left) Cxt NoHole (Sum PythonSig) (K ()) ExprL
right
undoReassociateComp PythonTerm OpL
op Cxt NoHole (Sum PythonSig) (K ()) ExprL
left Cxt NoHole (Sum PythonSig) (K ()) ExprL
right = PythonTerm OpL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a OpL
-> CxtS h fs a ExprL -> CxtS h fs a ExprL -> CxtS h fs a j
F.iBinaryOp PythonTerm OpL
op Cxt NoHole (Sum PythonSig) (K ()) ExprL
left Cxt NoHole (Sum PythonSig) (K ()) ExprL
right

instance {-# OVERLAPPING #-} Untrans PyCompIsExpr where
  untrans :: forall l.
PyCompIsExpr (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
untrans (PyCompIsExpr (PyBaseComp' Cxt NoHole (Sum MPythonSig) (K ()) OpL
op Cxt NoHole (Sum MPythonSig) (K ()) ExprL
l Cxt NoHole (Sum MPythonSig) (K ()) ExprL
r)) = PythonTerm OpL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
undoReassociateComp (Cxt NoHole (Sum MPythonSig) (K ()) OpL -> PythonTerm OpL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) OpL
op) (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
l) (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
r)
  untrans (PyCompIsExpr (PyChainComp' Cxt NoHole (Sum MPythonSig) (K ()) OpL
op Cxt NoHole (Sum MPythonSig) (K ()) ExprL
l Cxt NoHole (Sum MPythonSig) (K ()) PyCompL
r)) = PythonTerm OpL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
undoReassociateComp (Cxt NoHole (Sum MPythonSig) (K ()) OpL -> PythonTerm OpL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) OpL
op) (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
l) (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
 -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig) (K ()) PyCompL
-> Cxt NoHole (Sum MPythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(PyCompIsExpr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a PyCompL -> CxtS h fs a j
iPyCompIsExpr Cxt NoHole (Sum MPythonSig) (K ()) PyCompL
r)

untransArg :: MPythonTerm FunctionArgumentL -> F.PythonTerm F.ArgumentL
untransArg :: MPythonTerm FunctionArgumentL -> PythonTerm ArgumentL
untransArg (PositionalArgument' Cxt NoHole (Sum MPythonSig) (K ()) PositionalArgExpL
e) = Cxt NoHole (Sum PythonSig) (K ()) ExprL -> PythonTerm ArgumentL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Argument :-<: fs, InjF fs ArgumentL j) =>
CxtS h fs a ExprL -> CxtS h fs a j
F.iArgExpr (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
 -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig) (K ()) PositionalArgExpL
-> Cxt NoHole (Sum MPythonSig) (K ()) ExprL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF Cxt NoHole (Sum MPythonSig) (K ()) PositionalArgExpL
e)
untransArg (MPythonTerm FunctionArgumentL
-> Maybe
     (PythonArg (Cxt NoHole (Sum MPythonSig) (K ())) FunctionArgumentL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PythonArg (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PythonArgSplat     Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e)) = Cxt NoHole (Sum PythonSig) (K ()) ExprL -> PythonTerm ArgumentL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Argument :-<: fs, InjF fs ArgumentL j) =>
CxtS h fs a ExprL -> CxtS h fs a j
F.iArgVarArgsPos (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e)
untransArg (MPythonTerm FunctionArgumentL
-> Maybe
     (PythonArg (Cxt NoHole (Sum MPythonSig) (K ())) FunctionArgumentL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PythonArg (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PythonArgKWSplat   Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e)) = Cxt NoHole (Sum PythonSig) (K ()) ExprL -> PythonTerm ArgumentL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Argument :-<: fs, InjF fs ArgumentL j) =>
CxtS h fs a ExprL -> CxtS h fs a j
F.iArgVarArgsKeyword (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e)
untransArg (MPythonTerm FunctionArgumentL
-> Maybe
     (PythonArg (Cxt NoHole (Sum MPythonSig) (K ())) FunctionArgumentL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PythonArg (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PythonArgKeyword MPythonTerm IdentL
n Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e)) = PythonTerm IdentL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL -> PythonTerm ArgumentL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Argument :-<: fs, InjF fs ArgumentL j) =>
CxtS h fs a IdentL -> CxtS h fs a ExprL -> CxtS h fs a j
F.iArgKeyword (MPythonTerm IdentL -> PythonTerm IdentL
untransIdent MPythonTerm IdentL
n) (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e)

instance {-# OVERLAPPING #-} Untrans FunctionCallIsExpr where
  untrans :: forall l.
FunctionCallIsExpr (Cxt NoHole (Sum MPythonSig) (K ())) l
-> PythonTerm l
untrans (FunctionCallIsExpr (FunctionCall' Cxt NoHole (Sum MPythonSig) (K ()) FunctionCallAttrsL
EmptyFunctionCallAttrs' Cxt NoHole (Sum MPythonSig) (K ()) FunctionExpL
f Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentsL
args)) = Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole PythonSig (K ()) [ArgumentL]
-> CxtS NoHole PythonSig (K ()) l
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a ExprL -> CxtS h fs a [ArgumentL] -> CxtS h fs a j
F.iCall Cxt NoHole (Sum PythonSig) (K ()) ExprL
lhs CxtS NoHole PythonSig (K ()) [ArgumentL]
args'
    where
      (Cxt NoHole (Sum PythonSig) (K ()) ExprL
lhs, CxtS NoHole PythonSig (K ()) [ArgumentL]
args') = case (Cxt NoHole (Sum MPythonSig) (K ()) FunctionExpL
f, Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentsL
args) of
                       (FunctionIdent' MPythonTerm IdentL
n, FunctionArgumentList' (ConsF' (ReceiverArg' Cxt NoHole (Sum MPythonSig) (K ()) ReceiverL
r) Cxt NoHole (Sum MPythonSig) (K ()) [FunctionArgumentL]
as)) -> ( Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> PythonTerm IdentL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a ExprL -> CxtS h fs a IdentL -> CxtS h fs a j
F.iDot (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
 -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig) (K ()) ReceiverL
-> Cxt NoHole (Sum MPythonSig) (K ()) ExprL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF Cxt NoHole (Sum MPythonSig) (K ()) ReceiverL
r) (MPythonTerm IdentL -> PythonTerm IdentL
untransIdent MPythonTerm IdentL
n)
                                                                                                 , (MPythonTerm FunctionArgumentL -> PythonTerm ArgumentL)
-> Cxt NoHole (Sum MPythonSig) (K ()) [FunctionArgumentL]
-> CxtS NoHole PythonSig (K ()) [ArgumentL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF MPythonTerm FunctionArgumentL -> PythonTerm ArgumentL
untransArg Cxt NoHole (Sum MPythonSig) (K ()) [FunctionArgumentL]
as)
                       (Cxt NoHole (Sum MPythonSig) (K ()) FunctionExpL
e, FunctionArgumentList' Cxt NoHole (Sum MPythonSig) (K ()) [FunctionArgumentL]
as) -> (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
 -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig) (K ()) FunctionExpL
-> Cxt NoHole (Sum MPythonSig) (K ()) ExprL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF Cxt NoHole (Sum MPythonSig) (K ()) FunctionExpL
e, (MPythonTerm FunctionArgumentL -> PythonTerm ArgumentL)
-> Cxt NoHole (Sum MPythonSig) (K ()) [FunctionArgumentL]
-> CxtS NoHole PythonSig (K ()) [ArgumentL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF MPythonTerm FunctionArgumentL -> PythonTerm ArgumentL
untransArg Cxt NoHole (Sum MPythonSig) (K ()) [FunctionArgumentL]
as)

insertString :: String -> F.PythonTerm [CharL]
insertString :: String -> PythonTerm [CharL]
insertString String
str = [Cxt NoHole (Sum PythonSig) (K ()) CharL] -> PythonTerm [CharL]
forall l.
Typeable l =>
[Cxt NoHole (Sum PythonSig) (K ()) l]
-> Cxt NoHole (Sum PythonSig) (K ()) [l]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([Cxt NoHole (Sum PythonSig) (K ()) CharL] -> PythonTerm [CharL])
-> [Cxt NoHole (Sum PythonSig) (K ()) CharL] -> PythonTerm [CharL]
forall a b. (a -> b) -> a -> b
$ (Char -> Cxt NoHole (Sum PythonSig) (K ()) CharL)
-> String -> [Cxt NoHole (Sum PythonSig) (K ()) CharL]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Cxt NoHole (Sum PythonSig) (K ()) CharL
forall h (f :: Fragment) (a :: * -> *) j.
(CharF :<: f) =>
Char -> Cxt h f a CharL
CharF' String
str

insertStrings :: [String] -> F.PythonTerm [[CharL]]
insertStrings :: [String] -> CxtS NoHole PythonSig (K ()) [[CharL]]
insertStrings [String]
strs = [PythonTerm [CharL]] -> CxtS NoHole PythonSig (K ()) [[CharL]]
forall l.
Typeable l =>
[Cxt NoHole (Sum PythonSig) (K ()) l]
-> Cxt NoHole (Sum PythonSig) (K ()) [l]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([PythonTerm [CharL]] -> CxtS NoHole PythonSig (K ()) [[CharL]])
-> [PythonTerm [CharL]] -> CxtS NoHole PythonSig (K ()) [[CharL]]
forall a b. (a -> b) -> a -> b
$ (String -> PythonTerm [CharL]) -> [String] -> [PythonTerm [CharL]]
forall a b. (a -> b) -> [a] -> [b]
map String -> PythonTerm [CharL]
insertString [String]
strs

untransParam :: MPythonTerm FunctionParameterL -> F.PythonTerm F.ParameterL
untransParam :: MPythonTerm FunctionParameterL -> PythonTerm ParameterL
untransParam (PositionalParameter' (PyParamAttrs'     Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
ann Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
def) MPythonTerm IdentL
n) = PythonTerm IdentL
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> PythonTerm ParameterL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Parameter :-<: fs, InjF fs ParameterL j) =>
CxtS h fs a IdentL
-> CxtS h fs a (Maybe ExprL)
-> CxtS h fs a (Maybe ExprL)
-> CxtS h fs a j
F.iParam          (MPythonTerm IdentL -> PythonTerm IdentL
untransIdent MPythonTerm IdentL
n) (Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
ann) (Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
def)
untransParam (MPythonTerm FunctionParameterL
-> Maybe
     (PythonParam
        (Cxt NoHole (Sum MPythonSig) (K ())) FunctionParameterL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PythonParam (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PythonParamVarArgs   MPythonTerm IdentL
n Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
ann))       = PythonTerm IdentL
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> PythonTerm ParameterL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Parameter :-<: fs, InjF fs ParameterL j) =>
CxtS h fs a IdentL -> CxtS h fs a (Maybe ExprL) -> CxtS h fs a j
F.iVarArgsPos     (MPythonTerm IdentL -> PythonTerm IdentL
untransIdent MPythonTerm IdentL
n) (Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
ann)
untransParam (MPythonTerm FunctionParameterL
-> Maybe
     (PythonParam
        (Cxt NoHole (Sum MPythonSig) (K ())) FunctionParameterL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PythonParam (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PythonParamVarArgsKW MPythonTerm IdentL
n Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
ann))       = PythonTerm IdentL
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> PythonTerm ParameterL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Parameter :-<: fs, InjF fs ParameterL j) =>
CxtS h fs a IdentL -> CxtS h fs a (Maybe ExprL) -> CxtS h fs a j
F.iVarArgsKeyword (MPythonTerm IdentL -> PythonTerm IdentL
untransIdent MPythonTerm IdentL
n) (Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
ann)
untransParam (MPythonTerm FunctionParameterL
-> Maybe
     (PythonParam
        (Cxt NoHole (Sum MPythonSig) (K ())) FunctionParameterL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PythonParam (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PythonParamUnpackTuple Cxt NoHole (Sum MPythonSig) (K ()) ParamTupleL
pt Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
ann))    = CxtS NoHole PythonSig (K ()) ParamTupleL
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> PythonTerm ParameterL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Parameter :-<: fs, InjF fs ParameterL j) =>
CxtS h fs a ParamTupleL
-> CxtS h fs a (Maybe ExprL) -> CxtS h fs a j
F.iUnPackTuple (Cxt NoHole (Sum MPythonSig) (K ()) ParamTupleL
-> CxtS NoHole PythonSig (K ()) ParamTupleL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ParamTupleL
pt) (Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
ann)
untransParam (MPythonTerm FunctionParameterL
-> Maybe
     (PythonParam
        (Cxt NoHole (Sum MPythonSig) (K ())) FunctionParameterL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PythonParam (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PythonParam (Cxt NoHole (Sum MPythonSig) (K ())) FunctionParameterL
PythonEndPosParam))                = PythonTerm ParameterL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Parameter :-<: fs, InjF fs ParameterL j) =>
CxtS h fs a j
F.iEndPositional


instance {-# OVERLAPPING #-} Untrans FunctionDefIsStatement where
  untrans :: forall l.
FunctionDefIsStatement (Cxt NoHole (Sum MPythonSig) (K ())) l
-> PythonTerm l
untrans (FunctionDefIsStatement (FunctionDef' (PyFunDefAttrs' Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
ann) MPythonTerm IdentL
n Cxt NoHole (Sum MPythonSig) (K ()) [FunctionParameterL]
params Cxt NoHole (Sum MPythonSig) (K ()) FunctionBodyL
body)) = PythonTerm IdentL
-> CxtS NoHole PythonSig (K ()) [ParameterL]
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> CxtS NoHole PythonSig (K ()) [StatementL]
-> CxtS NoHole PythonSig (K ()) l
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Statement :-<: fs, InjF fs StatementL j) =>
CxtS h fs a IdentL
-> CxtS h fs a [ParameterL]
-> CxtS h fs a (Maybe ExprL)
-> CxtS h fs a [StatementL]
-> CxtS h fs a j
F.iFun (MPythonTerm IdentL -> PythonTerm IdentL
untransIdent MPythonTerm IdentL
n) ((MPythonTerm FunctionParameterL -> PythonTerm ParameterL)
-> Cxt NoHole (Sum MPythonSig) (K ()) [FunctionParameterL]
-> CxtS NoHole PythonSig (K ()) [ParameterL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF MPythonTerm FunctionParameterL -> PythonTerm ParameterL
untransParam Cxt NoHole (Sum MPythonSig) (K ()) [FunctionParameterL]
params) (Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) (Maybe ExprL)
ann) (MPythonTerm PyBlockL -> CxtS NoHole PythonSig (K ()) [StatementL]
untransPyBlock (MPythonTerm PyBlockL -> CxtS NoHole PythonSig (K ()) [StatementL])
-> MPythonTerm PyBlockL
-> CxtS NoHole PythonSig (K ()) [StatementL]
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MPythonSig) (K ()) FunctionBodyL
-> MPythonTerm PyBlockL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF Cxt NoHole (Sum MPythonSig) (K ()) FunctionBodyL
body)

instance {-# OVERLAPPING #-} Untrans PyCondExpr where
  untrans :: forall l.
PyCondExpr (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
untrans (PyCondExpr Cxt NoHole (Sum MPythonSig) (K ()) ExprL
c Cxt NoHole (Sum MPythonSig) (K ()) ExprL
t Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e) = Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole PythonSig (K ()) l
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a ExprL
-> CxtS h fs a ExprL -> CxtS h fs a ExprL -> CxtS h fs a j
F.iCondExpr (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
t) (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
c) (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e)

instance {-# OVERLAPPING #-} Untrans PyComprehensionExpr where
  untrans :: forall l.
PyComprehensionExpr (Cxt NoHole (Sum MPythonSig) (K ())) l
-> PythonTerm l
untrans (PyListComprehension MPythonTerm PyComprehensionL
c) = CxtS NoHole PythonSig (K ()) ComprehensionL
-> CxtS NoHole PythonSig (K ()) l
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a ComprehensionL -> CxtS h fs a j
F.iListComp (MPythonTerm PyComprehensionL
-> CxtS NoHole PythonSig (K ()) ComprehensionL
untransComprehension MPythonTerm PyComprehensionL
c)
  untrans (PyDictComprehension MPythonTerm PyComprehensionL
c) = CxtS NoHole PythonSig (K ()) ComprehensionL
-> CxtS NoHole PythonSig (K ()) l
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a ComprehensionL -> CxtS h fs a j
F.iDictComp (MPythonTerm PyComprehensionL
-> CxtS NoHole PythonSig (K ()) ComprehensionL
untransComprehension MPythonTerm PyComprehensionL
c)
  untrans (PySetComprehension MPythonTerm PyComprehensionL
c) = CxtS NoHole PythonSig (K ()) ComprehensionL
-> CxtS NoHole PythonSig (K ()) l
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a ComprehensionL -> CxtS h fs a j
F.iSetComp (MPythonTerm PyComprehensionL
-> CxtS NoHole PythonSig (K ()) ComprehensionL
untransComprehension MPythonTerm PyComprehensionL
c)

-- instance {-# OVERLAPPING #-} Untrans PyComprehension where
--   untrans = untransComprehension

untransComprehension :: MPythonTerm PyComprehensionL -> F.PythonTerm F.ComprehensionL
untransComprehension :: MPythonTerm PyComprehensionL
-> CxtS NoHole PythonSig (K ()) ComprehensionL
untransComprehension MPythonTerm PyComprehensionL
t =
  let (PythonTerm ComprehensionExprL
expr, PythonTerm CompForL
comp) = MPythonTerm PyComprehensionL
-> (PythonTerm ComprehensionExprL, PythonTerm CompForL)
untransComprehension0 MPythonTerm PyComprehensionL
t
  in  PythonTerm ComprehensionExprL
-> PythonTerm CompForL
-> CxtS NoHole PythonSig (K ()) ComprehensionL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Comprehension :-<: fs, InjF fs ComprehensionL j) =>
CxtS h fs a ComprehensionExprL
-> CxtS h fs a CompForL -> CxtS h fs a j
F.iComprehension PythonTerm ComprehensionExprL
expr PythonTerm CompForL
comp

  where untransComprehension0 :: MPythonTerm PyComprehensionL -> (F.PythonTerm F.ComprehensionExprL, F.PythonTerm F.CompForL)
        untransComprehension0 :: MPythonTerm PyComprehensionL
-> (PythonTerm ComprehensionExprL, PythonTerm CompForL)
untransComprehension0 (MPythonTerm PyComprehensionL
-> Maybe
     (PyComprehension
        (Cxt NoHole (Sum MPythonSig) (K ())) PyComprehensionL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PyComprehension (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PyComprehensionFor Bool
b Cxt NoHole (Sum MPythonSig) (K ()) [ExprL]
es Cxt NoHole (Sum MPythonSig) (K ()) ExprL
v MPythonTerm PyComprehensionL
comp)) =
          CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
-> PythonTerm CompForL
compFor (CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
 -> PythonTerm CompForL)
-> (PythonTerm ComprehensionExprL,
    CxtS NoHole PythonSig (K ()) (Maybe CompIterL))
-> (PythonTerm ComprehensionExprL, PythonTerm CompForL)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MPythonTerm PyComprehensionL
-> (PythonTerm ComprehensionExprL,
    CxtS NoHole PythonSig (K ()) (Maybe CompIterL))
go MPythonTerm PyComprehensionL
comp

          where compFor :: CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
-> PythonTerm CompForL
compFor CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
mIter = Bool
-> CxtS NoHole PythonSig (K ()) [ExprL]
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
-> PythonTerm CompForL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(CompFor :-<: fs, InjF fs CompForL j) =>
Bool
-> CxtS h fs a [ExprL]
-> CxtS h fs a ExprL
-> CxtS h fs a (Maybe CompIterL)
-> CxtS h fs a j
F.iCompFor Bool
b ((Cxt NoHole (Sum MPythonSig) (K ()) ExprL
 -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> Cxt NoHole (Sum MPythonSig) (K ()) [ExprL]
-> CxtS NoHole PythonSig (K ()) [ExprL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) [ExprL]
es) (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
v) CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
mIter

        go :: MPythonTerm PyComprehensionL -> (F.PythonTerm F.ComprehensionExprL, F.PythonTerm (Maybe F.CompIterL))
        go :: MPythonTerm PyComprehensionL
-> (PythonTerm ComprehensionExprL,
    CxtS NoHole PythonSig (K ()) (Maybe CompIterL))
go (MPythonTerm PyComprehensionL
-> Maybe
     (PyComprehension
        (Cxt NoHole (Sum MPythonSig) (K ())) PyComprehensionL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PyComprehension (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PyComprehensionFor Bool
b Cxt NoHole (Sum MPythonSig) (K ()) [ExprL]
es Cxt NoHole (Sum MPythonSig) (K ()) ExprL
v MPythonTerm PyComprehensionL
comp)) =
          CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
-> CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
iterFor (CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
 -> CxtS NoHole PythonSig (K ()) (Maybe CompIterL))
-> (PythonTerm ComprehensionExprL,
    CxtS NoHole PythonSig (K ()) (Maybe CompIterL))
-> (PythonTerm ComprehensionExprL,
    CxtS NoHole PythonSig (K ()) (Maybe CompIterL))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MPythonTerm PyComprehensionL
-> (PythonTerm ComprehensionExprL,
    CxtS NoHole PythonSig (K ()) (Maybe CompIterL))
go MPythonTerm PyComprehensionL
comp
          
          where iterFor :: CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
-> CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
iterFor CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
mIter =
                  let compFor :: PythonTerm CompForL
compFor = Bool
-> CxtS NoHole PythonSig (K ()) [ExprL]
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
-> PythonTerm CompForL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(CompFor :-<: fs, InjF fs CompForL j) =>
Bool
-> CxtS h fs a [ExprL]
-> CxtS h fs a ExprL
-> CxtS h fs a (Maybe CompIterL)
-> CxtS h fs a j
F.iCompFor Bool
b ((Cxt NoHole (Sum MPythonSig) (K ()) ExprL
 -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> Cxt NoHole (Sum MPythonSig) (K ()) [ExprL]
-> CxtS NoHole PythonSig (K ()) [ExprL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) [ExprL]
es) (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
v) CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
mIter
                  in  Cxt NoHole (Sum PythonSig) (K ()) CompIterL
-> CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
forall (f :: Fragment) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a l -> Cxt h f a (Maybe l)
Just' (PythonTerm CompForL -> Cxt NoHole (Sum PythonSig) (K ()) CompIterL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(CompIter :-<: fs, InjF fs CompIterL j) =>
CxtS h fs a CompForL -> CxtS h fs a j
F.iIterFor PythonTerm CompForL
compFor)
          
        go (MPythonTerm PyComprehensionL
-> Maybe
     (PyComprehension
        (Cxt NoHole (Sum MPythonSig) (K ())) PyComprehensionL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PyComprehension (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PyComprehensionIf Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e MPythonTerm PyComprehensionL
comp)) =
          CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
-> CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
iterIf (CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
 -> CxtS NoHole PythonSig (K ()) (Maybe CompIterL))
-> (PythonTerm ComprehensionExprL,
    CxtS NoHole PythonSig (K ()) (Maybe CompIterL))
-> (PythonTerm ComprehensionExprL,
    CxtS NoHole PythonSig (K ()) (Maybe CompIterL))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MPythonTerm PyComprehensionL
-> (PythonTerm ComprehensionExprL,
    CxtS NoHole PythonSig (K ()) (Maybe CompIterL))
go MPythonTerm PyComprehensionL
comp

          where iterIf :: CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
-> CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
iterIf CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
mIter =
                  let compIf :: CxtS NoHole PythonSig (K ()) CompIfL
compIf = Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
-> CxtS NoHole PythonSig (K ()) CompIfL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(CompIf :-<: fs, InjF fs CompIfL j) =>
CxtS h fs a ExprL -> CxtS h fs a (Maybe CompIterL) -> CxtS h fs a j
F.iCompIf (Cxt NoHole (Sum MPythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ExprL
e) CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
mIter
                  in Cxt NoHole (Sum PythonSig) (K ()) CompIterL
-> CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
forall (f :: Fragment) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a l -> Cxt h f a (Maybe l)
Just' (CxtS NoHole PythonSig (K ()) CompIfL
-> Cxt NoHole (Sum PythonSig) (K ()) CompIterL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(CompIter :-<: fs, InjF fs CompIterL j) =>
CxtS h fs a CompIfL -> CxtS h fs a j
F.iIterIf CxtS NoHole PythonSig (K ()) CompIfL
compIf)

        go (MPythonTerm PyComprehensionL
-> Maybe
     (PyComprehension
        (Cxt NoHole (Sum MPythonSig) (K ())) PyComprehensionL)
NatM
  Maybe
  (Cxt NoHole (Sum MPythonSig) (K ()))
  (PyComprehension (Cxt NoHole (Sum MPythonSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PyComprehensionBody Cxt NoHole (Sum MPythonSig) (K ()) ComprehensionExprL
b)) =
          (Cxt NoHole (Sum MPythonSig) (K ()) ComprehensionExprL
-> PythonTerm ComprehensionExprL
Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate Cxt NoHole (Sum MPythonSig) (K ()) ComprehensionExprL
b, CxtS NoHole PythonSig (K ()) (Maybe CompIterL)
forall (f :: Fragment) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a (Maybe l)
Nothing')

untranslate :: MPythonTerm l -> F.PythonTerm l
untranslate :: Cxt NoHole (Sum MPythonSig) (K ())
:-> Cxt NoHole (Sum PythonSig) (K ())
untranslate = Sum MPythonSig (Cxt NoHole (Sum MPythonSig) (K ())) l
-> PythonTerm l
forall l.
Sum MPythonSig (Cxt NoHole (Sum MPythonSig) (K ())) l
-> PythonTerm l
forall (f :: Fragment) l.
Untrans f =>
f (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
untrans (Sum MPythonSig (Cxt NoHole (Sum MPythonSig) (K ())) l
 -> PythonTerm l)
-> (MPythonTerm l
    -> Sum MPythonSig (Cxt NoHole (Sum MPythonSig) (K ())) l)
-> MPythonTerm l
-> PythonTerm l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MPythonTerm l
-> Sum MPythonSig (Cxt NoHole (Sum MPythonSig) (K ())) l
forall (f :: Fragment) t. HFix f t -> f (HFix f) t
unTerm

#endif