{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE FlexibleInstances          #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

module HaskellWorks.Data.BalancedParens.Simple
  ( SimpleBalancedParens(..)
  ) where

import Control.Monad
import GHC.Generics
import HaskellWorks.Data.BalancedParens.BalancedParens
import HaskellWorks.Data.BalancedParens.CloseAt
import HaskellWorks.Data.BalancedParens.Enclose
import HaskellWorks.Data.BalancedParens.FindClose
import HaskellWorks.Data.BalancedParens.FindOpen
import HaskellWorks.Data.BalancedParens.OpenAt
import HaskellWorks.Data.Bits.BitLength
import HaskellWorks.Data.Bits.BitShow
import HaskellWorks.Data.Bits.BitWise
import HaskellWorks.Data.RankSelect.Base.Rank0
import HaskellWorks.Data.RankSelect.Base.Rank1
import HaskellWorks.Data.RankSelect.Base.Select0
import HaskellWorks.Data.RankSelect.Base.Select1
import Prelude                                         as P

newtype SimpleBalancedParens a = SimpleBalancedParens a
  deriving (CloseAt (SimpleBalancedParens a)
FindClose (SimpleBalancedParens a)
OpenAt (SimpleBalancedParens a)
Enclose (SimpleBalancedParens a)
FindOpen (SimpleBalancedParens a)
OpenAt (SimpleBalancedParens a)
-> CloseAt (SimpleBalancedParens a)
-> FindOpen (SimpleBalancedParens a)
-> FindClose (SimpleBalancedParens a)
-> Enclose (SimpleBalancedParens a)
-> (SimpleBalancedParens a -> Count -> Maybe Count)
-> (SimpleBalancedParens a -> Count -> Maybe Count)
-> (SimpleBalancedParens a -> Count -> Maybe Count)
-> BalancedParens (SimpleBalancedParens a)
SimpleBalancedParens a -> Count -> Maybe Count
forall v.
OpenAt v
-> CloseAt v
-> FindOpen v
-> FindClose v
-> Enclose v
-> (v -> Count -> Maybe Count)
-> (v -> Count -> Maybe Count)
-> (v -> Count -> Maybe Count)
-> BalancedParens v
forall a. BalancedParens a => CloseAt (SimpleBalancedParens a)
forall a. BalancedParens a => FindClose (SimpleBalancedParens a)
forall a. BalancedParens a => OpenAt (SimpleBalancedParens a)
forall a. BalancedParens a => Enclose (SimpleBalancedParens a)
forall a. BalancedParens a => FindOpen (SimpleBalancedParens a)
forall a.
BalancedParens a =>
SimpleBalancedParens a -> Count -> Maybe Count
parent :: SimpleBalancedParens a -> Count -> Maybe Count
$cparent :: forall a.
BalancedParens a =>
SimpleBalancedParens a -> Count -> Maybe Count
nextSibling :: SimpleBalancedParens a -> Count -> Maybe Count
$cnextSibling :: forall a.
BalancedParens a =>
SimpleBalancedParens a -> Count -> Maybe Count
firstChild :: SimpleBalancedParens a -> Count -> Maybe Count
$cfirstChild :: forall a.
BalancedParens a =>
SimpleBalancedParens a -> Count -> Maybe Count
$cp5BalancedParens :: forall a. BalancedParens a => Enclose (SimpleBalancedParens a)
$cp4BalancedParens :: forall a. BalancedParens a => FindClose (SimpleBalancedParens a)
$cp3BalancedParens :: forall a. BalancedParens a => FindOpen (SimpleBalancedParens a)
$cp2BalancedParens :: forall a. BalancedParens a => CloseAt (SimpleBalancedParens a)
$cp1BalancedParens :: forall a. BalancedParens a => OpenAt (SimpleBalancedParens a)
BalancedParens, SimpleBalancedParens a -> Count -> Maybe Count
(SimpleBalancedParens a -> Count -> Maybe Count)
-> FindOpen (SimpleBalancedParens a)
forall a.
FindOpen a =>
SimpleBalancedParens a -> Count -> Maybe Count
forall v. (v -> Count -> Maybe Count) -> FindOpen v
findOpen :: SimpleBalancedParens a -> Count -> Maybe Count
$cfindOpen :: forall a.
FindOpen a =>
SimpleBalancedParens a -> Count -> Maybe Count
FindOpen, SimpleBalancedParens a -> Count -> Maybe Count
(SimpleBalancedParens a -> Count -> Maybe Count)
-> FindClose (SimpleBalancedParens a)
forall a.
FindClose a =>
SimpleBalancedParens a -> Count -> Maybe Count
forall v. (v -> Count -> Maybe Count) -> FindClose v
findClose :: SimpleBalancedParens a -> Count -> Maybe Count
$cfindClose :: forall a.
FindClose a =>
SimpleBalancedParens a -> Count -> Maybe Count
FindClose, SimpleBalancedParens a -> Count -> Maybe Count
(SimpleBalancedParens a -> Count -> Maybe Count)
-> Enclose (SimpleBalancedParens a)
forall a.
Enclose a =>
SimpleBalancedParens a -> Count -> Maybe Count
forall v. (v -> Count -> Maybe Count) -> Enclose v
enclose :: SimpleBalancedParens a -> Count -> Maybe Count
$cenclose :: forall a.
Enclose a =>
SimpleBalancedParens a -> Count -> Maybe Count
Enclose, SimpleBalancedParens a -> Count -> Bool
(SimpleBalancedParens a -> Count -> Bool)
-> OpenAt (SimpleBalancedParens a)
forall a. OpenAt a => SimpleBalancedParens a -> Count -> Bool
forall v. (v -> Count -> Bool) -> OpenAt v
openAt :: SimpleBalancedParens a -> Count -> Bool
$copenAt :: forall a. OpenAt a => SimpleBalancedParens a -> Count -> Bool
OpenAt, SimpleBalancedParens a -> Count -> Bool
(SimpleBalancedParens a -> Count -> Bool)
-> CloseAt (SimpleBalancedParens a)
forall a. CloseAt a => SimpleBalancedParens a -> Count -> Bool
forall v. (v -> Count -> Bool) -> CloseAt v
closeAt :: SimpleBalancedParens a -> Count -> Bool
$ccloseAt :: forall a. CloseAt a => SimpleBalancedParens a -> Count -> Bool
CloseAt, SimpleBalancedParens a -> Position
SimpleBalancedParens a -> Count
(SimpleBalancedParens a -> Count)
-> (SimpleBalancedParens a -> Position)
-> BitLength (SimpleBalancedParens a)
forall a. BitLength a => SimpleBalancedParens a -> Position
forall a. BitLength a => SimpleBalancedParens a -> Count
forall v. (v -> Count) -> (v -> Position) -> BitLength v
endPosition :: SimpleBalancedParens a -> Position
$cendPosition :: forall a. BitLength a => SimpleBalancedParens a -> Position
bitLength :: SimpleBalancedParens a -> Count
$cbitLength :: forall a. BitLength a => SimpleBalancedParens a -> Count
BitLength, SimpleBalancedParens a -> String -> String
(SimpleBalancedParens a -> String -> String)
-> BitShow (SimpleBalancedParens a)
forall a. BitShow a => SimpleBalancedParens a -> String -> String
forall a. (a -> String -> String) -> BitShow a
bitShows :: SimpleBalancedParens a -> String -> String
$cbitShows :: forall a. BitShow a => SimpleBalancedParens a -> String -> String
BitShow, SimpleBalancedParens a -> SimpleBalancedParens a -> Bool
(SimpleBalancedParens a -> SimpleBalancedParens a -> Bool)
-> (SimpleBalancedParens a -> SimpleBalancedParens a -> Bool)
-> Eq (SimpleBalancedParens a)
forall a.
Eq a =>
SimpleBalancedParens a -> SimpleBalancedParens a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SimpleBalancedParens a -> SimpleBalancedParens a -> Bool
$c/= :: forall a.
Eq a =>
SimpleBalancedParens a -> SimpleBalancedParens a -> Bool
== :: SimpleBalancedParens a -> SimpleBalancedParens a -> Bool
$c== :: forall a.
Eq a =>
SimpleBalancedParens a -> SimpleBalancedParens a -> Bool
Eq, SimpleBalancedParens a -> Count -> Count
(SimpleBalancedParens a -> Count -> Count)
-> Rank0 (SimpleBalancedParens a)
forall a. Rank0 a => SimpleBalancedParens a -> Count -> Count
forall v. (v -> Count -> Count) -> Rank0 v
rank0 :: SimpleBalancedParens a -> Count -> Count
$crank0 :: forall a. Rank0 a => SimpleBalancedParens a -> Count -> Count
Rank0, SimpleBalancedParens a -> Count -> Count
(SimpleBalancedParens a -> Count -> Count)
-> Rank1 (SimpleBalancedParens a)
forall a. Rank1 a => SimpleBalancedParens a -> Count -> Count
forall v. (v -> Count -> Count) -> Rank1 v
rank1 :: SimpleBalancedParens a -> Count -> Count
$crank1 :: forall a. Rank1 a => SimpleBalancedParens a -> Count -> Count
Rank1, SimpleBalancedParens a -> Count -> Count
(SimpleBalancedParens a -> Count -> Count)
-> Select0 (SimpleBalancedParens a)
forall a. Select0 a => SimpleBalancedParens a -> Count -> Count
forall v. (v -> Count -> Count) -> Select0 v
select0 :: SimpleBalancedParens a -> Count -> Count
$cselect0 :: forall a. Select0 a => SimpleBalancedParens a -> Count -> Count
Select0, SimpleBalancedParens a -> Count -> Count
(SimpleBalancedParens a -> Count -> Count)
-> Select1 (SimpleBalancedParens a)
forall a. Select1 a => SimpleBalancedParens a -> Count -> Count
forall v. (v -> Count -> Count) -> Select1 v
select1 :: SimpleBalancedParens a -> Count -> Count
$cselect1 :: forall a. Select1 a => SimpleBalancedParens a -> Count -> Count
Select1, SimpleBalancedParens a -> Position -> Bool
(SimpleBalancedParens a -> Position -> Bool)
-> TestBit (SimpleBalancedParens a)
forall a. TestBit a => SimpleBalancedParens a -> Position -> Bool
forall a. (a -> Position -> Bool) -> TestBit a
.?. :: SimpleBalancedParens a -> Position -> Bool
$c.?. :: forall a. TestBit a => SimpleBalancedParens a -> Position -> Bool
TestBit, (forall x.
 SimpleBalancedParens a -> Rep (SimpleBalancedParens a) x)
-> (forall x.
    Rep (SimpleBalancedParens a) x -> SimpleBalancedParens a)
-> Generic (SimpleBalancedParens a)
forall x. Rep (SimpleBalancedParens a) x -> SimpleBalancedParens a
forall x. SimpleBalancedParens a -> Rep (SimpleBalancedParens a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x.
Rep (SimpleBalancedParens a) x -> SimpleBalancedParens a
forall a x.
SimpleBalancedParens a -> Rep (SimpleBalancedParens a) x
$cto :: forall a x.
Rep (SimpleBalancedParens a) x -> SimpleBalancedParens a
$cfrom :: forall a x.
SimpleBalancedParens a -> Rep (SimpleBalancedParens a) x
Generic)

instance Functor SimpleBalancedParens where
  fmap :: (a -> b) -> SimpleBalancedParens a -> SimpleBalancedParens b
fmap a -> b
f (SimpleBalancedParens a
a) = b -> SimpleBalancedParens b
forall a. a -> SimpleBalancedParens a
SimpleBalancedParens (a -> b
f a
a)
  {-# INLINABLE fmap   #-}

instance BitShow a => Show (SimpleBalancedParens a) where
  show :: SimpleBalancedParens a -> String
show = SimpleBalancedParens a -> String
forall a. BitShow a => a -> String
bitShow