{-# OPTIONS_HADDOCK hide #-}
{-# LANGUAGE CPP                    #-}
{-# LANGUAGE DataKinds              #-}
{-# LANGUAGE FlexibleContexts       #-}
{-# LANGUAGE FlexibleInstances      #-}
{-# LANGUAGE GADTs                  #-}
{-# LANGUAGE KindSignatures         #-}
{-# LANGUAGE MultiParamTypeClasses  #-}
{-# LANGUAGE PartialTypeSignatures  #-}
{-# LANGUAGE ScopedTypeVariables    #-}
{-# LANGUAGE ViewPatterns           #-}
{-# LANGUAGE TemplateHaskell        #-}
{-# LANGUAGE TypeApplications       #-}
{-# LANGUAGE TypeOperators          #-}
{-# 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.List( (\\) )
import Data.Proxy
import Language.Haskell.TH.Syntax ( Type(ConT), Exp(VarE) )

import Data.Comp.Multi ( project, inject, unTerm, 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

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

translate :: F.PythonTerm l -> MPythonTerm l
translate :: PythonTerm l -> MPythonTerm l
translate = Sum PythonSig PythonTerm l -> MPythonTerm l
forall (f :: (* -> *) -> * -> *) l.
Trans f =>
f PythonTerm l -> MPythonTerm l
trans (Sum PythonSig PythonTerm l -> MPythonTerm l)
-> (PythonTerm l -> Sum PythonSig PythonTerm l)
-> PythonTerm l
-> MPythonTerm l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PythonTerm l -> Sum PythonSig PythonTerm l
forall (f :: (* -> *) -> * -> *) t. HFix f t -> f (HFix f) t
unTerm

translate' :: (InjF MPythonSig l l') => F.PythonTerm l -> MPythonTerm l'
translate' :: PythonTerm l -> MPythonTerm l'
translate' = CxtS NoHole MPythonSig (K ()) l -> MPythonTerm l'
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MPythonSig (K ()) l -> MPythonTerm l')
-> (PythonTerm l -> CxtS NoHole MPythonSig (K ()) l)
-> PythonTerm l
-> MPythonTerm l'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PythonTerm l -> CxtS NoHole MPythonSig (K ()) l
forall l. PythonTerm l -> MPythonTerm l
translate

class Trans f where
  trans :: f F.PythonTerm l -> MPythonTerm l

instance {-# OVERLAPPING #-} (All Trans fs) => Trans (Sum fs) where
  trans :: Sum fs PythonTerm l -> MPythonTerm l
trans = Proxy Trans
-> (forall (f :: (* -> *) -> * -> *).
    Trans f =>
    f PythonTerm l -> MPythonTerm l)
-> Sum fs PythonTerm l
-> MPythonTerm l
forall (cxt :: ((* -> *) -> * -> *) -> Constraint)
       (fs :: [(* -> *) -> * -> *]) (a :: * -> *) e b.
All cxt fs =>
Proxy cxt
-> (forall (f :: (* -> *) -> * -> *). cxt f => f a e -> b)
-> Sum fs a e
-> b
caseCxt (Proxy Trans
forall k (t :: k). Proxy t
Proxy @Trans) forall (f :: (* -> *) -> * -> *).
Trans f =>
f PythonTerm l -> MPythonTerm l
forall (f :: (* -> *) -> * -> *) l.
Trans f =>
f PythonTerm l -> MPythonTerm l
trans

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

instance {-# OVERLAPPABLE #-} (HFunctor f, f :-<: MPythonSig, f :-<: F.PythonSig) => Trans f where
  trans :: f PythonTerm l -> MPythonTerm l
trans = f PythonTerm l -> MPythonTerm l
forall (f :: (* -> *) -> * -> *) l.
(HFunctor f, f :-<: MPythonSig, f :-<: PythonSig) =>
f PythonTerm l -> MPythonTerm l
transDefault


transIdent :: F.PythonTerm F.IdentL -> MPythonTerm IdentL
transIdent :: PythonTerm IdentL -> MPythonTerm IdentL
transIdent (PythonTerm IdentL -> Maybe (Ident PythonTerm IdentL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Ident s :: String
s _)) = String -> MPythonTerm IdentL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Ident :-<: fs, InjF fs IdentL j) =>
String -> CxtS h fs a j
iIdent String
s

instance Trans F.Ident where
  trans :: Ident PythonTerm l -> MPythonTerm l
trans (F.Ident s :: String
s _) = MPythonTerm IdentL -> MPythonTerm l
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MPythonTerm IdentL -> MPythonTerm l)
-> MPythonTerm IdentL -> MPythonTerm l
forall a b. (a -> b) -> a -> b
$ String -> MPythonTerm IdentL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(Ident :-<: fs, All HFunctor fs) =>
String -> CxtS h fs a IdentL
Ident' String
s

transArgs :: F.PythonTerm [F.ArgumentL] -> MPythonTerm [FunctionArgumentL]
transArgs :: PythonTerm [ArgumentL] -> MPythonTerm [FunctionArgumentL]
transArgs = (Cxt NoHole (Sum PythonSig) (K ()) ArgumentL
 -> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL)
-> PythonTerm [ArgumentL] -> MPythonTerm [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) (K ()) ArgumentL
-> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL
transArg
  where
    transArg :: F.PythonTerm F.ArgumentL -> MPythonTerm FunctionArgumentL
    transArg :: Cxt NoHole (Sum PythonSig) (K ()) ArgumentL
-> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL
transArg (Cxt NoHole (Sum PythonSig) (K ()) ArgumentL
-> Maybe (Argument PythonTerm ArgumentL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.ArgExpr           e :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
e _)) = CxtS NoHole MPythonSig (K ()) PositionalArgExpL
-> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(PositionalArgument :-<: fs, All HFunctor fs) =>
CxtS h fs a PositionalArgExpL -> CxtS h fs a FunctionArgumentL
PositionalArgument' (CxtS NoHole MPythonSig (K ()) PositionalArgExpL
 -> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL)
-> CxtS NoHole MPythonSig (K ()) PositionalArgExpL
-> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) PositionalArgExpL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MPythonSig (K ()) ExprL
 -> CxtS NoHole MPythonSig (K ()) PositionalArgExpL)
-> CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) PositionalArgExpL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
e
    transArg (Cxt NoHole (Sum PythonSig) (K ()) ArgumentL
-> Maybe (Argument PythonTerm ArgumentL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.ArgVarArgsPos     e :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
e _)) = CxtS NoHole MPythonSig (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PythonArg :-<: fs, InjF fs FunctionArgumentL j) =>
CxtS h fs a ExprL -> CxtS h fs a j
iPythonArgSplat (CxtS NoHole MPythonSig (K ()) ExprL
 -> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL)
-> CxtS NoHole MPythonSig (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
e
    transArg (Cxt NoHole (Sum PythonSig) (K ()) ArgumentL
-> Maybe (Argument PythonTerm ArgumentL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.ArgVarArgsKeyword e :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
e _)) = CxtS NoHole MPythonSig (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PythonArg :-<: fs, InjF fs FunctionArgumentL j) =>
CxtS h fs a ExprL -> CxtS h fs a j
iPythonArgKWSplat (CxtS NoHole MPythonSig (K ()) ExprL
 -> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL)
-> CxtS NoHole MPythonSig (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate  Cxt NoHole (Sum PythonSig) (K ()) ExprL
e
    transArg (Cxt NoHole (Sum PythonSig) (K ()) ArgumentL
-> Maybe (Argument PythonTerm ArgumentL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.ArgKeyword      n :: PythonTerm IdentL
n e :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
e _)) = MPythonTerm IdentL
-> CxtS NoHole MPythonSig (K ()) ExprL
-> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PythonArg :-<: fs, InjF fs FunctionArgumentL j) =>
CxtS h fs a IdentL -> CxtS h fs a ExprL -> CxtS h fs a j
iPythonArgKeyword (PythonTerm IdentL -> MPythonTerm IdentL
transIdent PythonTerm IdentL
n) (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
e)

isCompOp :: F.PythonTerm F.OpL -> Bool
isCompOp :: PythonTerm OpL -> Bool
isCompOp (PythonTerm OpL -> Maybe (Op PythonTerm OpL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (F.LessThan _)))          = Bool
True
isCompOp (PythonTerm OpL -> Maybe (Op PythonTerm OpL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (F.LessThanEquals _)))    = Bool
True
isCompOp (PythonTerm OpL -> Maybe (Op PythonTerm OpL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (F.GreaterThan _)))       = Bool
True
isCompOp (PythonTerm OpL -> Maybe (Op PythonTerm OpL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (F.GreaterThanEquals _))) = Bool
True
isCompOp (PythonTerm OpL -> Maybe (Op PythonTerm OpL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (F.Equality _)))          = Bool
True
isCompOp (PythonTerm OpL -> Maybe (Op PythonTerm OpL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (F.NotEquals _)))         = Bool
True
isCompOp (PythonTerm OpL -> Maybe (Op PythonTerm OpL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (F.In _)))                = Bool
True
isCompOp (PythonTerm OpL -> Maybe (Op PythonTerm OpL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (F.Is _)))                = Bool
True
isCompOp (PythonTerm OpL -> Maybe (Op PythonTerm OpL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (F.IsNot _)))             = Bool
True
isCompOp (PythonTerm OpL -> Maybe (Op PythonTerm OpL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (F.NotIn _)))             = Bool
True
isCompOp _                                           = 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)".
reassociateComp :: F.PythonTerm F.OpL -> F.PythonTerm F.ExprL -> F.PythonTerm F.ExprL -> MPythonTerm F.ExprL
reassociateComp :: PythonTerm OpL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
reassociateComp op :: PythonTerm OpL
op l :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
l r :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
r = CxtS NoHole MPythonSig (K ()) PyCompL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MPythonSig (K ()) PyCompL
 -> CxtS NoHole MPythonSig (K ()) ExprL)
-> CxtS NoHole MPythonSig (K ()) PyCompL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MPythonSig (K ()) OpL
-> CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) PyCompL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(KnownNat (Position PyCompIsExpr fs),
 KnownNat (Position PyComp fs), All HFunctor fs) =>
CxtS h fs a OpL
-> Cxt h (Sum fs) a ExprL
-> Cxt h (Sum fs) a ExprL
-> CxtS h fs a PyCompL
reassociate (PythonTerm OpL -> CxtS NoHole MPythonSig (K ()) OpL
forall l. PythonTerm l -> MPythonTerm l
translate PythonTerm OpL
op) (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
l) (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
r)
  where
    reassociate :: CxtS h fs a OpL
-> Cxt h (Sum fs) a ExprL
-> Cxt h (Sum fs) a ExprL
-> CxtS h fs a PyCompL
reassociate outer_op :: CxtS h fs a OpL
outer_op (Cxt h (Sum fs) a ExprL
-> Maybe (PyCompIsExpr (Cxt h (Sum fs) a) ExprL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (PyCompIsExpr (PyChainComp' inner_op left inner_right)))) outer_right :: Cxt h (Sum fs) a ExprL
outer_right =
      CxtS h fs a OpL
-> Cxt h (Sum fs) a ExprL
-> CxtS h fs a PyCompL
-> CxtS h fs a PyCompL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyComp :-<: fs, InjF fs PyCompL j) =>
CxtS h fs a OpL
-> CxtS h fs a ExprL -> CxtS h fs a PyCompL -> CxtS h fs a j
iPyChainComp CxtS h fs a OpL
inner_op Cxt h (Sum fs) a ExprL
left (CxtS h fs a OpL
-> Cxt h (Sum fs) a ExprL
-> Cxt h (Sum fs) a ExprL
-> CxtS h fs a PyCompL
reassociate CxtS h fs a OpL
outer_op (CxtS h fs a PyCompL -> Cxt h (Sum fs) a ExprL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF CxtS h fs a PyCompL
inner_right) Cxt h (Sum fs) a ExprL
outer_right)
    reassociate outer_op :: CxtS h fs a OpL
outer_op (Cxt h (Sum fs) a ExprL
-> Maybe (PyCompIsExpr (Cxt h (Sum fs) a) ExprL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (PyCompIsExpr (PyBaseComp' inner_op left inner_right)))) outer_right :: Cxt h (Sum fs) a ExprL
outer_right =
      CxtS h fs a OpL
-> Cxt h (Sum fs) a ExprL
-> CxtS h fs a PyCompL
-> CxtS h fs a PyCompL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyComp :-<: fs, InjF fs PyCompL j) =>
CxtS h fs a OpL
-> CxtS h fs a ExprL -> CxtS h fs a PyCompL -> CxtS h fs a j
iPyChainComp CxtS h fs a OpL
inner_op Cxt h (Sum fs) a ExprL
left (CxtS h fs a OpL
-> Cxt h (Sum fs) a ExprL
-> Cxt h (Sum fs) a ExprL
-> CxtS h fs a PyCompL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyComp :-<: fs, InjF fs PyCompL j) =>
CxtS h fs a OpL
-> CxtS h fs a ExprL -> CxtS h fs a ExprL -> CxtS h fs a j
iPyBaseComp CxtS h fs a OpL
outer_op Cxt h (Sum fs) a ExprL
inner_right Cxt h (Sum fs) a ExprL
outer_right)
    reassociate op :: CxtS h fs a OpL
op left :: Cxt h (Sum fs) a ExprL
left right :: Cxt h (Sum fs) a ExprL
right = CxtS h fs a OpL
-> Cxt h (Sum fs) a ExprL
-> Cxt h (Sum fs) a ExprL
-> CxtS h fs a PyCompL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyComp :-<: fs, InjF fs PyCompL j) =>
CxtS h fs a OpL
-> CxtS h fs a ExprL -> CxtS h fs a ExprL -> CxtS h fs a j
iPyBaseComp CxtS h fs a OpL
op Cxt h (Sum fs) a ExprL
left Cxt h (Sum fs) a 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 :: Expr PythonTerm l -> MPythonTerm l
trans (F.Call f :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
f args :: PythonTerm [ArgumentL]
args _) = CxtS NoHole MPythonSig (K ()) FunctionCallAttrsL
-> CxtS NoHole MPythonSig (K ()) FunctionExpL
-> CxtS NoHole MPythonSig (K ()) FunctionArgumentsL
-> MPythonTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunctionCall :-<: fs, InjF fs FunctionCallL j) =>
CxtS h fs a FunctionCallAttrsL
-> CxtS h fs a FunctionExpL
-> CxtS h fs a FunctionArgumentsL
-> CxtS h fs a j
iFunctionCall CxtS NoHole MPythonSig (K ()) FunctionCallAttrsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(EmptyFunctionCallAttrs :-<: fs, All HFunctor fs) =>
CxtS h fs a FunctionCallAttrsL
EmptyFunctionCallAttrs' CxtS NoHole MPythonSig (K ()) FunctionExpL
fun (MPythonTerm [FunctionArgumentL]
-> CxtS NoHole MPythonSig (K ()) FunctionArgumentsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(FunctionArgumentList :-<: fs, All HFunctor fs) =>
CxtS h fs a [FunctionArgumentL] -> CxtS h fs a FunctionArgumentsL
FunctionArgumentList' MPythonTerm [FunctionArgumentL]
args')
    where
      (fun :: CxtS NoHole MPythonSig (K ()) FunctionExpL
fun, args' :: MPythonTerm [FunctionArgumentL]
args') = case Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Maybe (Expr PythonTerm ExprL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project Cxt NoHole (Sum PythonSig) (K ()) ExprL
f of
        Just (F.Dot l :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
l n :: PythonTerm IdentL
n _) -> (MPythonTerm IdentL -> CxtS NoHole MPythonSig (K ()) FunctionExpL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunctionIdent :-<: fs, InjF fs FunctionExpL j) =>
CxtS h fs a IdentL -> CxtS h fs a j
iFunctionIdent (PythonTerm IdentL -> MPythonTerm IdentL
transIdent PythonTerm IdentL
n), Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL
-> MPythonTerm [FunctionArgumentL]
-> MPythonTerm [FunctionArgumentL]
forall (f :: (* -> *) -> * -> *) l h (a :: * -> *).
(ListF :<: f, Typeable l, HFunctor f) =>
Cxt h f a l -> Cxt h f a [l] -> Cxt h f a [l]
ConsF' (CxtS NoHole MPythonSig (K ()) ReceiverL
-> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(ReceiverArg :-<: fs, All HFunctor fs) =>
CxtS h fs a ReceiverL -> CxtS h fs a FunctionArgumentL
ReceiverArg' (CxtS NoHole MPythonSig (K ()) ReceiverL
 -> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL)
-> CxtS NoHole MPythonSig (K ()) ReceiverL
-> Cxt NoHole (Sum MPythonSig) (K ()) FunctionArgumentL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ReceiverL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MPythonSig (K ()) ExprL
 -> CxtS NoHole MPythonSig (K ()) ReceiverL)
-> CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ReceiverL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
l) (PythonTerm [ArgumentL] -> MPythonTerm [FunctionArgumentL]
transArgs PythonTerm [ArgumentL]
args))
        _                  -> (CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) FunctionExpL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MPythonSig (K ()) ExprL
 -> CxtS NoHole MPythonSig (K ()) FunctionExpL)
-> CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) FunctionExpL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
f, PythonTerm [ArgumentL] -> MPythonTerm [FunctionArgumentL]
transArgs PythonTerm [ArgumentL]
args)

  trans t :: Expr PythonTerm l
t@(F.BinaryOp op :: PythonTerm OpL
op l :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
l r :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
r _) =
    if PythonTerm OpL -> Bool
isCompOp PythonTerm OpL
op
    then PythonTerm OpL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
reassociateComp PythonTerm OpL
op Cxt NoHole (Sum PythonSig) (K ()) ExprL
l Cxt NoHole (Sum PythonSig) (K ()) ExprL
r
    else Expr PythonTerm l -> MPythonTerm l
forall (f :: (* -> *) -> * -> *) l.
(HFunctor f, f :-<: MPythonSig, f :-<: PythonSig) =>
f PythonTerm l -> MPythonTerm l
transDefault Expr PythonTerm l
t
  trans (F.CondExpr t :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
t c :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
c e :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
e _) = CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
-> MPythonTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyCondExpr :-<: 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
iPyCondExpr (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
c) (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
t) (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
e)
  trans (F.ListComp comp :: PythonTerm ComprehensionL
comp _) = CxtS NoHole MPythonSig (K ()) PyComprehensionL -> MPythonTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyComprehensionExpr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a PyComprehensionL -> CxtS h fs a j
iPyListComprehension (PythonTerm ComprehensionL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
transComprehension PythonTerm ComprehensionL
comp)
  trans (F.DictComp comp :: PythonTerm ComprehensionL
comp _) = CxtS NoHole MPythonSig (K ()) PyComprehensionL -> MPythonTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyComprehensionExpr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a PyComprehensionL -> CxtS h fs a j
iPyDictComprehension (PythonTerm ComprehensionL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
transComprehension PythonTerm ComprehensionL
comp)
  trans (F.SetComp comp :: PythonTerm ComprehensionL
comp _) = CxtS NoHole MPythonSig (K ()) PyComprehensionL -> MPythonTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyComprehensionExpr :-<: fs, InjF fs ExprL j) =>
CxtS h fs a PyComprehensionL -> CxtS h fs a j
iPySetComprehension (PythonTerm ComprehensionL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
transComprehension PythonTerm ComprehensionL
comp)
  trans x :: Expr PythonTerm l
x = Expr PythonTerm l -> MPythonTerm l
forall (f :: (* -> *) -> * -> *) l.
(HFunctor f, f :-<: MPythonSig, f :-<: PythonSig) =>
f PythonTerm l -> MPythonTerm l
transDefault Expr PythonTerm l
x

transComprehension :: F.PythonTerm F.ComprehensionL -> MPythonTerm PyComprehensionL
transComprehension :: PythonTerm ComprehensionL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
transComprehension (PythonTerm ComprehensionL
-> Maybe (Comprehension PythonTerm ComprehensionL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Comprehension cexpr :: Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
cexpr cfor :: Cxt NoHole (Sum PythonSig) (K ()) CompForL
cfor _)) = Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
-> Cxt NoHole (Sum PythonSig) (K ()) CompForL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
transComprehensionFor Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
cexpr Cxt NoHole (Sum PythonSig) (K ()) CompForL
cfor

transComprehensionIf :: F.PythonTerm F.ComprehensionExprL -> F.PythonTerm F.CompIfL -> MPythonTerm PyComprehensionL
transComprehensionIf :: Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
-> PythonTerm CompIfL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
transComprehensionIf cexp :: Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
cexp (PythonTerm CompIfL -> Maybe (CompIf PythonTerm CompIfL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.CompIf e :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
e mi :: Cxt NoHole (Sum PythonSig) (K ()) (Maybe CompIterL)
mi _)) =
  let comp :: CxtS NoHole MPythonSig (K ()) PyComprehensionL
comp = case Cxt NoHole (Sum PythonSig) (K ()) (Maybe CompIterL)
-> Maybe (Cxt NoHole (Sum PythonSig) (K ()) CompIterL)
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF Cxt NoHole (Sum PythonSig) (K ()) (Maybe CompIterL)
mi of
        Just (Cxt NoHole (Sum PythonSig) (K ()) CompIterL
-> Maybe (CompIter PythonTerm CompIterL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.IterFor i :: Cxt NoHole (Sum PythonSig) (K ()) CompForL
i _)) -> Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
-> Cxt NoHole (Sum PythonSig) (K ()) CompForL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
transComprehensionFor Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
cexp Cxt NoHole (Sum PythonSig) (K ()) CompForL
i
        Just (Cxt NoHole (Sum PythonSig) (K ()) CompIterL
-> Maybe (CompIter PythonTerm CompIterL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.IterIf i :: PythonTerm CompIfL
i _)) -> Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
-> PythonTerm CompIfL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
transComprehensionIf Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
cexp PythonTerm CompIfL
i
        Nothing -> CxtS NoHole MPythonSig (K ()) ComprehensionExprL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyComprehension :-<: fs, InjF fs PyComprehensionL j) =>
CxtS h fs a ComprehensionExprL -> CxtS h fs a j
iPyComprehensionBody (Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
-> CxtS NoHole MPythonSig (K ()) ComprehensionExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
cexp)
  in CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyComprehension :-<: fs, InjF fs PyComprehensionL j) =>
CxtS h fs a ExprL -> CxtS h fs a PyComprehensionL -> CxtS h fs a j
iPyComprehensionIf (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
e) CxtS NoHole MPythonSig (K ()) PyComprehensionL
comp

transComprehensionFor :: F.PythonTerm F.ComprehensionExprL -> F.PythonTerm F.CompForL -> MPythonTerm PyComprehensionL
transComprehensionFor :: Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
-> Cxt NoHole (Sum PythonSig) (K ()) CompForL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
transComprehensionFor cexp :: Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
cexp (Cxt NoHole (Sum PythonSig) (K ()) CompForL
-> Maybe (CompFor PythonTerm CompForL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.CompFor b :: Bool
b es :: Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
es v :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
v mi :: Cxt NoHole (Sum PythonSig) (K ()) (Maybe CompIterL)
mi _)) =
  let comp :: CxtS NoHole MPythonSig (K ()) PyComprehensionL
comp = case Cxt NoHole (Sum PythonSig) (K ()) (Maybe CompIterL)
-> Maybe (Cxt NoHole (Sum PythonSig) (K ()) CompIterL)
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF Cxt NoHole (Sum PythonSig) (K ()) (Maybe CompIterL)
mi of
        Just (Cxt NoHole (Sum PythonSig) (K ()) CompIterL
-> Maybe (CompIter PythonTerm CompIterL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.IterFor i :: Cxt NoHole (Sum PythonSig) (K ()) CompForL
i _)) -> Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
-> Cxt NoHole (Sum PythonSig) (K ()) CompForL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
transComprehensionFor Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
cexp Cxt NoHole (Sum PythonSig) (K ()) CompForL
i
        Just (Cxt NoHole (Sum PythonSig) (K ()) CompIterL
-> Maybe (CompIter PythonTerm CompIterL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.IterIf i :: PythonTerm CompIfL
i _)) -> Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
-> PythonTerm CompIfL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
transComprehensionIf Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
cexp PythonTerm CompIfL
i
        Nothing -> CxtS NoHole MPythonSig (K ()) ComprehensionExprL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyComprehension :-<: fs, InjF fs PyComprehensionL j) =>
CxtS h fs a ComprehensionExprL -> CxtS h fs a j
iPyComprehensionBody (Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
-> CxtS NoHole MPythonSig (K ()) ComprehensionExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ComprehensionExprL
cexp)
  in Bool
-> CxtS NoHole MPythonSig (K ()) [ExprL]
-> CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
-> CxtS NoHole MPythonSig (K ()) PyComprehensionL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyComprehension :-<: fs, InjF fs PyComprehensionL j) =>
Bool
-> CxtS h fs a [ExprL]
-> CxtS h fs a ExprL
-> CxtS h fs a PyComprehensionL
-> CxtS h fs a j
iPyComprehensionFor Bool
b ((Cxt NoHole (Sum PythonSig) (K ()) ExprL
 -> CxtS NoHole MPythonSig (K ()) ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
-> CxtS NoHole MPythonSig (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) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
es) (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
v) CxtS NoHole MPythonSig (K ()) PyComprehensionL
comp

translateLValue :: F.PythonTerm F.ExprL -> MPythonTerm PyLValueL
translateLValue :: Cxt NoHole (Sum PythonSig) (K ()) ExprL -> MPythonTerm PyLValueL
translateLValue (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Maybe (Expr PythonTerm ExprL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Tuple xs :: Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
xs _))        = CxtS NoHole MPythonSig (K ()) [PyLValueL] -> MPythonTerm PyLValueL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(TupleLValue :-<: fs, InjF fs PyLValueL j) =>
CxtS h fs a [PyLValueL] -> CxtS h fs a j
iTupleLValue ((Cxt NoHole (Sum PythonSig) (K ()) ExprL -> MPythonTerm PyLValueL)
-> Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
-> CxtS NoHole MPythonSig (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) (K ()) ExprL -> MPythonTerm PyLValueL
translateLValue Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
xs)
translateLValue (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Maybe (Expr PythonTerm ExprL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.List xs :: Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
xs _))         = CxtS NoHole MPythonSig (K ()) [PyLValueL] -> MPythonTerm PyLValueL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(ListLValue :-<: fs, InjF fs PyLValueL j) =>
CxtS h fs a [PyLValueL] -> CxtS h fs a j
iListLValue  ((Cxt NoHole (Sum PythonSig) (K ()) ExprL -> MPythonTerm PyLValueL)
-> Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
-> CxtS NoHole MPythonSig (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) (K ()) ExprL -> MPythonTerm PyLValueL
translateLValue Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
xs)
translateLValue (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Maybe (Expr PythonTerm ExprL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Dot e :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
e i :: PythonTerm IdentL
i _))         = CxtS NoHole MPythonSig (K ()) ExprL
-> MPythonTerm IdentL -> MPythonTerm PyLValueL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(DotLValue :-<: fs, InjF fs PyLValueL j) =>
CxtS h fs a ExprL -> CxtS h fs a IdentL -> CxtS h fs a j
iDotLValue (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
e) (PythonTerm IdentL -> MPythonTerm IdentL
transIdent PythonTerm IdentL
i)
translateLValue (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Maybe (Expr PythonTerm ExprL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Starred e :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
e _))       = MPythonTerm PyLValueL -> MPythonTerm PyLValueL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(StarLValue :-<: fs, InjF fs PyLValueL j) =>
CxtS h fs a PyLValueL -> CxtS h fs a j
iStarLValue (Cxt NoHole (Sum PythonSig) (K ()) ExprL -> MPythonTerm PyLValueL
translateLValue Cxt NoHole (Sum PythonSig) (K ()) ExprL
e)
translateLValue (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Maybe (Expr PythonTerm ExprL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Subscript e :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
e x :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
x _))   = CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL -> MPythonTerm PyLValueL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(SubscriptLValue :-<: fs, InjF fs PyLValueL j) =>
CxtS h fs a ExprL -> CxtS h fs a ExprL -> CxtS h fs a j
iSubscriptLValue (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
e) (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
x)
translateLValue (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Maybe (Expr PythonTerm ExprL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.SlicedExpr e :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
e sl :: Cxt NoHole (Sum PythonSig) (K ()) [SliceL]
sl _)) = CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) [SliceL] -> MPythonTerm PyLValueL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(SliceLValue :-<: fs, InjF fs PyLValueL j) =>
CxtS h fs a ExprL -> CxtS h fs a [SliceL] -> CxtS h fs a j
iSliceLValue (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
e) (Cxt NoHole (Sum PythonSig) (K ()) [SliceL]
-> CxtS NoHole MPythonSig (K ()) [SliceL]
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) [SliceL]
sl)
translateLValue (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Maybe (Expr PythonTerm ExprL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Paren e :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
e _))         = MPythonTerm PyLValueL -> MPythonTerm PyLValueL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(ParenLValue :-<: fs, InjF fs PyLValueL j) =>
CxtS h fs a PyLValueL -> CxtS h fs a j
iParenLValue (Cxt NoHole (Sum PythonSig) (K ()) ExprL -> MPythonTerm PyLValueL
translateLValue Cxt NoHole (Sum PythonSig) (K ()) ExprL
e)
translateLValue (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Maybe (Expr PythonTerm ExprL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Var n :: PythonTerm IdentL
n _))           = MPythonTerm IdentL -> MPythonTerm PyLValueL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (PythonTerm IdentL -> MPythonTerm IdentL
transIdent PythonTerm IdentL
n)
translateLValue x :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
x                                       = String -> MPythonTerm PyLValueL
forall a. HasCallStack => String -> a
error ("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) (K ()) ExprL
x)


transBinder :: F.PythonTerm (F.ExprL, Maybe F.ExprL) -> MPythonTerm PyWithBinderL
transBinder :: PythonTerm (ExprL, Maybe ExprL) -> MPythonTerm PyWithBinderL
transBinder (PairF' x :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
x y :: Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
y) = CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) (Maybe PyLValueL)
-> MPythonTerm PyWithBinderL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyWithBinder :-<: fs, InjF fs PyWithBinderL j) =>
CxtS h fs a ExprL -> CxtS h fs a (Maybe PyLValueL) -> CxtS h fs a j
iPyWithBinder (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
x) ((Cxt NoHole (Sum PythonSig) (K ()) ExprL -> MPythonTerm PyLValueL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> CxtS NoHole MPythonSig (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 Cxt NoHole (Sum PythonSig) (K ()) ExprL -> MPythonTerm PyLValueL
translateLValue Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
y)

transParam :: F.PythonTerm F.ParameterL -> MPythonTerm FunctionParameterL
transParam :: PythonTerm ParameterL -> MPythonTerm FunctionParameterL
transParam (PythonTerm ParameterL -> Maybe (Parameter PythonTerm ParameterL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Param          n :: PythonTerm IdentL
n ann :: Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
ann d :: Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
d _)) = CxtS NoHole MPythonSig (K ()) ParameterAttrsL
-> MPythonTerm IdentL -> MPythonTerm FunctionParameterL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(PositionalParameter :-<: fs, All HFunctor fs) =>
CxtS h fs a ParameterAttrsL
-> CxtS h fs a IdentL -> CxtS h fs a FunctionParameterL
PositionalParameter' (CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
-> CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
-> CxtS NoHole MPythonSig (K ()) ParameterAttrsL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyParamAttrs :-<: fs, InjF fs ParameterAttrsL j) =>
CxtS h fs a (Maybe ExprL)
-> CxtS h fs a (Maybe ExprL) -> CxtS h fs a j
iPyParamAttrs (Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
ann) (Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
d)) (PythonTerm IdentL -> MPythonTerm IdentL
transIdent PythonTerm IdentL
n)
transParam (PythonTerm ParameterL -> Maybe (Parameter PythonTerm ParameterL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.VarArgsPos     n :: PythonTerm IdentL
n ann :: Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
ann   _)) = MPythonTerm IdentL
-> CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
-> MPythonTerm FunctionParameterL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PythonParam :-<: fs, InjF fs FunctionParameterL j) =>
CxtS h fs a IdentL -> CxtS h fs a (Maybe ExprL) -> CxtS h fs a j
iPythonParamVarArgs (PythonTerm IdentL -> MPythonTerm IdentL
transIdent PythonTerm IdentL
n) (Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
ann)
transParam (PythonTerm ParameterL -> Maybe (Parameter PythonTerm ParameterL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.VarArgsKeyword n :: PythonTerm IdentL
n ann :: Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
ann   _)) = MPythonTerm IdentL
-> CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
-> MPythonTerm FunctionParameterL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PythonParam :-<: fs, InjF fs FunctionParameterL j) =>
CxtS h fs a IdentL -> CxtS h fs a (Maybe ExprL) -> CxtS h fs a j
iPythonParamVarArgsKW (PythonTerm IdentL -> MPythonTerm IdentL
transIdent PythonTerm IdentL
n) (Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
ann)
transParam (PythonTerm ParameterL -> Maybe (Parameter PythonTerm ParameterL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.EndPositional _))          = MPythonTerm FunctionParameterL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PythonParam :-<: fs, InjF fs FunctionParameterL j) =>
CxtS h fs a j
iPythonEndPosParam
transParam (PythonTerm ParameterL -> Maybe (Parameter PythonTerm ParameterL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.UnPackTuple t :: Cxt NoHole (Sum PythonSig) (K ()) ParamTupleL
t    ann :: Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
ann   _)) = CxtS NoHole MPythonSig (K ()) ParamTupleL
-> CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
-> MPythonTerm FunctionParameterL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PythonParam :-<: fs, InjF fs FunctionParameterL j) =>
CxtS h fs a ParamTupleL
-> CxtS h fs a (Maybe ExprL) -> CxtS h fs a j
iPythonParamUnpackTuple (Cxt NoHole (Sum PythonSig) (K ()) ParamTupleL
-> CxtS NoHole MPythonSig (K ()) ParamTupleL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ParamTupleL
t) (Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
ann)

