{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ViewPatterns, MultiParamTypeClasses , FlexibleInstances, FlexibleContexts #-}
{-# LANGUAGE TupleSections #-}

--  Keep until 'descendApps', 'transformApps' and 'allowLeftSection'
-- are used.
{-# OPTIONS_GHC -Wno-unused-top-binds #-}

module GHC.Util.HsExpr (
    dotApp', dotApps'
  , simplifyExp', niceLambda', niceDotApp'
  , Brackets'(..)
  , rebracket1', appsBracket', transformAppsM', fromApps', apps', universeApps', universeParentExp'
  , paren'
  , replaceBranches'
  , needBracketOld', transformBracketOld', descendBracketOld', reduce', reduce1', fromParen1'
) where

import HsSyn
import BasicTypes
import SrcLoc
import FastString
import RdrName
import OccName
import Bag(bagToList)

import GHC.Util.Brackets
import GHC.Util.View
import GHC.Util.FreeVars
import GHC.Util.Pat

import Control.Applicative
import Control.Monad.Trans.State

import Data.Data
import Data.Generics.Uniplate.Data
import Data.List.Extra
import Data.Tuple.Extra

import Refact.Types hiding (Match)
import qualified Refact.Types as R (SrcSpan)

import Language.Haskell.GhclibParserEx.GHC.Hs.Expr
import Language.Haskell.GhclibParserEx.GHC.Hs.ExtendInstances

-- | 'dotApp a b' makes 'a . b'.
dotApp' :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
dotApp' :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
dotApp' x :: LHsExpr GhcPs
x y :: LHsExpr GhcPs
y = SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs)
-> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a -> b) -> a -> b
$ XOpApp GhcPs
-> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p.
XOpApp p -> LHsExpr p -> LHsExpr p -> LHsExpr p -> HsExpr p
OpApp NoExt
XOpApp GhcPs
noExt LHsExpr GhcPs
x (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs)
-> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a -> b) -> a -> b
$ XVar GhcPs -> Located (IdP GhcPs) -> HsExpr GhcPs
forall p. XVar p -> Located (IdP p) -> HsExpr p
HsVar NoExt
XVar GhcPs
noExt (SrcSpanLess (Located RdrName) -> Located (IdP GhcPs)
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc (SrcSpanLess (Located RdrName) -> Located (IdP GhcPs))
-> SrcSpanLess (Located RdrName) -> Located (IdP GhcPs)
forall a b. (a -> b) -> a -> b
$ FastString -> RdrName
mkVarUnqual (String -> FastString
fsLit "."))) LHsExpr GhcPs
y

dotApps' :: [LHsExpr GhcPs] -> LHsExpr GhcPs
dotApps' :: [LHsExpr GhcPs] -> LHsExpr GhcPs
dotApps' [] = String -> LHsExpr GhcPs
forall a. HasCallStack => String -> a
error "GHC.Util.HsExpr.dotApps', does not work on an empty list"
dotApps' [x :: LHsExpr GhcPs
x] = LHsExpr GhcPs
x
dotApps' (x :: LHsExpr GhcPs
x : xs :: [LHsExpr GhcPs]
xs) = LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
dotApp' LHsExpr GhcPs
x ([LHsExpr GhcPs] -> LHsExpr GhcPs
dotApps' [LHsExpr GhcPs]
xs)

-- | 'paren e' wraps 'e' in parens if 'e' is non-atomic.
paren' :: LHsExpr GhcPs -> LHsExpr GhcPs
paren' :: LHsExpr GhcPs -> LHsExpr GhcPs
paren' x :: LHsExpr GhcPs
x
  | LHsExpr GhcPs -> Bool
forall a. Brackets' a => a -> Bool
isAtom' LHsExpr GhcPs
x  = LHsExpr GhcPs
x
  | Bool
otherwise = LHsExpr GhcPs -> LHsExpr GhcPs
forall a. Brackets' a => a -> a
addParen' LHsExpr GhcPs
x

universeParentExp' :: Data a => a -> [(Maybe (Int, LHsExpr GhcPs), LHsExpr GhcPs)]
universeParentExp' :: a -> [(Maybe (Int, LHsExpr GhcPs), LHsExpr GhcPs)]
universeParentExp' xs :: a
xs = [[(Maybe (Int, LHsExpr GhcPs), LHsExpr GhcPs)]]
-> [(Maybe (Int, LHsExpr GhcPs), LHsExpr GhcPs)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [(Maybe (Int, LHsExpr GhcPs)
forall a. Maybe a
Nothing, LHsExpr GhcPs
x) (Maybe (Int, LHsExpr GhcPs), LHsExpr GhcPs)
-> [(Maybe (Int, LHsExpr GhcPs), LHsExpr GhcPs)]
-> [(Maybe (Int, LHsExpr GhcPs), LHsExpr GhcPs)]
forall a. a -> [a] -> [a]
: LHsExpr GhcPs -> [(Maybe (Int, LHsExpr GhcPs), LHsExpr GhcPs)]
forall a t. (Num a, Enum a, Data t) => t -> [(Maybe (a, t), t)]
f LHsExpr GhcPs
x | LHsExpr GhcPs
x <- a -> [LHsExpr GhcPs]
forall from to. Biplate from to => from -> [to]
childrenBi a
xs]
    where f :: t -> [(Maybe (a, t), t)]
f p :: t
p = [[(Maybe (a, t), t)]] -> [(Maybe (a, t), t)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [((a, t) -> Maybe (a, t)
forall a. a -> Maybe a
Just (a
i,t
p), t
c) (Maybe (a, t), t) -> [(Maybe (a, t), t)] -> [(Maybe (a, t), t)]
forall a. a -> [a] -> [a]
: t -> [(Maybe (a, t), t)]
f t
c | (i :: a
i,c :: t
c) <- [a] -> [t] -> [(a, t)]
forall a b. [a] -> [b] -> [(a, b)]
zip [0..] ([t] -> [(a, t)]) -> [t] -> [(a, t)]
forall a b. (a -> b) -> a -> b
$ t -> [t]
forall on. Uniplate on => on -> [on]
children t
p]


apps' :: [LHsExpr GhcPs] -> LHsExpr GhcPs
apps' :: [LHsExpr GhcPs] -> LHsExpr GhcPs
apps' = (LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs)
-> [LHsExpr GhcPs] -> LHsExpr GhcPs
forall a. (a -> a -> a) -> [a] -> a
foldl1' LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
forall a p.
(HasSrcSpan a, XApp p ~ NoExt, SrcSpanLess a ~ HsExpr p) =>
LHsExpr p -> LHsExpr p -> a
mkApp where mkApp :: LHsExpr p -> LHsExpr p -> a
mkApp x :: LHsExpr p
x y :: LHsExpr p
y = SrcSpanLess a -> a
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc (XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp NoExt
XApp p
noExt LHsExpr p
x LHsExpr p
y)

fromApps' :: LHsExpr GhcPs  -> [LHsExpr GhcPs]
fromApps' :: LHsExpr GhcPs -> [LHsExpr GhcPs]
fromApps' (LL _ (HsApp _ x y)) = LHsExpr GhcPs -> [LHsExpr GhcPs]
fromApps' LHsExpr GhcPs
x [LHsExpr GhcPs] -> [LHsExpr GhcPs] -> [LHsExpr GhcPs]
forall a. [a] -> [a] -> [a]
++ [LHsExpr GhcPs
y]
fromApps' x :: LHsExpr GhcPs
x = [LHsExpr GhcPs
x]

childrenApps' :: LHsExpr GhcPs -> [LHsExpr GhcPs]
childrenApps' :: LHsExpr GhcPs -> [LHsExpr GhcPs]
childrenApps' (LL _ (HsApp _ x y)) = LHsExpr GhcPs -> [LHsExpr GhcPs]
childrenApps' LHsExpr GhcPs
x [LHsExpr GhcPs] -> [LHsExpr GhcPs] -> [LHsExpr GhcPs]
forall a. [a] -> [a] -> [a]
++ [LHsExpr GhcPs
y]
childrenApps' x :: LHsExpr GhcPs
x = LHsExpr GhcPs -> [LHsExpr GhcPs]
forall on. Uniplate on => on -> [on]
children LHsExpr GhcPs
x

universeApps' :: LHsExpr GhcPs -> [LHsExpr GhcPs]
universeApps' :: LHsExpr GhcPs -> [LHsExpr GhcPs]
universeApps' x :: LHsExpr GhcPs
x = LHsExpr GhcPs
x LHsExpr GhcPs -> [LHsExpr GhcPs] -> [LHsExpr GhcPs]
forall a. a -> [a] -> [a]
: (LHsExpr GhcPs -> [LHsExpr GhcPs])
-> [LHsExpr GhcPs] -> [LHsExpr GhcPs]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap LHsExpr GhcPs -> [LHsExpr GhcPs]
universeApps' (LHsExpr GhcPs -> [LHsExpr GhcPs]
childrenApps' LHsExpr GhcPs
x)

descendApps' :: (LHsExpr GhcPs -> LHsExpr GhcPs) -> LHsExpr GhcPs -> LHsExpr GhcPs
descendApps' :: (LHsExpr GhcPs -> LHsExpr GhcPs) -> LHsExpr GhcPs -> LHsExpr GhcPs
descendApps' f :: LHsExpr GhcPs -> LHsExpr GhcPs
f (LL l :: SrcSpan
l (HsApp _ x y)) = SrcSpan -> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
LL SrcSpan
l (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs)
-> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a -> b) -> a -> b
$ XApp GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp NoExt
XApp GhcPs
noExt ((LHsExpr GhcPs -> LHsExpr GhcPs) -> LHsExpr GhcPs -> LHsExpr GhcPs
descendApps' LHsExpr GhcPs -> LHsExpr GhcPs
f LHsExpr GhcPs
x) (LHsExpr GhcPs -> LHsExpr GhcPs
f LHsExpr GhcPs
y)
descendApps' f :: LHsExpr GhcPs -> LHsExpr GhcPs
f x :: LHsExpr GhcPs
x = (LHsExpr GhcPs -> LHsExpr GhcPs) -> LHsExpr GhcPs -> LHsExpr GhcPs
forall on. Uniplate on => (on -> on) -> on -> on
descend LHsExpr GhcPs -> LHsExpr GhcPs
f LHsExpr GhcPs
x

