{-# OPTIONS_HADDOCK hide #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PartialTypeSignatures #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE ViewPatterns #-}

module Cubix.Language.Python.Parametric.Common.Semantics () where

#ifndef ONLY_ONE_LANGUAGE
import Control.Monad ( liftM )

import Data.Proxy ( Proxy(..) )
import Data.Type.Equality ( (:~:)(..), gcastWith )

import Data.Comp.Multi ( Cxt(..), project, project', inject', (:&:)(..), (:-<:) )
import Data.Comp.Multi.Strategy.Classification ( KDynCase(..), kIsSort )

import Cubix.Language.Info
import Cubix.Language.Python.Parametric.Common.Types
import Cubix.Language.Python.Parametric.Full
import Cubix.Language.Parametric.Semantics.SemanticProperties
import Cubix.Language.Parametric.Syntax

import Cubix.Sin.Compdata.Annotation ( annM )

instance {-# OVERLAPPING #-} (Op :-<: gs) => GetStrictness' gs Expr where
  getStrictness' :: Expr (Term gs) l -> [Strictness]
getStrictness' t :: Expr (Term gs) l
t@(BinaryOp op :: Term gs OpL
op _ _ _) = case Term gs OpL -> Maybe (Op (Term gs) OpL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project Term gs OpL
op of
    Just (And _) -> [Strictness
NoEval, Strictness
Strict, Place -> Strictness
GuardedBy (Int -> Place
Place 1), Strictness
NoEval]
    Just (Or _)  -> [Strictness
NoEval, Strictness
Strict, Place -> Strictness
GuardedBy (Int -> Place
NegPlace 1),    Strictness
NoEval]
    _           -> Expr (Term gs) l -> [Strictness]
forall (f :: (* -> *) -> * -> *) (e :: * -> *) l.
HFoldable f =>
f e l -> [Strictness]
defaultGetStrictness Expr (Term gs) l
t

  getStrictness' x :: Expr (Term gs) l
x                  = Expr (Term gs) l -> [Strictness]
forall (f :: (* -> *) -> * -> *) (e :: * -> *) l.
HFoldable f =>
f e l -> [Strictness]
defaultGetStrictness Expr (Term gs) l
x

instance {-# OVERLAPPING #-} GetStrictness' g PyCondExpr where
  getStrictness' :: PyCondExpr (Term g) l -> [Strictness]
getStrictness' (PyCondExpr _ _ _) = [Strictness
Strict, Place -> Strictness
GuardedBy (Int -> Place
Place 0), Place -> Strictness
GuardedBy (Int -> Place
NegPlace 0)]



instance {-# OVERLAPPING #-} InsertAt' MPythonSig StatementL Statement where
  insertAt' :: NodeEvaluationPoint
-> AnnTerm a MPythonSig StatementL
-> (:&:) Statement a (AnnTerm a MPythonSig) i
-> m (AnnTerm a MPythonSig i)
insertAt' (BeforeIntermediateEvalPoint n :: Int
n) e :: AnnTerm a MPythonSig StatementL
e (Conditional clauses :: AnnTerm a MPythonSig [(ExprL, [StatementL])]
clauses els :: AnnTerm a MPythonSig [StatementL]
els _ :&: l :: a
l)
                | (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> 0) Bool -> Bool -> Bool
&& (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])]
-> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (AnnTerm a MPythonSig [(ExprL, [StatementL])]
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF AnnTerm a MPythonSig [(ExprL, [StatementL])]
clauses)) = do
      let (former :: [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])]
former, latter :: [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])]
latter) = Int
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])]
-> ([Cxt
       NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])],
    [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
n (AnnTerm a MPythonSig [(ExprL, [StatementL])]
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF AnnTerm a MPythonSig [(ExprL, [StatementL])]
clauses)
      AnnTerm a MPythonSig StatementL
innerCond <- Context (Sum MPythonSig) (AnnTerm a MPythonSig) StatementL
-> m (AnnTerm a MPythonSig StatementL)
forall (f :: (* -> *) -> * -> *) a (m :: * -> *) l.
(HTraversable f, MonadAnnotater a m) =>
Context f (AnnHFix a f) l -> m (AnnHFix a f l)
annotateOuter (Context (Sum MPythonSig) (AnnTerm a MPythonSig) StatementL
 -> m (AnnTerm a MPythonSig StatementL))
-> Context (Sum MPythonSig) (AnnTerm a MPythonSig) StatementL
-> m (AnnTerm a MPythonSig StatementL)
forall a b. (a -> b) -> a -> b
$ CxtS Hole MPythonSig (AnnTerm a MPythonSig) [(ExprL, [StatementL])]
-> CxtS Hole MPythonSig (AnnTerm a MPythonSig) [StatementL]
-> CxtS Hole MPythonSig (AnnTerm a MPythonSig) ()
-> Context (Sum MPythonSig) (AnnTerm a MPythonSig) StatementL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Statement :-<: fs, InjF fs StatementL j) =>
CxtS h fs a [(ExprL, [StatementL])]
-> CxtS h fs a [StatementL] -> CxtS h fs a () -> CxtS h fs a j
iConditional ([Cxt
   Hole (Sum MPythonSig) (AnnTerm a MPythonSig) (ExprL, [StatementL])]
-> CxtS
     Hole MPythonSig (AnnTerm a MPythonSig) [(ExprL, [StatementL])]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([Cxt
    Hole (Sum MPythonSig) (AnnTerm a MPythonSig) (ExprL, [StatementL])]
 -> CxtS
      Hole MPythonSig (AnnTerm a MPythonSig) [(ExprL, [StatementL])])
-> [Cxt
      Hole (Sum MPythonSig) (AnnTerm a MPythonSig) (ExprL, [StatementL])]
-> CxtS
     Hole MPythonSig (AnnTerm a MPythonSig) [(ExprL, [StatementL])]
forall a b. (a -> b) -> a -> b
$ (Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])
 -> Cxt
      Hole (Sum MPythonSig) (AnnTerm a MPythonSig) (ExprL, [StatementL]))
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])]
-> [Cxt
      Hole (Sum MPythonSig) (AnnTerm a MPythonSig) (ExprL, [StatementL])]