extractString :: F.PythonTerm [CharL] -> String
extractString :: PythonTerm [CharL] -> String
extractString cs :: PythonTerm [CharL]
cs = (PythonTerm CharL -> Char) -> [PythonTerm CharL] -> String
forall a b. (a -> b) -> [a] -> [b]
map PythonTerm CharL -> Char
getChar ([PythonTerm CharL] -> String) -> [PythonTerm CharL] -> String
forall a b. (a -> b) -> a -> b
$ PythonTerm [CharL] -> [PythonTerm CharL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF PythonTerm [CharL]
cs
  where
    getChar :: F.PythonTerm CharL -> Char
    getChar :: PythonTerm CharL -> Char
getChar (CharF' c :: Char
c) = Char
c

extractStrings :: F.PythonTerm [[CharL]] -> [String]
extractStrings :: PythonTerm [[CharL]] -> [String]
extractStrings strs :: PythonTerm [[CharL]]
strs = (PythonTerm [CharL] -> String) -> [PythonTerm [CharL]] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map PythonTerm [CharL] -> String
extractString ([PythonTerm [CharL]] -> [String])
-> [PythonTerm [CharL]] -> [String]
forall a b. (a -> b) -> a -> b
$ PythonTerm [[CharL]] -> [PythonTerm [CharL]]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF PythonTerm [[CharL]]
strs

makePyBlock :: F.PythonTerm [F.StatementL] -> MPythonTerm PyBlockL
makePyBlock :: PythonTerm [StatementL] -> MPythonTerm PyBlockL
makePyBlock stmts :: PythonTerm [StatementL]
stmts = CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL)
-> CxtS NoHole MPythonSig (K ()) BlockL -> MPythonTerm PyBlockL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyBlock :-<: fs, InjF fs PyBlockL j) =>
CxtS h fs a (Maybe PyStringLitL)
-> CxtS h fs a BlockL -> CxtS h fs a j
iPyBlock CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL)
docstring (CxtS NoHole MPythonSig (K ()) [BlockItemL]
-> CxtS NoHole MPythonSig (K ()) BlockEndL
-> CxtS NoHole MPythonSig (K ()) BlockL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Block :-<: fs, InjF fs BlockL j) =>
CxtS h fs a [BlockItemL] -> CxtS h fs a BlockEndL -> CxtS h fs a j
iBlock ([Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL]
-> CxtS NoHole MPythonSig (K ()) [BlockItemL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL]
 -> CxtS NoHole MPythonSig (K ()) [BlockItemL])