descendAppsM' :: Monad m => (LHsExpr GhcPs  -> m (LHsExpr GhcPs)) -> LHsExpr GhcPs -> m (LHsExpr GhcPs)
descendAppsM' :: (LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
descendAppsM' f :: LHsExpr GhcPs -> m (LHsExpr GhcPs)
f (LL l :: SrcSpan
l (HsApp _ x y)) = (LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs)
-> m (LHsExpr GhcPs) -> m (LHsExpr GhcPs) -> m (LHsExpr GhcPs)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (\x :: LHsExpr GhcPs
x y :: LHsExpr GhcPs
y -> SrcSpan -> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
LL SrcSpan
l (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs)
-> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a -> b) -> a -> b
$ XApp GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp NoExt
XApp GhcPs
noExt LHsExpr GhcPs
x LHsExpr GhcPs
y) ((LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
forall (m :: * -> *).
Monad m =>
(LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
descendAppsM' LHsExpr GhcPs -> m (LHsExpr GhcPs)
f LHsExpr GhcPs
x) (LHsExpr GhcPs -> m (LHsExpr GhcPs)
f LHsExpr GhcPs
y)
descendAppsM' f :: LHsExpr GhcPs -> m (LHsExpr GhcPs)
f x :: LHsExpr GhcPs
x = (LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
forall on (m :: * -> *).
(Uniplate on, Monad m) =>
(on -> m on) -> on -> m on
descendM LHsExpr GhcPs -> m (LHsExpr GhcPs)
f LHsExpr GhcPs
x

transformApps' :: (LHsExpr GhcPs -> LHsExpr GhcPs) -> LHsExpr GhcPs -> LHsExpr GhcPs
transformApps' :: (LHsExpr GhcPs -> LHsExpr GhcPs) -> LHsExpr GhcPs -> LHsExpr GhcPs
transformApps' f :: LHsExpr GhcPs -> LHsExpr GhcPs
f = LHsExpr GhcPs -> LHsExpr GhcPs
f (LHsExpr GhcPs -> LHsExpr GhcPs)
-> (LHsExpr GhcPs -> LHsExpr GhcPs)
-> LHsExpr GhcPs
-> LHsExpr GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LHsExpr GhcPs -> LHsExpr GhcPs) -> LHsExpr GhcPs -> LHsExpr GhcPs
descendApps' ((LHsExpr GhcPs -> LHsExpr GhcPs) -> LHsExpr GhcPs -> LHsExpr GhcPs
transformApps' LHsExpr GhcPs -> LHsExpr GhcPs
f)

transformAppsM' :: Monad m => (LHsExpr GhcPs -> m (LHsExpr GhcPs)) -> LHsExpr GhcPs -> m (LHsExpr GhcPs)
transformAppsM' :: (LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
transformAppsM' f :: LHsExpr GhcPs -> m (LHsExpr GhcPs)
f x :: LHsExpr GhcPs
x = LHsExpr GhcPs -> m (LHsExpr GhcPs)
f (LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> m (LHsExpr GhcPs) -> m (LHsExpr GhcPs)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
forall (m :: * -> *).
Monad m =>
(LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
descendAppsM' ((LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
forall (m :: * -> *).
Monad m =>
(LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
transformAppsM' LHsExpr GhcPs -> m (LHsExpr GhcPs)
f) LHsExpr GhcPs
x

descendIndex' :: Data a => (Int -> a -> a) -> a -> a
descendIndex' :: (Int -> a -> a) -> a -> a
descendIndex' f :: Int -> a -> a
f x :: a
x = (State Int a -> Int -> a) -> Int -> State Int a -> a
forall a b c. (a -> b -> c) -> b -> a -> c
flip State Int a -> Int -> a
forall s a. State s a -> s -> a
evalState 0 (State Int a -> a) -> State Int a -> a
forall a b. (a -> b) -> a -> b
$ ((a -> State Int a) -> a -> State Int a)
-> a -> (a -> State Int a) -> State Int a
forall a b c. (a -> b -> c) -> b -> a -> c
flip (a -> State Int a) -> a -> State Int a
forall on (m :: * -> *).
(Uniplate on, Monad m) =>
(on -> m on) -> on -> m on
descendM a
x ((a -> State Int a) -> State Int a)
-> (a -> State Int a) -> State Int a
forall a b. (a -> b) -> a -> b
$ \y :: a
y -> do
    Int
i <- StateT Int Identity Int
forall (m :: * -> *) s. Monad m => StateT s m s
get
    (Int -> Int) -> StateT Int Identity ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (Int -> Int -> Int
forall a. Num a => a -> a -> a
+1)
    a -> State Int a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> State Int a) -> a -> State Int a
forall a b. (a -> b) -> a -> b
$ Int -> a -> a
f Int
i a
y

--  There are differences in pretty-printing between GHC and HSE. This
--  version never removes brackets.
descendBracket' :: (LHsExpr GhcPs -> (Bool, LHsExpr GhcPs)) -> LHsExpr GhcPs -> LHsExpr GhcPs
descendBracket' :: (LHsExpr GhcPs -> (Bool, LHsExpr GhcPs))
-> LHsExpr GhcPs -> LHsExpr GhcPs
descendBracket' op :: LHsExpr GhcPs -> (Bool, LHsExpr GhcPs)
op x :: LHsExpr GhcPs
x = (Int -> LHsExpr GhcPs -> LHsExpr GhcPs)
-> LHsExpr GhcPs -> LHsExpr GhcPs
forall a. Data a => (Int -> a -> a) -> a -> a
descendIndex' Int -> LHsExpr GhcPs -> LHsExpr GhcPs
g LHsExpr GhcPs
x
    where
        g :: Int -> LHsExpr GhcPs -> LHsExpr GhcPs
g i :: Int
i y :: LHsExpr GhcPs
y = if Bool
a then Int -> LHsExpr GhcPs -> LHsExpr GhcPs
f Int
i LHsExpr GhcPs
b else LHsExpr GhcPs
b
            where (a :: Bool
a, b :: LHsExpr GhcPs
b) = LHsExpr GhcPs -> (Bool, LHsExpr GhcPs)
op LHsExpr GhcPs
y
        f :: Int -> LHsExpr GhcPs -> LHsExpr GhcPs
f i :: Int
i y :: LHsExpr GhcPs
y@(LL _ e :: SrcSpanLess (LHsExpr GhcPs)
e) | Int -> LHsExpr GhcPs -> LHsExpr GhcPs -> Bool
forall a. Brackets' a => Int -> a -> a -> Bool
needBracket' Int
i LHsExpr GhcPs
x LHsExpr GhcPs
y = LHsExpr GhcPs -> LHsExpr GhcPs
forall a. Brackets' a => a -> a
addParen' LHsExpr GhcPs
y
        f _ y :: LHsExpr GhcPs
y = LHsExpr GhcPs
y

-- Add brackets as suggested 'needBracket' at 1-level of depth.
rebracket1' :: LHsExpr GhcPs -> LHsExpr GhcPs
rebracket1' :: LHsExpr GhcPs -> LHsExpr GhcPs
rebracket1' = (LHsExpr GhcPs -> (Bool, LHsExpr GhcPs))
-> LHsExpr GhcPs -> LHsExpr GhcPs
descendBracket' (Bool
True, )

-- A list of application, with any necessary brackets.
appsBracket' :: [LHsExpr GhcPs] -> LHsExpr GhcPs
appsBracket' :: [LHsExpr GhcPs] -> LHsExpr GhcPs
appsBracket' = (LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs)
-> [LHsExpr GhcPs] -> LHsExpr GhcPs
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
mkApp
  where mkApp :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
mkApp x :: LHsExpr GhcPs
x y :: LHsExpr GhcPs
y = LHsExpr GhcPs -> LHsExpr GhcPs
rebracket1' (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs)
-> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a -> b) -> a -> b
$ XApp GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp NoExt
XApp GhcPs
noExt LHsExpr GhcPs
x LHsExpr GhcPs
y)