forall a b. (a -> b) -> [a] -> [b]
map Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])
-> Cxt
     Hole (Sum MPythonSig) (AnnTerm a MPythonSig) (ExprL, [StatementL])
forall (a :: * -> *) i (f :: (* -> *) -> * -> *).
a i -> Cxt Hole f a i
Hole [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])]
latter) (AnnTerm a MPythonSig [StatementL]
-> CxtS Hole MPythonSig (AnnTerm a MPythonSig) [StatementL]
forall (a :: * -> *) i (f :: (* -> *) -> * -> *).
a i -> Cxt Hole f a i
Hole AnnTerm a MPythonSig [StatementL]
els) CxtS Hole MPythonSig (AnnTerm a MPythonSig) ()
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(UnitF :-<: fs, InjF fs () j) =>
CxtS h fs a j
iUnitF
      AnnTerm a MPythonSig i
outerCond <- Context (Sum MPythonSig) (AnnTerm a MPythonSig) i
-> m (AnnTerm a MPythonSig i)
forall (f :: (* -> *) -> * -> *) a (m :: * -> *) l.
(HTraversable f, MonadAnnotater a m) =>
Context f (AnnHFix a f) l -> m (AnnHFix a f l)
annotateOuter (Context (Sum MPythonSig) (AnnTerm a MPythonSig) i
 -> m (AnnTerm a MPythonSig i))
-> Context (Sum MPythonSig) (AnnTerm a MPythonSig) i
-> m (AnnTerm a MPythonSig i)
forall a b. (a -> b) -> a -> b
$ CxtS Hole MPythonSig (AnnTerm a MPythonSig) [(ExprL, [StatementL])]
-> CxtS Hole MPythonSig (AnnTerm a MPythonSig) [StatementL]
-> CxtS Hole MPythonSig (AnnTerm a MPythonSig) ()
-> Context (Sum MPythonSig) (AnnTerm a MPythonSig) i
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Statement :-<: fs, InjF fs StatementL j) =>
CxtS h fs a [(ExprL, [StatementL])]
-> CxtS h fs a [StatementL] -> CxtS h fs a () -> CxtS h fs a j
iConditional ([Cxt
   Hole (Sum MPythonSig) (AnnTerm a MPythonSig) (ExprL, [StatementL])]
-> CxtS
     Hole MPythonSig (AnnTerm a MPythonSig) [(ExprL, [StatementL])]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([Cxt
    Hole (Sum MPythonSig) (AnnTerm a MPythonSig) (ExprL, [StatementL])]
 -> CxtS
      Hole MPythonSig (AnnTerm a MPythonSig) [(ExprL, [StatementL])])
-> [Cxt
      Hole (Sum MPythonSig) (AnnTerm a MPythonSig) (ExprL, [StatementL])]
-> CxtS
     Hole MPythonSig (AnnTerm a MPythonSig) [(ExprL, [StatementL])]
forall a b. (a -> b) -> a -> b
$ (Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])
 -> Cxt
      Hole (Sum MPythonSig) (AnnTerm a MPythonSig) (ExprL, [StatementL]))
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])]
-> [Cxt
      Hole (Sum MPythonSig) (AnnTerm a MPythonSig) (ExprL, [StatementL])]
forall a b. (a -> b) -> [a] -> [b]
map Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])
-> Cxt
     Hole (Sum MPythonSig) (AnnTerm a MPythonSig) (ExprL, [StatementL])
forall (a :: * -> *) i (f :: (* -> *) -> * -> *).
a i -> Cxt Hole f a i
Hole [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])]
former) ([Context (Sum MPythonSig) (AnnTerm a MPythonSig) StatementL]
-> CxtS Hole MPythonSig (AnnTerm a MPythonSig) [StatementL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF [AnnTerm a MPythonSig StatementL
-> Context (Sum MPythonSig) (AnnTerm a MPythonSig) StatementL
forall (a :: * -> *) i (f :: (* -> *) -> * -> *).
a i -> Cxt Hole f a i
Hole AnnTerm a MPythonSig StatementL
e, AnnTerm a MPythonSig StatementL
-> Context (Sum MPythonSig) (AnnTerm a MPythonSig) StatementL
forall (a :: * -> *) i (f :: (* -> *) -> * -> *).
a i -> Cxt Hole f a i
Hole AnnTerm a MPythonSig StatementL
innerCond]) CxtS Hole MPythonSig (AnnTerm a MPythonSig) ()
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(UnitF :-<: fs, InjF fs () j) =>
CxtS h fs a j
iUnitF
      AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i)
forall (m :: * -> *) a. Monad m => a -> m a
return AnnTerm a MPythonSig i
outerCond

  -- This case is hit when doing multiple inserts on the same conditional, causing some eval points to move into the else
  -- This doesn't really work because it just puts everything at the front, instead of where it's meant to go...
  insertAt' (BeforeIntermediateEvalPoint n :: Int
n) e :: AnnTerm a MPythonSig StatementL
e (Conditional clauses :: AnnTerm a MPythonSig [(ExprL, [StatementL])]
clauses els :: AnnTerm a MPythonSig [StatementL]
els u :: AnnTerm a MPythonSig ()
u :&: l :: a
l)
                | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])]
-> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (AnnTerm a MPythonSig [(ExprL, [StatementL])]
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF AnnTerm a MPythonSig [(ExprL, [StatementL])]
clauses)
    = do AnnTerm a MPythonSig [StatementL]