-> [Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL]
-> CxtS NoHole MPythonSig (K ()) [BlockItemL]
forall a b. (a -> b) -> a -> b
$ (PythonTerm StatementL
 -> Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL)
-> [PythonTerm StatementL]
-> [Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL]
forall a b. (a -> b) -> [a] -> [b]
map (CxtS NoHole MPythonSig (K ()) StatementL
-> Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF(CxtS NoHole MPythonSig (K ()) StatementL
 -> Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL)
-> (PythonTerm StatementL
    -> CxtS NoHole MPythonSig (K ()) StatementL)
-> PythonTerm StatementL
-> Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL
forall b c a. (b -> c) -> (a -> b) -> a -> c
.PythonTerm StatementL -> CxtS NoHole MPythonSig (K ()) StatementL
forall l. PythonTerm l -> MPythonTerm l
translate) [PythonTerm StatementL]
body) CxtS NoHole MPythonSig (K ()) BlockEndL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(EmptyBlockEnd :-<: fs, All HFunctor fs) =>
CxtS h fs a BlockEndL
EmptyBlockEnd')
  where
    docstring :: MPythonTerm (Maybe PyStringLitL)
    body :: [F.PythonTerm F.StatementL]
    (docstring :: CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL)
docstring, body :: [PythonTerm StatementL]
body) = case PythonTerm [StatementL] -> [PythonTerm StatementL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF PythonTerm [StatementL]
stmts of
      [] -> (CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL)
forall (f :: (* -> *) -> * -> *) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a (Maybe l)
Nothing', [])
      (fst :: PythonTerm StatementL
fst : rest :: [PythonTerm StatementL]
rest) ->
        case PythonTerm StatementL
fst of
          (PythonTerm StatementL -> Maybe (Statement PythonTerm StatementL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.StmtExpr exp :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
exp _)) ->
            case Cxt NoHole (Sum PythonSig) (K ()) ExprL
exp of
              (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Maybe (Expr PythonTerm ExprL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Strings        strs :: PythonTerm [[CharL]]
strs _)) -> (Cxt NoHole (Sum MPythonSig) (K ()) PyStringLitL
-> CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL)
forall (f :: (* -> *) -> * -> *) 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) (K ()) PyStringLitL
 -> CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL))