simplifyExp' :: LHsExpr GhcPs -> LHsExpr GhcPs
-- Replace appliciations 'f $ x' with 'f (x)'.
simplifyExp' :: LHsExpr GhcPs -> LHsExpr GhcPs
simplifyExp' (LL l :: SrcSpan
l (OpApp _ x op y)) | LHsExpr GhcPs -> Bool
isDol LHsExpr GhcPs
op = SrcSpan -> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
LL SrcSpan
l (XApp GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp NoExt
XApp GhcPs
noExt LHsExpr GhcPs
x (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc (XPar GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XPar p -> LHsExpr p -> HsExpr p
HsPar NoExt
XPar GhcPs
noExt LHsExpr GhcPs
y)))
simplifyExp' e :: LHsExpr GhcPs
e@(LL _ (HsLet _ (LL _ (HsValBinds _ (ValBinds _ binds []))) z)) =
  -- An expression of the form, 'let x = y in z'.
  case Bag (LHsBindLR GhcPs GhcPs) -> [LHsBindLR GhcPs GhcPs]
forall a. Bag a -> [a]
bagToList Bag (LHsBindLR GhcPs GhcPs)
binds of
    [LL _ (FunBind _ _(MG _ (LL _ [LL _ (Match _(FunRhs (LL _ x) _ _) [] (GRHSs _[LL _ (GRHS _ [] y)] (LL _ (EmptyLocalBinds _))))]) _) _ _)]
         -- If 'x' is not in the free variables of 'y', beta-reduce to
         -- 'z[(y)/x]'.
      | OccName -> String
occNameString (RdrName -> OccName
rdrNameOcc RdrName
SrcSpanLess (Located RdrName)
x) String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` LHsExpr GhcPs -> [String]
forall a. FreeVars' a => a -> [String]
vars' LHsExpr GhcPs
y Bool -> Bool -> Bool
&& [()] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [() | Unqual a :: OccName
a <- LHsExpr GhcPs -> [RdrName]
forall from to. Biplate from to => from -> [to]
universeBi LHsExpr GhcPs
z, OccName
a OccName -> OccName -> Bool
forall a. Eq a => a -> a -> Bool
== RdrName -> OccName
rdrNameOcc RdrName
SrcSpanLess (Located RdrName)
x] Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= 1 ->
          (LHsExpr GhcPs -> LHsExpr GhcPs) -> LHsExpr GhcPs -> LHsExpr GhcPs
forall on. Uniplate on => (on -> on) -> on -> on
transform LHsExpr GhcPs -> LHsExpr GhcPs
f LHsExpr GhcPs
z
          where f :: LHsExpr GhcPs -> LHsExpr GhcPs
f (LHsExpr GhcPs -> Var_'
forall a b. View' a b => a -> b
view' -> Var_' x' :: String
x') | OccName -> String
occNameString (RdrName -> OccName
rdrNameOcc RdrName
SrcSpanLess (Located RdrName)
x) String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
x' = LHsExpr GhcPs -> LHsExpr GhcPs
paren' LHsExpr GhcPs
y
                f x :: LHsExpr GhcPs
x = LHsExpr GhcPs
x
    _ -> LHsExpr GhcPs
e
simplifyExp' e :: LHsExpr GhcPs
e = LHsExpr GhcPs
e

-- Rewrite '($) . b' as 'b'.
niceDotApp' :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
niceDotApp' :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
niceDotApp' (LL _ (HsVar _ (L _ r))) b :: LHsExpr GhcPs
b | OccName -> String
occNameString (RdrName -> OccName
rdrNameOcc RdrName
IdP GhcPs
r) String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== "$" = LHsExpr GhcPs
b
niceDotApp' a :: LHsExpr GhcPs
a b :: LHsExpr GhcPs
b = LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
dotApp' LHsExpr GhcPs
a LHsExpr GhcPs
b


-- Generate a lambda expression but prettier if possible.
niceLambda' :: [String] -> LHsExpr GhcPs -> LHsExpr GhcPs
niceLambda' :: [String] -> LHsExpr GhcPs -> LHsExpr GhcPs
niceLambda' ss :: [String]
ss e :: LHsExpr GhcPs
e = (LHsExpr GhcPs, SrcSpan -> [Refactoring SrcSpan]) -> LHsExpr GhcPs
forall a b. (a, b) -> a
fst ([String]
-> LHsExpr GhcPs
-> (LHsExpr GhcPs, SrcSpan -> [Refactoring SrcSpan])
niceLambdaR' [String]
ss LHsExpr GhcPs
e)-- We don't support refactorings yet.

allowRightSection :: String -> Bool
allowRightSection x :: String
x = String
x String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` ["-","#"]
allowLeftSection :: String -> Bool
allowLeftSection x :: String
x = String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
/= "#"