els' <- AnnTerm a MPythonSig StatementL
-> AnnTerm a MPythonSig [StatementL]
-> m (AnnTerm a MPythonSig [StatementL])
forall (gs :: [(* -> *) -> * -> *]) l a (m :: * -> *) i.
(InsertAt gs l, MonadAnnotater a m) =>
AnnTerm a gs l -> AnnTerm a gs i -> m (AnnTerm a gs i)
insertBefore AnnTerm a MPythonSig StatementL
e AnnTerm a MPythonSig [StatementL]
els
         AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i)
forall (m :: * -> *) a. Monad m => a -> m a
return (AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i))
-> AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i)
forall a b. (a -> b) -> a -> b
$ (:&:) Statement a (AnnTerm a MPythonSig) i
-> AnnTerm a MPythonSig i
forall (f :: (* -> *) -> * -> *) (g :: (* -> *) -> * -> *) p h
       (a :: * -> *).
(f :<: g) =>
(:&:) f p (Cxt h (g :&: p) a) :-> Cxt h (g :&: p) a
inject' ((:&:) Statement a (AnnTerm a MPythonSig) i
 -> AnnTerm a MPythonSig i)
-> (:&:) Statement a (AnnTerm a MPythonSig) i
-> AnnTerm a MPythonSig i
forall a b. (a -> b) -> a -> b
$ (AnnTerm a MPythonSig [(ExprL, [StatementL])]
-> AnnTerm a MPythonSig [StatementL]
-> AnnTerm a MPythonSig ()
-> Statement (AnnTerm a MPythonSig) i
forall (e :: * -> *) i.
(i ~ StatementL) =>
e [(ExprL, [StatementL])]
-> e [StatementL] -> e () -> Statement e i
Conditional AnnTerm a MPythonSig [(ExprL, [StatementL])]
clauses AnnTerm a MPythonSig [StatementL]
els' AnnTerm a MPythonSig ()
u) Statement (AnnTerm a MPythonSig) i
-> a -> (:&:) Statement a (AnnTerm a MPythonSig) i
forall k (f :: (* -> *) -> k -> *) a (g :: * -> *) (e :: k).
f g e -> a -> (:&:) f a g e
:&: a
l

  insertAt' _ _ t :: (:&:) Statement a (AnnTerm a MPythonSig) i
t = AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i)
forall (m :: * -> *) a. Monad m => a -> m a
return (AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i))
-> AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i)
forall a b. (a -> b) -> a -> b
$ (:&:) Statement a (AnnTerm a MPythonSig) i
-> AnnTerm a MPythonSig i
forall (f :: (* -> *) -> * -> *) (g :: (* -> *) -> * -> *) p h
       (a :: * -> *).
(f :<: g) =>
(:&:) f p (Cxt h (g :&: p) a) :-> Cxt h (g :&: p) a
inject' (:&:) Statement a (AnnTerm a MPythonSig) i
t

  -- If = 0, use normal insertion at the list level, not this kind which will split an if/elif
  canInsertAt' :: NodeEvaluationPoint
-> Proxy StatementL
-> (:&:) Statement a (AnnTerm a MPythonSig) i
-> Bool
canInsertAt' (BeforeIntermediateEvalPoint n :: Int
n) _ (Conditional clauses :: AnnTerm a MPythonSig [(ExprL, [StatementL])]
clauses _ _ :&: _) = (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> 0) Bool -> Bool -> Bool
&& (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])]
-> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (AnnTerm a MPythonSig [(ExprL, [StatementL])]
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) (ExprL, [StatementL])]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF AnnTerm a MPythonSig [(ExprL, [StatementL])]
clauses))
  canInsertAt' _                               _ _                               = Bool
False

instance {-# OVERLAPPING #-} InsertAt' MPythonSig BlockItemL Statement where
  insertAt' :: NodeEvaluationPoint
-> AnnTerm a MPythonSig BlockItemL
-> (:&:) Statement a (AnnTerm a MPythonSig) i
-> m (AnnTerm a MPythonSig i)
insertAt' p :: NodeEvaluationPoint
p (AnnTerm a MPythonSig BlockItemL
-> Maybe (StatementIsBlockItem (AnnTerm a MPythonSig) BlockItemL)
forall (f :: (* -> *) -> * -> *) (f' :: (* -> *) -> * -> *)
       (s :: (* -> *) -> * -> *) h (a :: * -> *) i.
(RemA f f', s :<: f') =>
Cxt h f a i -> Maybe (s (Cxt h f a) i)
project' -> Just (StatementIsBlockItem s :: Cxt NoHole (Sum MPythonSig :&: a) (K ()) StatementL
s)) t :: (:&:) Statement a (AnnTerm a MPythonSig) i
t = NodeEvaluationPoint
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) StatementL
-> (:&:) Statement a (AnnTerm a MPythonSig) i
-> m (AnnTerm a MPythonSig i)
forall (gs :: [(* -> *) -> * -> *]) l (f :: (* -> *) -> * -> *) a
       (m :: * -> *) i.