-> Cxt NoHole (Sum MPythonSig) (K ()) PyStringLitL
-> CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL)
forall a b. (a -> b) -> a -> b
$ [String] -> Cxt NoHole (Sum MPythonSig) (K ()) PyStringLitL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyStringLit :-<: fs, InjF fs PyStringLitL j) =>
[String] -> CxtS h fs a j
iPyStrings        (PythonTerm [[CharL]] -> [String]
extractStrings PythonTerm [[CharL]]
strs), [PythonTerm StatementL]
rest)
              (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Maybe (Expr PythonTerm ExprL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.UnicodeStrings strs :: PythonTerm [[CharL]]
strs _)) -> (Cxt NoHole (Sum MPythonSig) (K ()) PyStringLitL
-> CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL)
forall (f :: (* -> *) -> * -> *) 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) (K ()) PyStringLitL
 -> CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL))
-> Cxt NoHole (Sum MPythonSig) (K ()) PyStringLitL
-> CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL)
forall a b. (a -> b) -> a -> b
$ [String] -> Cxt NoHole (Sum MPythonSig) (K ()) PyStringLitL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyStringLit :-<: fs, InjF fs PyStringLitL j) =>
[String] -> CxtS h fs a j
iPyUnicodeStrings (PythonTerm [[CharL]] -> [String]
extractStrings PythonTerm [[CharL]]
strs), [PythonTerm StatementL]
rest)
              (Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Maybe (Expr PythonTerm ExprL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.ByteStrings    strs :: PythonTerm [[CharL]]
strs _)) -> (Cxt NoHole (Sum MPythonSig) (K ()) PyStringLitL
-> CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL)
forall (f :: (* -> *) -> * -> *) 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) (K ()) PyStringLitL
 -> CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL))