-- Implementation. Try to produce special forms (e.g. sections,
-- compositions) where we can.
niceLambdaR' :: [String]
             -> LHsExpr GhcPs
             -> (LHsExpr GhcPs, R.SrcSpan
             -> [Refactoring R.SrcSpan])
-- Rewrite '\xs -> (e)' as '\xs -> e'.
niceLambdaR' :: [String]
-> LHsExpr GhcPs
-> (LHsExpr GhcPs, SrcSpan -> [Refactoring SrcSpan])
niceLambdaR' xs :: [String]
xs (LL _ (HsPar _ x)) = [String]
-> LHsExpr GhcPs
-> (LHsExpr GhcPs, SrcSpan -> [Refactoring SrcSpan])
niceLambdaR' [String]
xs LHsExpr GhcPs
x
-- Rewrite '\x -> x + a' as '(+ a)' (heuristic: 'a' must be a single
-- lexeme, or it all gets too complex).
niceLambdaR' [x :: String
x] (LHsExpr GhcPs -> App2'
forall a b. View' a b => a -> b
view' -> App2' op :: LHsExpr GhcPs
op@(LL _ (HsVar _ (L _ tag))) l :: LHsExpr GhcPs
l r :: LHsExpr GhcPs
r)
  | LHsExpr GhcPs -> Bool
isLexeme LHsExpr GhcPs
r, LHsExpr GhcPs -> Var_'
forall a b. View' a b => a -> b
view' LHsExpr GhcPs
l Var_' -> Var_' -> Bool
forall a. Eq a => a -> a -> Bool
== String -> Var_'
Var_' String
x, String
x String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` LHsExpr GhcPs -> [String]
forall a. FreeVars' a => a -> [String]
vars' LHsExpr GhcPs
r, String -> Bool
allowRightSection (OccName -> String
occNameString (OccName -> String) -> OccName -> String
forall a b. (a -> b) -> a -> b
$ RdrName -> OccName
rdrNameOcc RdrName
IdP GhcPs
tag) =
      let e :: LHsExpr GhcPs
e = LHsExpr GhcPs -> LHsExpr GhcPs
rebracket1' (LHsExpr GhcPs -> LHsExpr GhcPs) -> LHsExpr GhcPs -> LHsExpr GhcPs
forall a b. (a -> b) -> a -> b
$ LHsExpr GhcPs -> LHsExpr GhcPs
forall a. Brackets' a => a -> a
addParen' (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs)
-> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a -> b) -> a -> b
$ XSectionR GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XSectionR p -> LHsExpr p -> LHsExpr p -> HsExpr p
SectionR NoExt
XSectionR GhcPs
noExt LHsExpr GhcPs
op LHsExpr GhcPs
r)
      in (LHsExpr GhcPs
e, [Refactoring SrcSpan] -> SrcSpan -> [Refactoring SrcSpan]
forall a b. a -> b -> a
const [])
-- Rewrite (1) '\x -> f (b x)' as 'f . b', (2) '\x -> f $ b x' as 'f . b'.
niceLambdaR' [x :: String
x] y :: LHsExpr GhcPs
y
  | Just (z :: LHsExpr GhcPs
z, subts :: [LHsExpr GhcPs]
subts) <- LHsExpr GhcPs -> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
factor LHsExpr GhcPs
y, String
x String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` LHsExpr GhcPs -> [String]
forall a. FreeVars' a => a -> [String]
vars' LHsExpr GhcPs
z = (LHsExpr GhcPs
z, [Refactoring SrcSpan] -> SrcSpan -> [Refactoring SrcSpan]
forall a b. a -> b -> a
const [])
  where
    -- Factor the expression with respect to x.
    factor :: LHsExpr GhcPs -> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
    factor :: LHsExpr GhcPs -> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
factor y :: LHsExpr GhcPs
y@(LL _ (HsApp _ ini lst)) | LHsExpr GhcPs -> Var_'
forall a b. View' a b => a -> b
view' LHsExpr GhcPs
lst Var_' -> Var_' -> Bool
forall a. Eq a => a -> a -> Bool
== String -> Var_'
Var_' String
x = (LHsExpr GhcPs, [LHsExpr GhcPs])
-> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
forall a. a -> Maybe a
Just (LHsExpr GhcPs
ini, [LHsExpr GhcPs
ini])
    factor y :: LHsExpr GhcPs
y@(LL _ (HsApp _ ini lst)) | Just (z :: LHsExpr GhcPs
z, ss :: [LHsExpr GhcPs]
ss) <- LHsExpr GhcPs -> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
factor LHsExpr GhcPs
lst
      = let r :: LHsExpr GhcPs
r = LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
niceDotApp' LHsExpr GhcPs
ini LHsExpr GhcPs
z
        in if LHsExpr GhcPs -> LHsExpr GhcPs -> Bool
forall a. Data a => a -> a -> Bool
astEq LHsExpr GhcPs
r LHsExpr GhcPs
z then (LHsExpr GhcPs, [LHsExpr GhcPs])
-> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
forall a. a -> Maybe a
Just (LHsExpr GhcPs
r, [LHsExpr GhcPs]
ss) else (LHsExpr GhcPs, [LHsExpr GhcPs])
-> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
forall a. a -> Maybe a
Just (LHsExpr GhcPs
r, LHsExpr GhcPs
ini LHsExpr GhcPs -> [LHsExpr GhcPs] -> [LHsExpr GhcPs]
forall a. a -> [a] -> [a]
: [LHsExpr GhcPs]
ss)
    factor (LL _ (OpApp _ y op (factor -> Just (z, ss))))| LHsExpr GhcPs -> Bool
isDol LHsExpr GhcPs
op
      = let r :: LHsExpr GhcPs
r = LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
niceDotApp' LHsExpr GhcPs
y LHsExpr GhcPs
z
        in if LHsExpr GhcPs -> LHsExpr GhcPs -> Bool
forall a. Data a => a -> a -> Bool
astEq LHsExpr GhcPs
r LHsExpr GhcPs
z then (LHsExpr GhcPs, [LHsExpr GhcPs])
-> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
forall a. a -> Maybe a
Just (LHsExpr GhcPs
r, [LHsExpr GhcPs]
ss) else (LHsExpr GhcPs, [LHsExpr GhcPs])
-> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
forall a. a -> Maybe a
Just (LHsExpr GhcPs
r, LHsExpr GhcPs
y LHsExpr GhcPs -> [LHsExpr GhcPs] -> [LHsExpr GhcPs]
forall a. a -> [a] -> [a]
: [LHsExpr GhcPs]
ss)
    factor (LL _ (HsPar _ y@(LL _ HsApp{}))) = LHsExpr GhcPs -> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
factor LHsExpr GhcPs
y
    factor _ = Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
forall a. Maybe a
Nothing
-- Rewrite '\x y -> x + y' as '(+)'.
niceLambdaR' [x :: String
x,y :: String
y] (LL _ (OpApp _ (view' -> Var_' x1) op@(LL _ HsVar {}) (view' -> Var_' y1)))
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
x1, String
y String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
y1, LHsExpr GhcPs -> [String]
forall a. FreeVars' a => a -> [String]
vars' LHsExpr GhcPs
op [String] -> [String] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`disjoint` [String
x, String
y] = (LHsExpr GhcPs
op, [Refactoring SrcSpan] -> SrcSpan -> [Refactoring SrcSpan]
forall a b. a -> b -> a
const [])
-- Rewrite '\x y -> f y x' as 'flip f'.
niceLambdaR' [x :: String
x, y :: String
y] (LHsExpr GhcPs -> App2'
forall a b. View' a b => a -> b
view' -> App2' op :: LHsExpr GhcPs
op (LHsExpr GhcPs -> Var_'
forall a b. View' a b => a -> b
view' -> Var_' y1 :: String
y1) (LHsExpr GhcPs -> Var_'
forall a b. View' a b => a -> b
view' -> Var_' x1 :: String
x1))
  | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