(InsertAt' gs l f, MonadAnnotater a m) =>
NodeEvaluationPoint
-> AnnTerm a gs l
-> (:&:) f a (AnnTerm a gs) i
-> m (AnnTerm a gs i)
insertAt' NodeEvaluationPoint
p Cxt NoHole (Sum MPythonSig :&: a) (K ()) StatementL
s (:&:) Statement a (AnnTerm a MPythonSig) i
t
  canInsertAt' :: NodeEvaluationPoint
-> Proxy BlockItemL
-> (:&:) Statement a (AnnTerm a MPythonSig) i
-> Bool
canInsertAt' p :: NodeEvaluationPoint
p _ t :: (:&:) Statement a (AnnTerm a MPythonSig) i
t = NodeEvaluationPoint
-> Proxy StatementL
-> (:&:) Statement a (AnnTerm a MPythonSig) i
-> Bool
forall (gs :: [(* -> *) -> * -> *]) l (f :: (* -> *) -> * -> *) a
       i.
InsertAt' gs l f =>
NodeEvaluationPoint
-> Proxy l -> (:&:) f a (AnnTerm a gs) i -> Bool
canInsertAt' NodeEvaluationPoint
p (Proxy StatementL
forall k (t :: k). Proxy t
Proxy :: Proxy StatementL) (:&:) Statement a (AnnTerm a MPythonSig) i
t


instance {-# OVERLAPPING #-} InsertAt' MPythonSig StatementL PyWith where
  insertAt' :: NodeEvaluationPoint
-> AnnTerm a MPythonSig StatementL
-> (:&:) PyWith a (AnnTerm a MPythonSig) i
-> m (AnnTerm a MPythonSig i)
insertAt' (BeforeIntermediateEvalPoint n :: Int
n) e :: AnnTerm a MPythonSig StatementL
e (PyWith binders :: AnnTerm a MPythonSig [PyWithBinderL]
binders body :: AnnTerm a MPythonSig [StatementL]
body :&: l :: a
l)
                  | (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> 0) Bool -> Bool -> Bool
&& (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (AnnTerm a MPythonSig [PyWithBinderL]
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF AnnTerm a MPythonSig [PyWithBinderL]
binders)) = do
      let (former :: [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL]
former, latter :: [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL]
latter) = Int
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL]
-> ([Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL],
    [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
n (AnnTerm a MPythonSig [PyWithBinderL]
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF AnnTerm a MPythonSig [PyWithBinderL]
binders)
      AnnTerm a MPythonSig StatementL
innerWith <- Context (Sum MPythonSig) (AnnTerm a MPythonSig) StatementL
-> m (AnnTerm a MPythonSig StatementL)
forall (f :: (* -> *) -> * -> *) a (m :: * -> *) l.
(HTraversable f, MonadAnnotater a m) =>
Context f (AnnHFix a f) l -> m (AnnHFix a f l)
annotateOuter (Context (Sum MPythonSig) (AnnTerm a MPythonSig) StatementL
 -> m (AnnTerm a MPythonSig StatementL))
-> Context (Sum MPythonSig) (AnnTerm a MPythonSig) StatementL
-> m (AnnTerm a MPythonSig StatementL)
forall a b. (a -> b) -> a -> b
$ CxtS Hole MPythonSig (AnnTerm a MPythonSig) [PyWithBinderL]
-> CxtS Hole MPythonSig (AnnTerm a MPythonSig) [StatementL]
-> Context (Sum MPythonSig) (AnnTerm a MPythonSig) StatementL
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 ([Cxt Hole (Sum MPythonSig) (AnnTerm a MPythonSig) PyWithBinderL]
-> CxtS Hole MPythonSig (AnnTerm a MPythonSig) [PyWithBinderL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([Cxt Hole (Sum MPythonSig) (AnnTerm a MPythonSig) PyWithBinderL]
 -> CxtS Hole MPythonSig (AnnTerm a MPythonSig) [PyWithBinderL])
-> [Cxt Hole (Sum MPythonSig) (AnnTerm a MPythonSig) PyWithBinderL]
-> CxtS Hole MPythonSig (AnnTerm a MPythonSig) [PyWithBinderL]
forall a b. (a -> b) -> a -> b
$ (Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL
 -> Cxt Hole (Sum MPythonSig) (AnnTerm a MPythonSig) PyWithBinderL)
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL]
-> [Cxt Hole (Sum MPythonSig) (AnnTerm a MPythonSig) PyWithBinderL]
forall a b. (a -> b) -> [a] -> [b]
map Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL
-> Cxt Hole (Sum MPythonSig) (AnnTerm a MPythonSig) PyWithBinderL
forall (a :: * -> *) i (f :: (* -> *) -> * -> *).
a i -> Cxt Hole f a i
Hole [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL]
latter) (AnnTerm a MPythonSig [StatementL]
-> CxtS Hole MPythonSig (AnnTerm a MPythonSig) [StatementL]
forall (a :: * -> *) i (f :: (* -> *) -> * -> *).
a i -> Cxt Hole f a i
Hole AnnTerm a MPythonSig [StatementL]
body)
      AnnTerm a MPythonSig i
outerWith <- Context (Sum MPythonSig) (AnnTerm a MPythonSig) i
-> m (AnnTerm a MPythonSig i)
forall (f :: (* -> *) -> * -> *) a (m :: * -> *) l.
(HTraversable f, MonadAnnotater a m) =>
Context f (AnnHFix a f) l -> m (AnnHFix a f l)
annotateOuter (Context (Sum MPythonSig) (AnnTerm a MPythonSig) i
 -> m (AnnTerm a MPythonSig i))
-> Context (Sum MPythonSig) (AnnTerm a MPythonSig) i
-> m (AnnTerm a MPythonSig i)
forall a b. (a -> b) -> a -> b
$ CxtS Hole MPythonSig (AnnTerm a MPythonSig) [PyWithBinderL]
-> CxtS Hole MPythonSig (AnnTerm a MPythonSig) [StatementL]
-> Context (Sum MPythonSig) (AnnTerm a MPythonSig) i
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 ([Cxt Hole (Sum MPythonSig) (AnnTerm a MPythonSig) PyWithBinderL]
-> CxtS Hole MPythonSig (AnnTerm a MPythonSig) [PyWithBinderL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([Cxt Hole (Sum MPythonSig) (AnnTerm a MPythonSig) PyWithBinderL]
 -> CxtS Hole MPythonSig (AnnTerm a MPythonSig) [PyWithBinderL])
-> [Cxt Hole (Sum MPythonSig) (AnnTerm a MPythonSig) PyWithBinderL]
-> CxtS Hole MPythonSig (AnnTerm a MPythonSig) [PyWithBinderL]
forall a b. (a -> b) -> a -> b
$ (Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL
 -> Cxt Hole (Sum MPythonSig) (AnnTerm a MPythonSig) PyWithBinderL)
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL]
-> [Cxt Hole (Sum MPythonSig) (AnnTerm a MPythonSig) PyWithBinderL]
forall a b. (a -> b) -> [a] -> [b]
map Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL
-> Cxt Hole (Sum MPythonSig) (AnnTerm a MPythonSig) PyWithBinderL
forall (a :: * -> *) i (f :: (* -> *) -> * -> *).
a i -> Cxt Hole f a i
Hole [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL]
former) ([Context (Sum MPythonSig) (AnnTerm a MPythonSig) StatementL]
-> CxtS Hole MPythonSig (AnnTerm a MPythonSig) [StatementL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF [AnnTerm a MPythonSig StatementL
-> Context (Sum MPythonSig) (AnnTerm a MPythonSig) StatementL
forall (a :: * -> *) i (f :: (* -> *) -> * -> *).
a i -> Cxt Hole f a i
Hole AnnTerm a MPythonSig StatementL
e, AnnTerm a MPythonSig StatementL
-> Context (Sum MPythonSig) (AnnTerm a MPythonSig) StatementL
forall (a :: * -> *) i (f :: (* -> *) -> * -> *).
a i -> Cxt Hole f a i
Hole AnnTerm a MPythonSig StatementL
innerWith])
      AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i)
forall (m :: * -> *) a. Monad m => a -> m a
return AnnTerm a MPythonSig i
outerWith

  insertAt' (BeforeIntermediateEvalPoint n :: Int
n) e :: AnnTerm a MPythonSig StatementL
e (PyWith binders :: AnnTerm a MPythonSig [PyWithBinderL]
binders body :: AnnTerm a MPythonSig [StatementL]
body :&: l :: a
l)
                 | (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (AnnTerm a MPythonSig [PyWithBinderL]
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF AnnTerm a MPythonSig [PyWithBinderL]
binders))
    = do AnnTerm a MPythonSig [StatementL]
body' <- AnnTerm a MPythonSig StatementL
-> AnnTerm a MPythonSig [StatementL]
-> m (AnnTerm a MPythonSig [StatementL])
forall (gs :: [(* -> *) -> * -> *]) l a (m :: * -> *) i.
(InsertAt gs l, MonadAnnotater a m) =>
AnnTerm a gs l -> AnnTerm a gs i -> m (AnnTerm a gs i)
insertBefore AnnTerm a MPythonSig StatementL
e AnnTerm a MPythonSig [StatementL]
body
         AnnTerm a MPythonSig StatementL -> m (AnnTerm a MPythonSig i)
forall (m :: * -> *) a. Monad m => a -> m a
return (AnnTerm a MPythonSig StatementL -> m (AnnTerm a MPythonSig i))
-> AnnTerm a MPythonSig StatementL -> m (AnnTerm a MPythonSig i)
forall a b. (a -> b) -> a -> b
$ (:&:) PyWith a (AnnTerm a MPythonSig) StatementL
-> AnnTerm a MPythonSig StatementL
forall (f :: (* -> *) -> * -> *) (g :: (* -> *) -> * -> *) p h
       (a :: * -> *).
(f :<: g) =>
(:&:) f p (Cxt h (g :&: p) a) :-> Cxt h (g :&: p) a
inject' ((:&:) PyWith a (AnnTerm a MPythonSig) StatementL
 -> AnnTerm a MPythonSig StatementL)