-> Cxt NoHole (Sum MPythonSig) (K ()) PyStringLitL
-> CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL)
forall a b. (a -> b) -> a -> b
$ [String] -> Cxt NoHole (Sum MPythonSig) (K ()) PyStringLitL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyStringLit :-<: fs, InjF fs PyStringLitL j) =>
[String] -> CxtS h fs a j
iPyByteStrings    (PythonTerm [[CharL]] -> [String]
extractStrings PythonTerm [[CharL]]
strs), [PythonTerm StatementL]
rest)
              _                                            -> (CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL)
forall (f :: (* -> *) -> * -> *) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a (Maybe l)
Nothing', PythonTerm StatementL
fst PythonTerm StatementL
-> [PythonTerm StatementL] -> [PythonTerm StatementL]
forall a. a -> [a] -> [a]
: [PythonTerm StatementL]
rest)
          _ -> (CxtS NoHole MPythonSig (K ()) (Maybe PyStringLitL)
forall (f :: (* -> *) -> * -> *) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a (Maybe l)
Nothing', PythonTerm StatementL
fst PythonTerm StatementL
-> [PythonTerm StatementL] -> [PythonTerm StatementL]
forall a. a -> [a] -> [a]
: [PythonTerm StatementL]
rest)

instance Trans F.Statement where
  trans :: Statement PythonTerm l -> MPythonTerm l