x1, String
y String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
y1, LHsExpr GhcPs -> [String]
forall a. FreeVars' a => a -> [String]
vars' LHsExpr GhcPs
op [String] -> [String] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`disjoint` [String
x, String
y] = (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs)
-> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a -> b) -> a -> b
$ XApp GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp NoExt
XApp GhcPs
noExt (String -> LHsExpr GhcPs
strToVar "flip") LHsExpr GhcPs
op, [Refactoring SrcSpan] -> SrcSpan -> [Refactoring SrcSpan]
forall a b. a -> b -> a
const [])
-- Base case. Just a good old fashioned lambda.
niceLambdaR' ss :: [String]
ss e :: LHsExpr GhcPs
e =
  let grhs :: LGRHS GhcPs (LHsExpr GhcPs)
grhs = SrcSpanLess (LGRHS GhcPs (LHsExpr GhcPs))
-> LGRHS GhcPs (LHsExpr GhcPs)
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc (SrcSpanLess (LGRHS GhcPs (LHsExpr GhcPs))
 -> LGRHS GhcPs (LHsExpr GhcPs))
-> SrcSpanLess (LGRHS GhcPs (LHsExpr GhcPs))
-> LGRHS GhcPs (LHsExpr GhcPs)
forall a b. (a -> b) -> a -> b
$ XCGRHS GhcPs (LHsExpr GhcPs)
-> [GuardLStmt GhcPs]
-> LHsExpr GhcPs
-> GRHS GhcPs (LHsExpr GhcPs)
forall p body.
XCGRHS p body -> [GuardLStmt p] -> body -> GRHS p body
GRHS NoExt
XCGRHS GhcPs (LHsExpr GhcPs)
noExt [] LHsExpr GhcPs
e :: LGRHS GhcPs (LHsExpr GhcPs)
      grhss :: GRHSs GhcPs (LHsExpr GhcPs)
grhss = GRHSs :: forall p body.
XCGRHSs p body -> [LGRHS p body] -> LHsLocalBinds p -> GRHSs p body
GRHSs {grhssExt :: XCGRHSs GhcPs (LHsExpr GhcPs)
grhssExt = NoExt
XCGRHSs GhcPs (LHsExpr GhcPs)
noExt, grhssGRHSs :: [LGRHS GhcPs (LHsExpr GhcPs)]
grhssGRHSs=[LGRHS GhcPs (LHsExpr GhcPs)
grhs], grhssLocalBinds :: LHsLocalBinds GhcPs
grhssLocalBinds=SrcSpanLess (LHsLocalBinds GhcPs) -> LHsLocalBinds GhcPs
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc (SrcSpanLess (LHsLocalBinds GhcPs) -> LHsLocalBinds GhcPs)
-> SrcSpanLess (LHsLocalBinds GhcPs) -> LHsLocalBinds GhcPs
forall a b. (a -> b) -> a -> b
$ XEmptyLocalBinds GhcPs GhcPs -> HsLocalBindsLR GhcPs GhcPs
forall idL idR. XEmptyLocalBinds idL idR -> HsLocalBindsLR idL idR
EmptyLocalBinds NoExt
XEmptyLocalBinds GhcPs GhcPs
noExt}
      match :: LMatch GhcPs (LHsExpr GhcPs)
match = SrcSpanLess (LMatch GhcPs (LHsExpr GhcPs))
-> LMatch GhcPs (LHsExpr GhcPs)
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc (SrcSpanLess (LMatch GhcPs (LHsExpr GhcPs))
 -> LMatch GhcPs (LHsExpr GhcPs))
-> SrcSpanLess (LMatch GhcPs (LHsExpr GhcPs))
-> LMatch GhcPs (LHsExpr GhcPs)
forall a b. (a -> b) -> a -> b
$ Match :: forall p body.
XCMatch p body
-> HsMatchContext (NameOrRdrName (IdP p))
-> [LPat p]
-> GRHSs p body
-> Match p body
Match {m_ext :: XCMatch GhcPs (LHsExpr GhcPs)
m_ext=NoExt
XCMatch GhcPs (LHsExpr GhcPs)
noExt, m_ctxt :: HsMatchContext (NameOrRdrName (IdP GhcPs))
m_ctxt=HsMatchContext (NameOrRdrName (IdP GhcPs))
forall id. HsMatchContext id
LambdaExpr, m_pats :: [LPat GhcPs]
m_pats=(String -> LPat GhcPs) -> [String] -> [LPat GhcPs]
forall a b. (a -> b) -> [a] -> [b]
map String -> LPat GhcPs
strToPat' [String]
ss, m_grhss :: GRHSs GhcPs (LHsExpr GhcPs)
m_grhss=GRHSs GhcPs (LHsExpr GhcPs)
grhss} :: LMatch GhcPs (LHsExpr GhcPs)
      matchGroup :: MatchGroup GhcPs (LHsExpr GhcPs)
matchGroup = MG :: forall p body.
XMG p body
-> Located [LMatch p body] -> Origin -> MatchGroup p body
MG {mg_ext :: XMG GhcPs (LHsExpr GhcPs)
mg_ext=NoExt
XMG GhcPs (LHsExpr GhcPs)
noExt, mg_origin :: Origin
mg_origin=Origin
Generated, mg_alts :: Located [LMatch GhcPs (LHsExpr GhcPs)]
mg_alts=SrcSpanLess (Located [LMatch GhcPs (LHsExpr GhcPs)])
-> Located [LMatch GhcPs (LHsExpr GhcPs)]
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc [LMatch GhcPs (LHsExpr GhcPs)
match]}
  in (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs)
-> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a -> b) -> a -> b
$ XLam GhcPs -> MatchGroup GhcPs (LHsExpr GhcPs) -> HsExpr GhcPs
forall p. XLam p -> MatchGroup p (LHsExpr p) -> HsExpr p
HsLam NoExt
XLam GhcPs
noExt MatchGroup GhcPs (LHsExpr GhcPs)
matchGroup, [Refactoring SrcSpan] -> SrcSpan -> [Refactoring SrcSpan]
forall a b. a -> b -> a
const [])


-- 'case' and 'if' expressions have branches, nothing else does (this
-- doesn't consider 'HsMultiIf' perhaps it should?).
replaceBranches' :: LHsExpr GhcPs -> ([LHsExpr GhcPs], [LHsExpr GhcPs] -> LHsExpr GhcPs)
replaceBranches' :: LHsExpr GhcPs
-> ([LHsExpr GhcPs], [LHsExpr GhcPs] -> LHsExpr GhcPs)
replaceBranches' (LL l :: SrcSpan
l (HsIf _ _ a b c)) = ([LHsExpr GhcPs
b, LHsExpr GhcPs
c], \[b :: LHsExpr GhcPs
b, c :: LHsExpr GhcPs
c] -> SrcSpan -> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
l (XIf GhcPs
-> Maybe (SyntaxExpr GhcPs)
-> LHsExpr GhcPs
-> LHsExpr GhcPs
-> LHsExpr GhcPs
-> HsExpr GhcPs
forall p.
XIf p
-> Maybe (SyntaxExpr p)
-> LHsExpr p
-> LHsExpr p
-> LHsExpr p
-> HsExpr p
HsIf NoExt
XIf GhcPs
noExt Maybe (SyntaxExpr GhcPs)
forall a. Maybe a
Nothing LHsExpr GhcPs
a LHsExpr GhcPs
b LHsExpr GhcPs
c))