-> (:&:) PyWith a (AnnTerm a MPythonSig) StatementL
-> AnnTerm a MPythonSig StatementL
forall a b. (a -> b) -> a -> b
$ (AnnTerm a MPythonSig [PyWithBinderL]
-> AnnTerm a MPythonSig [StatementL]
-> PyWith (AnnTerm a MPythonSig) StatementL
forall (e :: * -> *).
e [PyWithBinderL] -> e [StatementL] -> PyWith e StatementL
PyWith AnnTerm a MPythonSig [PyWithBinderL]
binders AnnTerm a MPythonSig [StatementL]
body') PyWith (AnnTerm a MPythonSig) StatementL
-> a -> (:&:) PyWith a (AnnTerm a MPythonSig) StatementL
forall k (f :: (* -> *) -> k -> *) a (g :: * -> *) (e :: k).
f g e -> a -> (:&:) f a g e
:&: a
l

  insertAt' _ _ t :: (:&:) PyWith a (AnnTerm a MPythonSig) i
t = AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i)
forall (m :: * -> *) a. Monad m => a -> m a
return (AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i))
-> AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i)
forall a b. (a -> b) -> a -> b
$ (:&:) PyWith a (AnnTerm a MPythonSig) i -> AnnTerm a MPythonSig i
forall (f :: (* -> *) -> * -> *) (g :: (* -> *) -> * -> *) p h
       (a :: * -> *).
(f :<: g) =>
(:&:) f p (Cxt h (g :&: p) a) :-> Cxt h (g :&: p) a
inject' (:&:) PyWith a (AnnTerm a MPythonSig) i
t


  canInsertAt' :: NodeEvaluationPoint