trans (F.Assign es :: Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
es e :: Cxt NoHole (Sum PythonSig) (K ()) ExprL
e _)           = CxtS NoHole MPythonSig (K ()) AssignL -> MPythonTerm l
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MPythonSig (K ()) AssignL -> MPythonTerm l)
-> CxtS NoHole MPythonSig (K ()) AssignL -> MPythonTerm l
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MPythonSig (K ()) LhsL
-> CxtS NoHole MPythonSig (K ()) AssignOpL
-> CxtS NoHole MPythonSig (K ()) RhsL
-> CxtS NoHole MPythonSig (K ()) AssignL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(Assign :-<: fs, All HFunctor fs) =>
CxtS h fs a LhsL
-> CxtS h fs a AssignOpL -> CxtS h fs a RhsL -> CxtS h fs a AssignL
Assign' (CxtS NoHole MPythonSig (K ()) [PyLValueL]
-> CxtS NoHole MPythonSig (K ()) LhsL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyLhs :-<: fs, InjF fs LhsL j) =>
CxtS h fs a [PyLValueL] -> CxtS h fs a j
iPyLhs (CxtS NoHole MPythonSig (K ()) [PyLValueL]
 -> CxtS NoHole MPythonSig (K ()) LhsL)
-> CxtS NoHole MPythonSig (K ()) [PyLValueL]
-> CxtS NoHole MPythonSig (K ()) LhsL
forall a b. (a -> b) -> a -> b
$ (Cxt NoHole (Sum PythonSig) (K ()) ExprL -> MPythonTerm PyLValueL)
-> Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
-> CxtS NoHole MPythonSig (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) (K ()) ExprL -> MPythonTerm PyLValueL
translateLValue Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
es) CxtS NoHole MPythonSig (K ()) AssignOpL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(AssignOpEquals :-<: fs, All HFunctor fs) =>
CxtS h fs a AssignOpL
AssignOpEquals' (CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) RhsL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MPythonSig (K ()) ExprL
 -> CxtS NoHole MPythonSig (K ()) RhsL)
-> CxtS NoHole MPythonSig (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) RhsL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) ExprL
e)
  trans (F.Fun n :: PythonTerm IdentL
n params :: PythonTerm [ParameterL]
params ann :: Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
ann body :: PythonTerm [StatementL]
body _) = CxtS NoHole MPythonSig (K ()) FunctionDefAttrsL
-> MPythonTerm IdentL
-> CxtS NoHole MPythonSig (K ()) [FunctionParameterL]
-> CxtS NoHole MPythonSig (K ()) FunctionBodyL
-> MPythonTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunctionDef :-<: fs, InjF fs FunctionDefL j) =>
CxtS h fs a FunctionDefAttrsL
-> CxtS h fs a IdentL
-> CxtS h fs a [FunctionParameterL]
-> CxtS h fs a FunctionBodyL
-> CxtS h fs a j
iFunctionDef (CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
-> CxtS NoHole MPythonSig (K ()) FunctionDefAttrsL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyFunDefAttrs :-<: fs, InjF fs FunctionDefAttrsL j) =>
CxtS h fs a (Maybe ExprL) -> CxtS h fs a j
iPyFunDefAttrs (CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
 -> CxtS NoHole MPythonSig (K ()) FunctionDefAttrsL)
-> CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
-> CxtS NoHole MPythonSig (K ()) FunctionDefAttrsL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
forall l. PythonTerm l -> MPythonTerm l
translate Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
ann) (PythonTerm IdentL -> MPythonTerm IdentL
transIdent PythonTerm IdentL
n) ((PythonTerm ParameterL -> MPythonTerm FunctionParameterL)
-> PythonTerm [ParameterL]
-> CxtS NoHole MPythonSig (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 PythonTerm ParameterL -> MPythonTerm FunctionParameterL
transParam PythonTerm [ParameterL]
params) (MPythonTerm PyBlockL -> CxtS NoHole MPythonSig (K ()) FunctionBodyL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MPythonTerm PyBlockL
 -> CxtS NoHole MPythonSig (K ()) FunctionBodyL)
-> MPythonTerm PyBlockL
-> CxtS NoHole MPythonSig (K ()) FunctionBodyL
forall a b. (a -> b) -> a -> b
$ PythonTerm [StatementL] -> MPythonTerm PyBlockL
makePyBlock PythonTerm [StatementL]
body)
  trans (F.With binders :: PythonTerm [(ExprL, Maybe ExprL)]
binders body :: PythonTerm [StatementL]
body _  )   = CxtS NoHole MPythonSig (K ()) [PyWithBinderL]
-> CxtS NoHole MPythonSig (K ()) [StatementL] -> MPythonTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyWith :-<: fs, InjF fs StatementL j) =>
CxtS h fs a [PyWithBinderL]
-> CxtS h fs a [StatementL] -> CxtS h fs a j
iPyWith ((PythonTerm (ExprL, Maybe ExprL) -> MPythonTerm PyWithBinderL)
-> PythonTerm [(ExprL, Maybe ExprL)]
-> CxtS NoHole MPythonSig (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 PythonTerm (ExprL, Maybe ExprL) -> MPythonTerm PyWithBinderL
transBinder PythonTerm [(ExprL, Maybe ExprL)]
binders) (PythonTerm [StatementL]
-> CxtS NoHole MPythonSig (K ()) [StatementL]
forall l. PythonTerm l -> MPythonTerm l
translate PythonTerm [StatementL]
body)
  trans (F.Class id :: PythonTerm IdentL
id args :: PythonTerm [ArgumentL]
args body :: PythonTerm [StatementL]
body _)    = MPythonTerm IdentL
-> CxtS NoHole MPythonSig (K ()) [ArgumentL]
-> MPythonTerm PyBlockL
-> MPythonTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(PyClass :-<: fs, InjF fs PyClassL j) =>
CxtS h fs a IdentL
-> CxtS h fs a [ArgumentL] -> CxtS h fs a PyBlockL -> CxtS h fs a j
iPyClass (PythonTerm IdentL -> MPythonTerm IdentL
transIdent PythonTerm IdentL
id) (PythonTerm [ArgumentL] -> CxtS NoHole MPythonSig (K ()) [ArgumentL]
forall l. PythonTerm l -> MPythonTerm l
translate PythonTerm [ArgumentL]
args) (PythonTerm [StatementL] -> MPythonTerm PyBlockL
makePyBlock PythonTerm [StatementL]
body)
  trans x :: Statement PythonTerm l
x                           = Statement PythonTerm l -> MPythonTerm l
forall (f :: (* -> *) -> * -> *) l.
(HFunctor f, f :-<: MPythonSig, f :-<: PythonSig) =>
f PythonTerm l -> MPythonTerm l
transDefault Statement PythonTerm l
x

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

untranslate :: MPythonTerm l -> F.PythonTerm l
untranslate :: MPythonTerm l -> PythonTerm l
untranslate = Sum MPythonSig (Cxt NoHole (Sum MPythonSig) (K ())) l
-> PythonTerm l
forall (f :: (* -> *) -> * -> *) 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 :: (* -> *) -> * -> *) t. HFix f t -> f (HFix f) t
unTerm

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

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

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