replaceBranches' (LL s :: SrcSpan
s (HsCase _ a (MG _ (L l bs) FromSource))) =
  ((LMatch GhcPs (LHsExpr GhcPs) -> [LHsExpr GhcPs])
-> [LMatch GhcPs (LHsExpr GhcPs)] -> [LHsExpr GhcPs]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap LMatch GhcPs (LHsExpr GhcPs) -> [LHsExpr GhcPs]
f [LMatch GhcPs (LHsExpr GhcPs)]
bs, \xs :: [LHsExpr GhcPs]
xs -> SrcSpan -> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
s (XCase GhcPs
-> LHsExpr GhcPs
-> MatchGroup GhcPs (LHsExpr GhcPs)
-> HsExpr GhcPs
forall p.
XCase p -> LHsExpr p -> MatchGroup p (LHsExpr p) -> HsExpr p
HsCase NoExt
XCase GhcPs
noExt LHsExpr GhcPs
a (XMG GhcPs (LHsExpr GhcPs)
-> Located [LMatch GhcPs (LHsExpr GhcPs)]
-> Origin
-> MatchGroup GhcPs (LHsExpr GhcPs)
forall p body.
XMG p body
-> Located [LMatch p body] -> Origin -> MatchGroup p body
MG NoExt
XMG GhcPs (LHsExpr GhcPs)
noExt (SrcSpan
-> SrcSpanLess (Located [LMatch GhcPs (LHsExpr GhcPs)])
-> Located [LMatch GhcPs (LHsExpr GhcPs)]
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
l ([LMatch GhcPs (LHsExpr GhcPs)]
-> [LHsExpr GhcPs] -> [LMatch GhcPs (LHsExpr GhcPs)]
g [LMatch GhcPs (LHsExpr GhcPs)]
bs [LHsExpr GhcPs]
xs)) Origin
Generated)))
  where
    f :: LMatch GhcPs (LHsExpr GhcPs) -> [LHsExpr GhcPs]
    f :: LMatch GhcPs (LHsExpr GhcPs) -> [LHsExpr GhcPs]
f (LL _ (Match _ CaseAlt _ (GRHSs _ xs _))) = [LHsExpr GhcPs
x | (LL _ (GRHS _ _ x)) <- [LGRHS GhcPs (LHsExpr GhcPs)]
xs]
    f _ = [LHsExpr GhcPs]
forall a. HasCallStack => a
undefined -- {-# COMPLETE LL #-}

    g :: [LMatch GhcPs (LHsExpr GhcPs)] -> [LHsExpr GhcPs] -> [LMatch GhcPs (LHsExpr GhcPs)]
    g :: [LMatch GhcPs (LHsExpr GhcPs)]
-> [LHsExpr GhcPs] -> [LMatch GhcPs (LHsExpr GhcPs)]
g (LL s1 :: SrcSpan
s1 (Match _ CaseAlt a (GRHSs _ ns b)) : rest :: [LMatch GhcPs (LHsExpr GhcPs)]
rest) xs :: [LHsExpr GhcPs]
xs =
      SrcSpan
-> SrcSpanLess (LMatch GhcPs (LHsExpr GhcPs))
-> LMatch GhcPs (LHsExpr GhcPs)
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
s1 (XCMatch GhcPs (LHsExpr GhcPs)
-> HsMatchContext (NameOrRdrName (IdP GhcPs))
-> [LPat GhcPs]
-> GRHSs GhcPs (LHsExpr GhcPs)
-> Match GhcPs (LHsExpr GhcPs)
forall p body.
XCMatch p body
-> HsMatchContext (NameOrRdrName (IdP p))
-> [LPat p]
-> GRHSs p body
-> Match p body
Match NoExt
XCMatch GhcPs (LHsExpr GhcPs)
noExt HsMatchContext (NameOrRdrName (IdP GhcPs))
forall id. HsMatchContext id
CaseAlt [LPat GhcPs]
a (XCGRHSs GhcPs (LHsExpr GhcPs)
-> [LGRHS GhcPs (LHsExpr GhcPs)]
-> LHsLocalBinds GhcPs
-> GRHSs GhcPs (LHsExpr GhcPs)
forall p body.
XCGRHSs p body -> [LGRHS p body] -> LHsLocalBinds p -> GRHSs p body
GRHSs NoExt
XCGRHSs GhcPs (LHsExpr GhcPs)
noExt [SrcSpan
-> SrcSpanLess (LGRHS GhcPs (LHsExpr GhcPs))
-> LGRHS GhcPs (LHsExpr GhcPs)
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
a (XCGRHS GhcPs (LHsExpr GhcPs)
-> [GuardLStmt GhcPs]
-> LHsExpr GhcPs
-> GRHS GhcPs (LHsExpr GhcPs)
forall p body.
XCGRHS p body -> [GuardLStmt p] -> body -> GRHS p body
GRHS NoExt
XCGRHS GhcPs (LHsExpr GhcPs)
noExt [GuardLStmt GhcPs]
gs LHsExpr GhcPs
x) | (LL a :: SrcSpan
a (GRHS _ gs _), x :: LHsExpr GhcPs
x) <- [LGRHS GhcPs (LHsExpr GhcPs)]
-> [LHsExpr GhcPs]
-> [(LGRHS GhcPs (LHsExpr GhcPs), LHsExpr GhcPs)]
forall a b. [a] -> [b] -> [(a, b)]
zip [LGRHS GhcPs (LHsExpr GhcPs)]
ns [LHsExpr GhcPs]
as] LHsLocalBinds GhcPs
b)) LMatch GhcPs (LHsExpr GhcPs)
-> [LMatch GhcPs (LHsExpr GhcPs)] -> [LMatch GhcPs (LHsExpr GhcPs)]
forall a. a -> [a] -> [a]
: [LMatch GhcPs (LHsExpr GhcPs)]
-> [LHsExpr GhcPs] -> [LMatch GhcPs (LHsExpr GhcPs)]
g [LMatch GhcPs (LHsExpr GhcPs)]
rest [LHsExpr GhcPs]
bs
      where  (as :: [LHsExpr GhcPs]
as, bs :: [LHsExpr GhcPs]
bs) = Int -> [LHsExpr GhcPs] -> ([LHsExpr GhcPs], [LHsExpr GhcPs])
forall a. Int -> [a] -> ([a], [a])
splitAt ([LGRHS GhcPs (LHsExpr GhcPs)] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [LGRHS GhcPs (LHsExpr GhcPs)]
ns) [LHsExpr GhcPs]
xs
    g [] [] = []
    g _ _ = String -> [LMatch GhcPs (LHsExpr GhcPs)]
forall a. HasCallStack => String -> a
error "GHC.Util.HsExpr.replaceBranches': internal invariant failed, lists are of differing lengths"

replaceBranches' x :: LHsExpr GhcPs
x = ([], \[] -> LHsExpr GhcPs
x)


-- Like needBracket', but with a special case for 'a . b . b', which was
-- removed from haskell-src-exts-util-0.2.2.
needBracketOld' :: Int -> LHsExpr GhcPs -> LHsExpr GhcPs -> Bool
needBracketOld' :: Int -> LHsExpr GhcPs -> LHsExpr GhcPs -> Bool
needBracketOld' i :: Int
i parent :: LHsExpr GhcPs
parent child :: LHsExpr GhcPs
child
  | LHsExpr GhcPs -> Bool
isDotApp LHsExpr GhcPs
parent, LHsExpr GhcPs -> Bool
isDotApp LHsExpr GhcPs
child, Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== 2 = Bool
False
  | Bool
otherwise = Int -> LHsExpr GhcPs -> LHsExpr GhcPs -> Bool
forall a. Brackets' a => Int -> a -> a -> Bool
needBracket' Int
i LHsExpr GhcPs
parent LHsExpr GhcPs
child

transformBracketOld' :: (LHsExpr GhcPs -> Maybe (LHsExpr GhcPs)) -> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs)
transformBracketOld' :: (LHsExpr GhcPs -> Maybe (LHsExpr GhcPs))
-> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs)
transformBracketOld' op :: LHsExpr GhcPs -> Maybe (LHsExpr GhcPs)
op = ((Bool, LHsExpr GhcPs) -> LHsExpr GhcPs)
-> ((Bool, LHsExpr GhcPs), LHsExpr GhcPs)
-> (LHsExpr GhcPs, LHsExpr GhcPs)
forall a a' b. (a -> a') -> (a, b) -> (a', b)
first (Bool, LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a, b) -> b
snd (((Bool, LHsExpr GhcPs), LHsExpr GhcPs)
 -> (LHsExpr GhcPs, LHsExpr GhcPs))
-> (LHsExpr GhcPs -> ((Bool, LHsExpr GhcPs), LHsExpr GhcPs))
-> LHsExpr GhcPs
-> (LHsExpr GhcPs, LHsExpr GhcPs)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LHsExpr GhcPs -> ((Bool, LHsExpr GhcPs), LHsExpr GhcPs)
g
  where
    g :: LHsExpr GhcPs -> ((Bool, LHsExpr GhcPs), LHsExpr GhcPs)
g = (LHsExpr GhcPs -> (Bool, LHsExpr GhcPs))
-> (LHsExpr GhcPs, LHsExpr GhcPs)
-> ((Bool, LHsExpr GhcPs), LHsExpr GhcPs)
forall a a' b. (a -> a') -> (a, b) -> (a', b)
first LHsExpr GhcPs -> (Bool, LHsExpr GhcPs)
f ((LHsExpr GhcPs, LHsExpr GhcPs)
 -> ((Bool, LHsExpr GhcPs), LHsExpr GhcPs))
-> (LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
-> LHsExpr GhcPs
-> ((Bool, LHsExpr GhcPs), LHsExpr GhcPs)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LHsExpr GhcPs -> ((Bool, LHsExpr GhcPs), LHsExpr GhcPs))
-> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs)
descendBracketOld' LHsExpr GhcPs -> ((Bool, LHsExpr GhcPs), LHsExpr GhcPs)
g
    f :: LHsExpr GhcPs -> (Bool, LHsExpr GhcPs)