-> Proxy StatementL
-> (:&:) PyWith a (AnnTerm a MPythonSig) i
-> Bool
canInsertAt' (BeforeIntermediateEvalPoint n :: Int
n) _ (PyWith binders :: AnnTerm a MPythonSig [PyWithBinderL]
binders _ :&: _) = (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> 0) Bool -> Bool -> Bool
&& (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (AnnTerm a MPythonSig [PyWithBinderL]
-> [Cxt NoHole (Sum MPythonSig :&: a) (K ()) PyWithBinderL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF AnnTerm a MPythonSig [PyWithBinderL]
binders))
  canInsertAt' _                               _ _                        = Bool
False

instance {-# OVERLAPPING #-} InsertAt' MPythonSig BlockItemL PyWith where
  insertAt' :: NodeEvaluationPoint
-> AnnTerm a MPythonSig BlockItemL
-> (:&:) PyWith a (AnnTerm a MPythonSig) i
-> m (AnnTerm a MPythonSig i)
insertAt' p :: NodeEvaluationPoint
p (AnnTerm a MPythonSig BlockItemL
-> Maybe (StatementIsBlockItem (AnnTerm a MPythonSig) BlockItemL)
forall (f :: (* -> *) -> * -> *) (f' :: (* -> *) -> * -> *)
       (s :: (* -> *) -> * -> *) h (a :: * -> *) i.
(RemA f f', s :<: f') =>
Cxt h f a i -> Maybe (s (Cxt h f a) i)
project' -> Just (StatementIsBlockItem s :: Cxt NoHole (Sum MPythonSig :&: a) (K ()) StatementL
s)) t :: (:&:) PyWith a (AnnTerm a MPythonSig) i
t = NodeEvaluationPoint
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) StatementL
-> (:&:) PyWith a (AnnTerm a MPythonSig) i
-> m (AnnTerm a MPythonSig i)
forall (gs :: [(* -> *) -> * -> *]) l (f :: (* -> *) -> * -> *) a
       (m :: * -> *) i.
(InsertAt' gs l f, MonadAnnotater a m) =>
NodeEvaluationPoint
-> AnnTerm a gs l
-> (:&:) f a (AnnTerm a gs) i
-> m (AnnTerm a gs i)
insertAt' NodeEvaluationPoint
p Cxt NoHole (Sum MPythonSig :&: a) (K ()) StatementL
s (:&:) PyWith a (AnnTerm a MPythonSig) i
t
  canInsertAt' :: NodeEvaluationPoint
-> Proxy BlockItemL
-> (:&:) PyWith a (AnnTerm a MPythonSig) i
-> Bool
canInsertAt' p :: NodeEvaluationPoint
p _ t :: (:&:) PyWith a (AnnTerm a MPythonSig) i
t = NodeEvaluationPoint
-> Proxy StatementL
-> (:&:) PyWith a (AnnTerm a MPythonSig) i
-> Bool
forall (gs :: [(* -> *) -> * -> *]) l (f :: (* -> *) -> * -> *) a
       i.
InsertAt' gs l f =>
NodeEvaluationPoint
-> Proxy l -> (:&:) f a (AnnTerm a gs) i -> Bool
canInsertAt' NodeEvaluationPoint
p (Proxy StatementL
forall k (t :: k). Proxy t
Proxy :: Proxy StatementL) (:&:) PyWith a (AnnTerm a MPythonSig) i
t

-- We can insert statements before lists of statements, *or* before lists of BlockItem's
-- Python has both because scoping
instance {-# OVERLAPPING #-} InsertAt' MPythonSig StatementL ListF where
  insertAt' :: NodeEvaluationPoint
-> AnnTerm a MPythonSig StatementL
-> (:&:) ListF a (AnnTerm a MPythonSig) i
-> m (AnnTerm a MPythonSig i)
insertAt' EnterEvalPoint e :: AnnTerm a MPythonSig StatementL
e t :: (:&:) ListF a (AnnTerm a MPythonSig) i
t =
                      case (:&:) ListF a (AnnTerm a MPythonSig) i
-> Maybe (i :~: [StatementL])
forall (f :: (* -> *) -> * -> *) a (e :: * -> *) b.
KDynCase f a =>
f e b -> Maybe (b :~: a)
kdyncase (:&:) ListF a (AnnTerm a MPythonSig) i
t :: Maybe (_ :~: [StatementL]) of
                        Just p :: i :~: [StatementL]
p  -> (i :~: [StatementL])
-> ((i ~ [StatementL]) => m (AnnTerm a MPythonSig i))
-> m (AnnTerm a MPythonSig i)
forall k (a :: k) (b :: k) r. (a :~: b) -> ((a ~ b) => r) -> r
gcastWith i :~: [StatementL]
p (((i ~ [StatementL]) => m (AnnTerm a MPythonSig i))
 -> m (AnnTerm a MPythonSig i))
-> ((i ~ [StatementL]) => m (AnnTerm a MPythonSig i))
-> m (AnnTerm a MPythonSig i)
forall a b. (a -> b) -> a -> b
$ (:&:) ListF a (AnnTerm a MPythonSig) [StatementL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [StatementL]
forall (f :: (* -> *) -> * -> *) (g :: (* -> *) -> * -> *) p h
       (a :: * -> *).
(f :<: g) =>
(:&:) f p (Cxt h (g :&: p) a) :-> Cxt h (g :&: p) a
inject' ((:&:) ListF a (AnnTerm a MPythonSig) [StatementL]
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [StatementL])
-> m ((:&:) ListF a (AnnTerm a MPythonSig) [StatementL])
-> m (Cxt NoHole (Sum MPythonSig :&: a) (K ()) [StatementL])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ListF (AnnTerm a MPythonSig) [StatementL]
-> m ((:&:) ListF a (AnnTerm a MPythonSig) [StatementL])
forall a (m :: * -> *) (f :: (* -> *) -> * -> *) (e :: * -> *) l.
MonadAnnotater a m =>
f e l -> m ((:&:) f a e l)
annM (AnnTerm a MPythonSig StatementL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [StatementL]
-> ListF (AnnTerm a MPythonSig) [StatementL]
forall l (e :: * -> *). Typeable l => e l -> e [l] -> ListF e [l]
ConsF AnnTerm a MPythonSig StatementL
e ((:&:) ListF a (AnnTerm a MPythonSig) i -> AnnTerm a MPythonSig i
forall (f :: (* -> *) -> * -> *) (g :: (* -> *) -> * -> *) p h
       (a :: * -> *).
(f :<: g) =>
(:&:) f p (Cxt h (g :&: p) a) :-> Cxt h (g :&: p) a
inject' (:&:) ListF a (AnnTerm a MPythonSig) i
t))
                        Nothing -> case (:&:) ListF a (AnnTerm a MPythonSig) i
-> Maybe (i :~: [BlockItemL])
forall (f :: (* -> *) -> * -> *) a (e :: * -> *) b.
KDynCase f a =>
f e b -> Maybe (b :~: a)
kdyncase (:&:) ListF a (AnnTerm a MPythonSig) i
t :: (Maybe (_ :~: [BlockItemL])) of
                                     Nothing -> AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i)
forall (m :: * -> *) a. Monad m => a -> m a
return (AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i))
-> AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i)
forall a b. (a -> b) -> a -> b
$ (:&:) ListF a (AnnTerm a MPythonSig) i -> AnnTerm a MPythonSig i
forall (f :: (* -> *) -> * -> *) (g :: (* -> *) -> * -> *) p h
       (a :: * -> *).