instance {-# OVERLAPPABLE #-} (HFunctor f, f :-<: F.PythonSig) => Untrans f where
  untrans :: f (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
untrans = f (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
forall (f :: (* -> *) -> * -> *) 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' x :: String
x) = String -> CxtS NoHole PythonSig (K ()) () -> PythonTerm IdentL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Ident :-<: fs, InjF fs IdentL j) =>
String -> CxtS h fs a () -> CxtS h fs a j
F.iIdent String
x CxtS NoHole PythonSig (K ()) ()
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(UnitF :-<: fs, InjF fs () j) =>
CxtS h fs a j
iUnitF

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

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

instance {-# OVERLAPPING #-} Untrans AssignIsStatement where
  untrans :: AssignIsStatement (Cxt NoHole (Sum MPythonSig) (K ())) l
-> PythonTerm l
untrans (AssignIsStatement (Assign' l :: CxtS NoHole MPythonSig (K ()) LhsL
l AssignOpEquals' r :: CxtS NoHole MPythonSig (K ()) RhsL
r)) = Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> CxtS NoHole PythonSig (K ()) ()
-> PythonTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Statement :-<: fs, InjF fs StatementL j) =>
CxtS h fs a [ExprL]
-> CxtS h fs a ExprL -> CxtS h fs a () -> CxtS h fs a j
F.iAssign ((MPythonTerm PyLValueL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> CxtS NoHole MPythonSig (K ()) [PyLValueL]
-> Cxt NoHole (Sum 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 (CxtS NoHole MPythonSig (K ()) [PyLValueL]
 -> Cxt NoHole (Sum PythonSig) (K ()) [ExprL])
-> CxtS NoHole MPythonSig (K ()) [PyLValueL]
-> Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MPythonSig (K ()) LhsL
-> CxtS NoHole MPythonSig (K ()) [PyLValueL]
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MPythonSig (K ()) LhsL
l) (CxtS NoHole MPythonSig (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ()) :-> PythonTerm
untranslate (CxtS NoHole MPythonSig (K ()) ExprL
 -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> CxtS NoHole MPythonSig (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MPythonSig (K ()) RhsL
-> CxtS NoHole MPythonSig (K ()) ExprL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MPythonSig (K ()) RhsL
r) CxtS NoHole PythonSig (K ()) ()
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(UnitF :-<: fs, InjF fs () j) =>
CxtS h fs a j
iUnitF


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)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PyWithBinder x :: CxtS NoHole MPythonSig (K ()) ExprL
x y :: CxtS NoHole MPythonSig (K ()) (Maybe PyLValueL)
y)) = Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> PythonTerm (ExprL, Maybe ExprL)
forall (f :: (* -> *) -> * -> *) 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' (CxtS NoHole MPythonSig (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ()) :-> PythonTerm
untranslate CxtS NoHole MPythonSig (K ()) ExprL
x) ((MPythonTerm PyLValueL -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> CxtS NoHole 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 CxtS NoHole MPythonSig (K ()) (Maybe PyLValueL)
y)

instance {-# OVERLAPPING #-} Untrans PyWith where
  untrans :: PyWith (Cxt NoHole (Sum MPythonSig) (K ())) l -> PythonTerm l
untrans (PyWith binders :: CxtS NoHole MPythonSig (K ()) [PyWithBinderL]
binders body :: CxtS NoHole MPythonSig (K ()) [StatementL]
body) = PythonTerm [(ExprL, Maybe ExprL)]
-> PythonTerm [StatementL]
-> CxtS NoHole PythonSig (K ()) ()
-> PythonTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Statement :-<: fs, InjF fs StatementL j) =>
CxtS h fs a [(ExprL, Maybe ExprL)]
-> CxtS h fs a [StatementL] -> CxtS h fs a () -> CxtS h fs a j
F.iWith ((MPythonTerm PyWithBinderL -> PythonTerm (ExprL, Maybe ExprL))
-> CxtS NoHole MPythonSig (K ()) [PyWithBinderL]
-> PythonTerm [(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 CxtS NoHole MPythonSig (K ()) [PyWithBinderL]
binders) (CxtS NoHole MPythonSig (K ()) [StatementL]
-> PythonTerm [StatementL]
Cxt NoHole (Sum MPythonSig) (K ()) :-> PythonTerm
untranslate CxtS NoHole MPythonSig (K ()) [StatementL]
body) CxtS NoHole PythonSig (K ()) ()
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(UnitF :-<: fs, InjF fs () j) =>
CxtS h fs a j
iUnitF

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

untransBlock :: MPythonTerm BlockL -> F.PythonTerm [F.StatementL]
untransBlock :: CxtS NoHole MPythonSig (K ()) BlockL -> PythonTerm [StatementL]
untransBlock (Block' ss :: CxtS NoHole MPythonSig (K ()) [BlockItemL]
ss EmptyBlockEnd') = (Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL
 -> PythonTerm StatementL)
-> CxtS NoHole MPythonSig (K ()) [BlockItemL]
-> PythonTerm [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 (CxtS NoHole MPythonSig (K ()) StatementL -> PythonTerm StatementL
Cxt NoHole (Sum MPythonSig) (K ()) :-> PythonTerm
untranslate(CxtS NoHole MPythonSig (K ()) StatementL -> PythonTerm StatementL)
-> (Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL
    -> CxtS NoHole MPythonSig (K ()) StatementL)
-> Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL
-> PythonTerm StatementL
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Cxt NoHole (Sum MPythonSig) (K ()) BlockItemL
-> CxtS NoHole MPythonSig (K ()) StatementL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF) CxtS NoHole MPythonSig (K ()) [BlockItemL]
ss

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

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

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

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

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

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

insertString :: String -> F.PythonTerm [CharL]
insertString :: String -> PythonTerm [CharL]
insertString str :: String
str = [PythonTerm CharL] -> PythonTerm [CharL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([PythonTerm CharL] -> PythonTerm [CharL])
-> [PythonTerm CharL] -> PythonTerm [CharL]
forall a b. (a -> b) -> a -> b
$ (Char -> PythonTerm CharL) -> String -> [PythonTerm CharL]
forall a b. (a -> b) -> [a] -> [b]
map Char -> PythonTerm CharL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(CharF :-<: fs, All HFunctor fs) =>
Char -> CxtS h fs a CharL
CharF' String
str

insertStrings :: [String] -> F.PythonTerm [[CharL]]
insertStrings :: [String] -> PythonTerm [[CharL]]
insertStrings strs :: [String]
strs = [PythonTerm [CharL]] -> PythonTerm [[CharL]]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([PythonTerm [CharL]] -> PythonTerm [[CharL]])
-> [PythonTerm [CharL]] -> PythonTerm [[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'     ann :: CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
ann def :: CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
def) n :: MPythonTerm IdentL
n) = PythonTerm IdentL
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> CxtS NoHole PythonSig (K ()) ()
-> PythonTerm ParameterL
forall h (fs :: [(* -> *) -> * -> *]) (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 ()
-> CxtS h fs a j
F.iParam          (MPythonTerm IdentL -> PythonTerm IdentL
untransIdent MPythonTerm IdentL
n) (CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
Cxt NoHole (Sum MPythonSig) (K ()) :-> PythonTerm
untranslate CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
ann) (CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
Cxt NoHole (Sum MPythonSig) (K ()) :-> PythonTerm
untranslate CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
def) CxtS NoHole PythonSig (K ()) ()
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(UnitF :-<: fs, InjF fs () j) =>
CxtS h fs a j
iUnitF
untransParam (MPythonTerm FunctionParameterL
-> Maybe
     (PythonParam
        (Cxt NoHole (Sum MPythonSig) (K ())) FunctionParameterL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PythonParamVarArgs   n :: MPythonTerm IdentL
n ann :: CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
ann))       = PythonTerm IdentL
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> CxtS NoHole PythonSig (K ()) ()
-> PythonTerm ParameterL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Parameter :-<: fs, InjF fs ParameterL j) =>
CxtS h fs a IdentL
-> CxtS h fs a (Maybe ExprL) -> CxtS h fs a () -> CxtS h fs a j
F.iVarArgsPos     (MPythonTerm IdentL -> PythonTerm IdentL
untransIdent MPythonTerm IdentL
n) (CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
Cxt NoHole (Sum MPythonSig) (K ()) :-> PythonTerm
untranslate CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
ann) CxtS NoHole PythonSig (K ()) ()
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(UnitF :-<: fs, InjF fs () j) =>
CxtS h fs a j
iUnitF
untransParam (MPythonTerm FunctionParameterL
-> Maybe
     (PythonParam
        (Cxt NoHole (Sum MPythonSig) (K ())) FunctionParameterL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PythonParamVarArgsKW n :: MPythonTerm IdentL
n ann :: CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
ann))       = PythonTerm IdentL
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> CxtS NoHole PythonSig (K ()) ()
-> PythonTerm ParameterL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Parameter :-<: fs, InjF fs ParameterL j) =>
CxtS h fs a IdentL
-> CxtS h fs a (Maybe ExprL) -> CxtS h fs a () -> CxtS h fs a j
F.iVarArgsKeyword (MPythonTerm IdentL -> PythonTerm IdentL
untransIdent MPythonTerm IdentL
n) (CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
Cxt NoHole (Sum MPythonSig) (K ()) :-> PythonTerm
untranslate CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
ann) CxtS NoHole PythonSig (K ()) ()
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(UnitF :-<: fs, InjF fs () j) =>
CxtS h fs a j
iUnitF
untransParam (MPythonTerm FunctionParameterL
-> Maybe
     (PythonParam
        (Cxt NoHole (Sum MPythonSig) (K ())) FunctionParameterL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PythonParamUnpackTuple pt :: CxtS NoHole MPythonSig (K ()) ParamTupleL
pt ann :: CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
ann))    = Cxt NoHole (Sum PythonSig) (K ()) ParamTupleL
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> CxtS NoHole PythonSig (K ()) ()
-> PythonTerm ParameterL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Parameter :-<: fs, InjF fs ParameterL j) =>
CxtS h fs a ParamTupleL
-> CxtS h fs a (Maybe ExprL) -> CxtS h fs a () -> CxtS h fs a j
F.iUnPackTuple (CxtS NoHole MPythonSig (K ()) ParamTupleL
-> Cxt NoHole (Sum PythonSig) (K ()) ParamTupleL
Cxt NoHole (Sum MPythonSig) (K ()) :-> PythonTerm
untranslate CxtS NoHole MPythonSig (K ()) ParamTupleL
pt) (CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
Cxt NoHole (Sum MPythonSig) (K ()) :-> PythonTerm
untranslate CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
ann) CxtS NoHole PythonSig (K ()) ()
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(UnitF :-<: fs, InjF fs () j) =>
CxtS h fs a j
iUnitF
untransParam (MPythonTerm FunctionParameterL
-> Maybe
     (PythonParam
        (Cxt NoHole (Sum MPythonSig) (K ())) FunctionParameterL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) 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))                = CxtS NoHole PythonSig (K ()) () -> PythonTerm ParameterL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Parameter :-<: fs, InjF fs ParameterL j) =>
CxtS h fs a () -> CxtS h fs a j
F.iEndPositional CxtS NoHole PythonSig (K ()) ()
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(UnitF :-<: fs, InjF fs () j) =>
CxtS h fs a j
iUnitF


instance {-# OVERLAPPING #-} Untrans FunctionDefIsStatement where
  untrans :: FunctionDefIsStatement (Cxt NoHole (Sum MPythonSig) (K ())) l
-> PythonTerm l
untrans (FunctionDefIsStatement (FunctionDef' (PyFunDefAttrs' ann :: CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
ann) n :: MPythonTerm IdentL
n params :: CxtS NoHole MPythonSig (K ()) [FunctionParameterL]
params body :: CxtS NoHole MPythonSig (K ()) FunctionBodyL
body)) = PythonTerm IdentL
-> PythonTerm [ParameterL]
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
-> PythonTerm [StatementL]
-> CxtS NoHole PythonSig (K ()) ()
-> PythonTerm l
forall h (fs :: [(* -> *) -> * -> *]) (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 ()
-> CxtS h fs a j
F.iFun (MPythonTerm IdentL -> PythonTerm IdentL
untransIdent MPythonTerm IdentL
n) ((MPythonTerm FunctionParameterL -> PythonTerm ParameterL)
-> CxtS NoHole MPythonSig (K ()) [FunctionParameterL]
-> PythonTerm [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 CxtS NoHole MPythonSig (K ()) [FunctionParameterL]
params) (CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe ExprL)
Cxt NoHole (Sum MPythonSig) (K ()) :-> PythonTerm
untranslate CxtS NoHole MPythonSig (K ()) (Maybe ExprL)
ann) (MPythonTerm PyBlockL -> PythonTerm [StatementL]
untransPyBlock (MPythonTerm PyBlockL -> PythonTerm [StatementL])
-> MPythonTerm PyBlockL -> PythonTerm [StatementL]
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MPythonSig (K ()) FunctionBodyL -> MPythonTerm PyBlockL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MPythonSig (K ()) FunctionBodyL
body) CxtS NoHole PythonSig (K ()) ()
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(UnitF :-<: fs, InjF fs () j) =>
CxtS h fs a j
iUnitF

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

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

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

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

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

          where compFor :: Cxt NoHole (Sum PythonSig) (K ()) (Maybe CompIterL)
-> Cxt NoHole (Sum PythonSig) (K ()) CompForL
compFor mIter :: Cxt NoHole (Sum PythonSig) (K ()) (Maybe CompIterL)
mIter = Bool
-> Cxt NoHole (Sum PythonSig) (K ()) [ExprL]
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) (Maybe CompIterL)
-> CxtS NoHole PythonSig (K ()) ()
-> Cxt NoHole (Sum PythonSig) (K ()) CompForL
forall h (fs :: [(* -> *) -> * -> *]) (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 ()
-> CxtS h fs a j
F.iCompFor Bool
b ((CxtS NoHole MPythonSig (K ()) ExprL
 -> Cxt NoHole (Sum PythonSig) (K ()) ExprL)
-> CxtS NoHole MPythonSig (K ()) [ExprL]
-> Cxt NoHole (Sum 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 CxtS NoHole MPythonSig (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ()) :-> PythonTerm
untranslate CxtS NoHole MPythonSig (K ()) [ExprL]
es) (CxtS NoHole MPythonSig (K ()) ExprL
-> Cxt NoHole (Sum PythonSig) (K ()) ExprL
Cxt NoHole (Sum MPythonSig) (K ()) :-> PythonTerm
untranslate CxtS NoHole MPythonSig (K ()) ExprL
v) Cxt NoHole (Sum PythonSig) (K ()) (Maybe CompIterL)
mIter CxtS NoHole PythonSig (K ()) ()
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(UnitF :-<: fs, InjF fs () j) =>
CxtS h fs a j
iUnitF

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

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

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

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


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)

#endif