f x :: LHsExpr GhcPs
x = (Bool, LHsExpr GhcPs)
-> (LHsExpr GhcPs -> (Bool, LHsExpr GhcPs))
-> Maybe (LHsExpr GhcPs)
-> (Bool, LHsExpr GhcPs)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Bool
False, LHsExpr GhcPs
x) (Bool
True, ) (LHsExpr GhcPs -> Maybe (LHsExpr GhcPs)
op LHsExpr GhcPs
x)

-- Descend, and if something changes then add/remove brackets
-- appropriately. Returns (suggested replacement, refactor template).
-- Whenever a bracket is added to the suggested replacement, a
-- corresponding bracket is added to the refactor template.
descendBracketOld' :: (LHsExpr GhcPs -> ((Bool, LHsExpr GhcPs), LHsExpr GhcPs))
                   -> LHsExpr GhcPs
                   -> (LHsExpr GhcPs, LHsExpr GhcPs)
descendBracketOld' :: (LHsExpr GhcPs -> ((Bool, LHsExpr GhcPs), LHsExpr GhcPs))
-> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs)
descendBracketOld' op :: LHsExpr GhcPs -> ((Bool, LHsExpr GhcPs), LHsExpr GhcPs)
op x :: LHsExpr GhcPs
x = ((Int -> LHsExpr GhcPs -> LHsExpr GhcPs)
-> LHsExpr GhcPs -> LHsExpr GhcPs
forall a. Data a => (Int -> a -> a) -> a -> a
descendIndex' Int -> LHsExpr GhcPs -> LHsExpr GhcPs
g1 LHsExpr GhcPs
x, (Int -> LHsExpr GhcPs -> LHsExpr GhcPs)
-> LHsExpr GhcPs -> LHsExpr GhcPs
forall a. Data a => (Int -> a -> a) -> a -> a
descendIndex' Int -> LHsExpr GhcPs -> LHsExpr GhcPs
g2 LHsExpr GhcPs
x)
  where
    g :: Int -> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs)
g i :: Int
i y :: LHsExpr GhcPs
y = if Bool
a then (Int -> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
f1 Int
i LHsExpr GhcPs
b LHsExpr GhcPs
z, Int -> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
f2 Int
i LHsExpr GhcPs
b LHsExpr GhcPs
z) else (LHsExpr GhcPs
b, LHsExpr GhcPs
z)
      where ((a :: Bool
a, b :: LHsExpr GhcPs
b), z :: LHsExpr GhcPs
z) = LHsExpr GhcPs -> ((Bool, LHsExpr GhcPs), LHsExpr GhcPs)
op LHsExpr GhcPs
y

    g1 :: Int -> LHsExpr GhcPs -> LHsExpr GhcPs