(f :<: g) =>
(:&:) f p (Cxt h (g :&: p) a) :-> Cxt h (g :&: p) a
inject' (:&:) ListF a (AnnTerm a MPythonSig) i
t
                                     Just p :: i :~: [BlockItemL]
p  -> (i :~: [BlockItemL])
-> ((i ~ [BlockItemL]) => m (AnnTerm a MPythonSig i))
-> m (AnnTerm a MPythonSig i)
forall k (a :: k) (b :: k) r. (a :~: b) -> ((a ~ b) => r) -> r
gcastWith i :~: [BlockItemL]
p (((i ~ [BlockItemL]) => m (AnnTerm a MPythonSig i))
 -> m (AnnTerm a MPythonSig i))
-> ((i ~ [BlockItemL]) => m (AnnTerm a MPythonSig i))
-> m (AnnTerm a MPythonSig i)
forall a b. (a -> b) -> a -> b
$ ((:&:) ListF a (AnnTerm a MPythonSig) [BlockItemL]
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [BlockItemL])
-> m ((:&:) ListF a (AnnTerm a MPythonSig) [BlockItemL])
-> m (Cxt NoHole (Sum MPythonSig :&: a) (K ()) [BlockItemL])
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (:&:) ListF a (AnnTerm a MPythonSig) [BlockItemL]
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [BlockItemL]
forall (f :: (* -> *) -> * -> *) (g :: (* -> *) -> * -> *) p h
       (a :: * -> *).
(f :<: g) =>
(:&:) f p (Cxt h (g :&: p) a) :-> Cxt h (g :&: p) a
inject' (m ((:&:) ListF a (AnnTerm a MPythonSig) [BlockItemL])
 -> m (AnnTerm a MPythonSig i))
-> m ((:&:) ListF a (AnnTerm a MPythonSig) [BlockItemL])
-> m (AnnTerm a MPythonSig i)
forall a b. (a -> b) -> a -> b
$ ListF (AnnTerm a MPythonSig) [BlockItemL]
-> m ((:&:) ListF a (AnnTerm a MPythonSig) [BlockItemL])
forall a (m :: * -> *) (f :: (* -> *) -> * -> *) (e :: * -> *) l.
MonadAnnotater a m =>
f e l -> m ((:&:) f a e l)
annM (ListF (AnnTerm a MPythonSig) [BlockItemL]
 -> m ((:&:) ListF a (AnnTerm a MPythonSig) [BlockItemL]))
-> m (ListF (AnnTerm a MPythonSig) [BlockItemL])
-> m ((:&:) ListF a (AnnTerm a MPythonSig) [BlockItemL])
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockItemL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [BlockItemL]
-> ListF (AnnTerm a MPythonSig) [BlockItemL]
forall l (e :: * -> *). Typeable l => e l -> e [l] -> ListF e [l]
ConsF (Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockItemL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) [BlockItemL]
 -> ListF (AnnTerm a MPythonSig) [BlockItemL])
-> m (Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockItemL)
-> m (Cxt NoHole (Sum MPythonSig :&: a) (K ()) [BlockItemL]
      -> ListF (AnnTerm a MPythonSig) [BlockItemL])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((:&:) StatementIsBlockItem a (AnnTerm a MPythonSig) BlockItemL
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockItemL
forall (f :: (* -> *) -> * -> *) (g :: (* -> *) -> * -> *) p h
       (a :: * -> *).
(f :<: g) =>
(:&:) f p (Cxt h (g :&: p) a) :-> Cxt h (g :&: p) a
inject' ((:&:) StatementIsBlockItem a (AnnTerm a MPythonSig) BlockItemL
 -> Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockItemL)
-> m ((:&:)
        StatementIsBlockItem a (AnnTerm a MPythonSig) BlockItemL)
-> m (Cxt NoHole (Sum MPythonSig :&: a) (K ()) BlockItemL)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (StatementIsBlockItem (AnnTerm a MPythonSig) BlockItemL
-> m ((:&:)
        StatementIsBlockItem a (AnnTerm a MPythonSig) BlockItemL)
forall a (m :: * -> *) (f :: (* -> *) -> * -> *) (e :: * -> *) l.
MonadAnnotater a m =>
f e l -> m ((:&:) f a e l)
annM (StatementIsBlockItem (AnnTerm a MPythonSig) BlockItemL
 -> m ((:&:)
         StatementIsBlockItem a (AnnTerm a MPythonSig) BlockItemL))
-> StatementIsBlockItem (AnnTerm a MPythonSig) BlockItemL
-> m ((:&:)
        StatementIsBlockItem a (AnnTerm a MPythonSig) BlockItemL)
forall a b. (a -> b) -> a -> b
$ AnnTerm a MPythonSig StatementL
-> StatementIsBlockItem (AnnTerm a MPythonSig) BlockItemL
forall (e :: * -> *) i.
(i ~ BlockItemL) =>
e StatementL -> StatementIsBlockItem e i
StatementIsBlockItem AnnTerm a MPythonSig StatementL
e)) m (Cxt NoHole (Sum MPythonSig :&: a) (K ()) [BlockItemL]
   -> ListF (AnnTerm a MPythonSig) [BlockItemL])
-> m (Cxt NoHole (Sum MPythonSig :&: a) (K ()) [BlockItemL])
-> m (ListF (AnnTerm a MPythonSig) [BlockItemL])
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((:&:) ListF a (AnnTerm a MPythonSig) i -> AnnTerm a MPythonSig i
forall (f :: (* -> *) -> * -> *) (g :: (* -> *) -> * -> *) p h
       (a :: * -> *).
(f :<: g) =>
(:&:) f p (Cxt h (g :&: p) a) :-> Cxt h (g :&: p) a
inject' (:&:) ListF a (AnnTerm a MPythonSig) i
t))
  insertAt' _ _ t :: (:&:) ListF a (AnnTerm a MPythonSig) i
t = AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i)
forall (m :: * -> *) a. Monad m => a -> m a
return (AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i))
-> AnnTerm a MPythonSig i -> m (AnnTerm a MPythonSig i)
forall a b. (a -> b) -> a -> b
$ (:&:) ListF a (AnnTerm a MPythonSig) i -> AnnTerm a MPythonSig i
forall (f :: (* -> *) -> * -> *) (g :: (* -> *) -> * -> *) p h
       (a :: * -> *).
(f :<: g) =>
(:&:) f p (Cxt h (g :&: p) a) :-> Cxt h (g :&: p) a
inject' (:&:) ListF a (AnnTerm a MPythonSig) i
t

  canInsertAt' :: NodeEvaluationPoint
-> Proxy StatementL
-> (:&:) ListF a (AnnTerm a MPythonSig) i
-> Bool
canInsertAt' EnterEvalPoint _  t :: (:&:) ListF a (AnnTerm a MPythonSig) i
t =    Proxy [StatementL]
-> (:&:) ListF a (AnnTerm a MPythonSig) i -> Bool
forall (f :: (* -> *) -> * -> *) l.
KDynCase f l =>
Proxy l -> forall i (e :: * -> *). f e i -> Bool
kIsSort (Proxy [StatementL]
forall k (t :: k). Proxy t
Proxy :: Proxy [StatementL]) (:&:) ListF a (AnnTerm a MPythonSig) i
t
                                     Bool -> Bool -> Bool
|| Proxy [BlockItemL]
-> (:&:) ListF a (AnnTerm a MPythonSig) i -> Bool
forall (f :: (* -> *) -> * -> *) l.
KDynCase f l =>
Proxy l -> forall i (e :: * -> *). f e i -> Bool
kIsSort (Proxy [BlockItemL]
forall k (t :: k). Proxy t
Proxy :: Proxy [BlockItemL]) (:&:) ListF a (AnnTerm a MPythonSig) i
t
  canInsertAt' _              _  _ = Bool
False

instance {-# OVERLAPPING #-} InsertAt' MPythonSig BlockItemL ListF where
  insertAt' :: NodeEvaluationPoint
-> AnnTerm a MPythonSig BlockItemL
-> (:&:) ListF a (AnnTerm a MPythonSig) i
-> m (AnnTerm a MPythonSig i)
insertAt' p :: NodeEvaluationPoint
p (AnnTerm a MPythonSig BlockItemL
-> Maybe (StatementIsBlockItem (AnnTerm a MPythonSig) BlockItemL)
forall (f :: (* -> *) -> * -> *) (f' :: (* -> *) -> * -> *)
       (s :: (* -> *) -> * -> *) h (a :: * -> *) i.
(RemA f f', s :<: f') =>
Cxt h f a i -> Maybe (s (Cxt h f a) i)
project' -> Just (StatementIsBlockItem s :: Cxt NoHole (Sum MPythonSig :&: a) (K ()) StatementL
s)) t :: (:&:) ListF a (AnnTerm a MPythonSig) i
t = NodeEvaluationPoint
-> Cxt NoHole (Sum MPythonSig :&: a) (K ()) StatementL
-> (:&:) ListF a (AnnTerm a MPythonSig) i
-> m (AnnTerm a MPythonSig i)
forall (gs :: [(* -> *) -> * -> *]) l (f :: (* -> *) -> * -> *) a
       (m :: * -> *) i.
(InsertAt' gs l f, MonadAnnotater a m) =>
NodeEvaluationPoint
-> AnnTerm a gs l
-> (:&:) f a (AnnTerm a gs) i
-> m (AnnTerm a gs i)
insertAt' NodeEvaluationPoint
p Cxt NoHole (Sum MPythonSig :&: a) (K ()) StatementL
s (:&:) ListF a (AnnTerm a MPythonSig) i
t
  canInsertAt' :: NodeEvaluationPoint
-> Proxy BlockItemL
-> (:&:) ListF a (AnnTerm a MPythonSig) i
-> Bool
canInsertAt' p :: NodeEvaluationPoint
p _ t :: (:&:) ListF a (AnnTerm a MPythonSig) i
t = NodeEvaluationPoint
-> Proxy StatementL
-> (:&:) ListF a (AnnTerm a MPythonSig) i
-> Bool
forall (gs :: [(* -> *) -> * -> *]) l (f :: (* -> *) -> * -> *) a
       i.
InsertAt' gs l f =>
NodeEvaluationPoint
-> Proxy l -> (:&:) f a (AnnTerm a gs) i -> Bool
canInsertAt' NodeEvaluationPoint
p (Proxy StatementL
forall k (t :: k). Proxy t
Proxy :: Proxy StatementL) (:&:) ListF a (AnnTerm a MPythonSig) i
t

#endif