g1 = ((LHsExpr GhcPs, LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a, b) -> a
fst ((LHsExpr GhcPs, LHsExpr GhcPs) -> LHsExpr GhcPs)
-> (LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
-> LHsExpr GhcPs
-> LHsExpr GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
 -> LHsExpr GhcPs -> LHsExpr GhcPs)
-> (Int -> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
-> Int
-> LHsExpr GhcPs
-> LHsExpr GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs)
g
    g2 :: Int -> LHsExpr GhcPs -> LHsExpr GhcPs
g2 = ((LHsExpr GhcPs, LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a, b) -> b
snd ((LHsExpr GhcPs, LHsExpr GhcPs) -> LHsExpr GhcPs)
-> (LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
-> LHsExpr GhcPs
-> LHsExpr GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
 -> LHsExpr GhcPs -> LHsExpr GhcPs)
-> (Int -> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
-> Int
-> LHsExpr GhcPs
-> LHsExpr GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs)
g

    f :: Int
-> LHsExpr GhcPs -> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs)
f i :: Int
i (LL _ (HsPar _ y)) z :: LHsExpr GhcPs
z | Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Int -> LHsExpr GhcPs -> LHsExpr GhcPs -> Bool
needBracketOld' Int
i LHsExpr GhcPs
x LHsExpr GhcPs
y = (LHsExpr GhcPs
y, LHsExpr GhcPs
z)
    f i :: Int
i y :: LHsExpr GhcPs
y z :: LHsExpr GhcPs
z                  | Int -> LHsExpr GhcPs -> LHsExpr GhcPs -> Bool
needBracketOld' Int
i LHsExpr GhcPs
x LHsExpr GhcPs
y = (LHsExpr GhcPs -> LHsExpr GhcPs
forall a. Brackets' a => a -> a
addParen' LHsExpr GhcPs
y, LHsExpr GhcPs -> LHsExpr GhcPs
forall a. Brackets' a => a -> a
addParen' LHsExpr GhcPs
z)
    f _ y :: LHsExpr GhcPs
y z :: LHsExpr GhcPs
z                  = (LHsExpr GhcPs
y, LHsExpr GhcPs
z)

    f1 :: Int -> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
f1 = (((LHsExpr GhcPs, LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a, b) -> a
fst ((LHsExpr GhcPs, LHsExpr GhcPs) -> LHsExpr GhcPs)
-> (LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
-> LHsExpr GhcPs
-> LHsExpr GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
 -> LHsExpr GhcPs -> LHsExpr GhcPs)
-> (LHsExpr GhcPs
    -> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
-> LHsExpr GhcPs
-> LHsExpr GhcPs
-> LHsExpr GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((LHsExpr GhcPs -> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
 -> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs)
-> (Int
    -> LHsExpr GhcPs
    -> LHsExpr GhcPs
    -> (LHsExpr GhcPs, LHsExpr GhcPs))
-> Int
-> LHsExpr GhcPs
-> LHsExpr GhcPs
-> LHsExpr GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int
-> LHsExpr GhcPs -> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs)
f
    f2 :: Int -> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
f2 = (((LHsExpr GhcPs, LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a, b) -> b
snd ((LHsExpr GhcPs, LHsExpr GhcPs) -> LHsExpr GhcPs)
-> (LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
-> LHsExpr GhcPs
-> LHsExpr GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
 -> LHsExpr GhcPs -> LHsExpr GhcPs)
-> (LHsExpr GhcPs
    -> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
-> LHsExpr GhcPs
-> LHsExpr GhcPs
-> LHsExpr GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((LHsExpr GhcPs -> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs))
 -> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs)
-> (Int
    -> LHsExpr GhcPs
    -> LHsExpr GhcPs
    -> (LHsExpr GhcPs, LHsExpr GhcPs))
-> Int
-> LHsExpr GhcPs
-> LHsExpr GhcPs
-> LHsExpr GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int
-> LHsExpr GhcPs -> LHsExpr GhcPs -> (LHsExpr GhcPs, LHsExpr GhcPs)
f

reduce' :: LHsExpr GhcPs -> LHsExpr GhcPs
reduce' :: LHsExpr GhcPs -> LHsExpr GhcPs
reduce' = LHsExpr GhcPs -> LHsExpr GhcPs
fromParen' (LHsExpr GhcPs -> LHsExpr GhcPs)
-> (LHsExpr GhcPs -> LHsExpr GhcPs)
-> LHsExpr GhcPs
-> LHsExpr GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LHsExpr GhcPs -> LHsExpr GhcPs) -> LHsExpr GhcPs -> LHsExpr GhcPs
forall on. Uniplate on => (on -> on) -> on -> on
transform LHsExpr GhcPs -> LHsExpr GhcPs
reduce1'

reduce1' :: LHsExpr GhcPs -> LHsExpr GhcPs
reduce1' :: LHsExpr GhcPs -> LHsExpr GhcPs
reduce1' (LL loc :: SrcSpan
loc (HsApp _ len (LL _ (HsLit _ (HsString _ xs)))))
  | LHsExpr GhcPs -> String
varToStr LHsExpr GhcPs
len String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== "length" = SrcSpan -> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
loc (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs)
-> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a -> b) -> a -> b
$ XLitE GhcPs -> HsLit GhcPs -> HsExpr GhcPs
forall p. XLitE p -> HsLit p -> HsExpr p
HsLit NoExt
XLitE GhcPs
noExt (XHsInt GhcPs -> IntegralLit -> HsLit GhcPs
forall x. XHsInt x -> IntegralLit -> HsLit x
HsInt NoExt
XHsInt GhcPs
noExt (SourceText -> Bool -> Integer -> IntegralLit
IL SourceText
NoSourceText Bool
False Integer
n))
  where n :: Integer
n = Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Integer) -> Int -> Integer
forall a b. (a -> b) -> a -> b
$ String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (FastString -> String
unpackFS FastString
xs)
reduce1' (LL loc :: SrcSpan
loc (HsApp _ len (LL _ (ExplicitList _ _ xs))))
  | LHsExpr GhcPs -> String
varToStr LHsExpr GhcPs
len String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== "length" = SrcSpan -> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
loc (SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs)
-> SrcSpanLess (LHsExpr GhcPs) -> LHsExpr GhcPs
forall a b. (a -> b) -> a -> b
$ XLitE GhcPs -> HsLit GhcPs -> HsExpr GhcPs
forall p. XLitE p -> HsLit p -> HsExpr p
HsLit NoExt
XLitE GhcPs
noExt (XHsInt GhcPs -> IntegralLit -> HsLit GhcPs
forall x. XHsInt x -> IntegralLit -> HsLit x
HsInt NoExt
XHsInt GhcPs
noExt (SourceText -> Bool -> Integer -> IntegralLit
IL SourceText
NoSourceText Bool
False Integer
n))
  where n :: Integer
n = Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Integer) -> Int -> Integer
forall a b. (a -> b) -> a -> b
$ [LHsExpr GhcPs] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [LHsExpr GhcPs]
xs
reduce1' (LHsExpr GhcPs -> App2'
forall a b. View' a b => a -> b
view' -> App2' op :: LHsExpr GhcPs
op (LL _ (HsLit _ x)) (LL _ (HsLit _ y))) | LHsExpr GhcPs -> String
varToStr LHsExpr GhcPs
op String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== "==" = String -> LHsExpr GhcPs
strToVar (Bool -> String
forall a. Show a => a -> String
show (HsLit GhcPs -> HsLit GhcPs -> Bool
forall a. Data a => a -> a -> Bool
astEq HsLit GhcPs
x HsLit GhcPs
y))
reduce1' (LHsExpr GhcPs -> App2'
forall a b. View' a b => a -> b
view' -> App2' op :: LHsExpr GhcPs
op (LL _ (HsLit _ (HsInt _ x))) (LL _ (HsLit _ (HsInt _ y)))) | LHsExpr GhcPs -> String
varToStr LHsExpr GhcPs
op String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== ">=" = String -> LHsExpr GhcPs
strToVar (String -> LHsExpr GhcPs) -> String -> LHsExpr GhcPs
forall a b. (a -> b) -> a -> b
$ Bool -> String
forall a. Show a => a -> String
show (IntegralLit
x IntegralLit -> IntegralLit -> Bool
forall a. Ord a => a -> a -> Bool
>= IntegralLit
y)
reduce1' (LHsExpr GhcPs -> App2'
forall a b. View' a b => a -> b
view' -> App2' op :: LHsExpr GhcPs
op x :: LHsExpr GhcPs
x y :: LHsExpr GhcPs
y)
    | LHsExpr GhcPs -> String
varToStr LHsExpr GhcPs
op String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== "&&" Bool -> Bool -> Bool
&& LHsExpr GhcPs -> String
varToStr LHsExpr GhcPs
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== "True"  = LHsExpr GhcPs
y
    | LHsExpr GhcPs -> String
varToStr LHsExpr GhcPs
op String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== "&&" Bool -> Bool -> Bool
&& LHsExpr GhcPs -> String
varToStr LHsExpr GhcPs
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== "False" = LHsExpr GhcPs
x
reduce1' (LL _ (HsPar _ x)) | LHsExpr GhcPs -> Bool
forall a. Brackets' a => a -> Bool
isAtom' LHsExpr GhcPs
x = LHsExpr GhcPs
x
reduce1' x :: LHsExpr GhcPs
x = LHsExpr GhcPs
x


fromParen1' :: LHsExpr GhcPs -> LHsExpr GhcPs
fromParen1' :: LHsExpr GhcPs -> LHsExpr GhcPs
fromParen1' (LL _ (HsPar _ x)) = LHsExpr GhcPs
x
fromParen1' x :: LHsExpr GhcPs
x = LHsExpr GhcPs
x