{-# LANGUAGE CPP                 #-}
{-# LANGUAGE DeriveFoldable      #-}
{-# LANGUAGE DeriveFunctor       #-}
{-# LANGUAGE DeriveGeneric       #-}
{-# LANGUAGE DeriveTraversable   #-}
{-# LANGUAGE FlexibleInstances   #-}
{-# LANGUAGE LambdaCase          #-}

module Language.Sexp.Types
  ( Atom (..)
  , Prefix (..)
  , Fix (..)
  , SexpF (..)
  , Compose (..)
  , Position (..)
  , dummyPos
  , LocatedBy (..)
  , location
  , extract
  , stripLocation
  , addLocation
  ) where

import Control.DeepSeq

import Data.Bifunctor

import Data.Fix (Fix (..))
import Data.Functor.Classes
import Data.Functor.Compose
import Data.Functor.Foldable (cata)
import Data.Scientific (Scientific)
import Data.Text (Text)
#if !MIN_VERSION_prettyprinter(1,7,0)
import Data.Text.Prettyprint.Doc (Pretty (..), colon)
#else
import Prettyprinter (Pretty (..), colon)
#endif
import GHC.Generics

----------------------------------------------------------------------
-- Positions

-- | Position: file name, line number, column number
data Position =
  Position FilePath {-# UNPACK #-} !Int {-# UNPACK #-} !Int
  deriving (Eq Position
Position -> Position -> Bool
Position -> Position -> Ordering
Position -> Position -> Position
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Position -> Position -> Position
$cmin :: Position -> Position -> Position
max :: Position -> Position -> Position
$cmax :: Position -> Position -> Position
>= :: Position -> Position -> Bool
$c>= :: Position -> Position -> Bool
> :: Position -> Position -> Bool
$c> :: Position -> Position -> Bool
<= :: Position -> Position -> Bool
$c<= :: Position -> Position -> Bool
< :: Position -> Position -> Bool
$c< :: Position -> Position -> Bool
compare :: Position -> Position -> Ordering
$ccompare :: Position -> Position -> Ordering
Ord, Position -> Position -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Position -> Position -> Bool
$c/= :: Position -> Position -> Bool
== :: Position -> Position -> Bool
$c== :: Position -> Position -> Bool
Eq, forall x. Rep Position x -> Position
forall x. Position -> Rep Position x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Position x -> Position
$cfrom :: forall x. Position -> Rep Position x
Generic)

dummyPos :: Position
dummyPos :: Position
dummyPos = FilePath -> Int -> Int -> Position
Position FilePath
"<no location information>" Int
1 Int
0

instance Pretty Position where
  pretty :: forall ann. Position -> Doc ann
pretty (Position FilePath
fn Int
line Int
col) =
    forall a ann. Pretty a => a -> Doc ann
pretty FilePath
fn forall a. Semigroup a => a -> a -> a
<> forall ann. Doc ann
colon forall a. Semigroup a => a -> a -> a
<> forall a ann. Pretty a => a -> Doc ann
pretty Int
line forall a. Semigroup a => a -> a -> a
<> forall ann. Doc ann
colon forall a. Semigroup a => a -> a -> a
<> forall a ann. Pretty a => a -> Doc ann
pretty Int
col

instance Show Position where
  show :: Position -> FilePath
show (Position FilePath
fn Int
line Int
col) =
    FilePath
fn forall a. [a] -> [a] -> [a]
++ FilePath
":" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> FilePath
show Int
line forall a. [a] -> [a] -> [a]
++ FilePath
":" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> FilePath
show Int
col

----------------------------------------------------------------------
-- Annotations

-- | Annotation functor for positions
data LocatedBy a e = !a :< e
    deriving (Int -> LocatedBy a e -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
forall a e. (Show a, Show e) => Int -> LocatedBy a e -> ShowS
forall a e. (Show a, Show e) => [LocatedBy a e] -> ShowS
forall a e. (Show a, Show e) => LocatedBy a e -> FilePath
showList :: [LocatedBy a e] -> ShowS
$cshowList :: forall a e. (Show a, Show e) => [LocatedBy a e] -> ShowS
show :: LocatedBy a e -> FilePath
$cshow :: forall a e. (Show a, Show e) => LocatedBy a e -> FilePath
showsPrec :: Int -> LocatedBy a e -> ShowS
$cshowsPrec :: forall a e. (Show a, Show e) => Int -> LocatedBy a e -> ShowS
Show, LocatedBy a e -> LocatedBy a e -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a e. (Eq a, Eq e) => LocatedBy a e -> LocatedBy a e -> Bool
/= :: LocatedBy a e -> LocatedBy a e -> Bool
$c/= :: forall a e. (Eq a, Eq e) => LocatedBy a e -> LocatedBy a e -> Bool
== :: LocatedBy a e -> LocatedBy a e -> Bool
$c== :: forall a e. (Eq a, Eq e) => LocatedBy a e -> LocatedBy a e -> Bool
Eq, LocatedBy a e -> LocatedBy a e -> Bool
LocatedBy a e -> LocatedBy a e -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a} {e}. (Ord a, Ord e) => Eq (LocatedBy a e)
forall a e.
(Ord a, Ord e) =>
LocatedBy a e -> LocatedBy a e -> Bool
forall a e.
(Ord a, Ord e) =>
LocatedBy a e -> LocatedBy a e -> Ordering
forall a e.
(Ord a, Ord e) =>
LocatedBy a e -> LocatedBy a e -> LocatedBy a e
min :: LocatedBy a e -> LocatedBy a e -> LocatedBy a e
$cmin :: forall a e.
(Ord a, Ord e) =>
LocatedBy a e -> LocatedBy a e -> LocatedBy a e
max :: LocatedBy a e -> LocatedBy a e -> LocatedBy a e
$cmax :: forall a e.
(Ord a, Ord e) =>
LocatedBy a e -> LocatedBy a e -> LocatedBy a e
>= :: LocatedBy a e -> LocatedBy a e -> Bool
$c>= :: forall a e.
(Ord a, Ord e) =>
LocatedBy a e -> LocatedBy a e -> Bool
> :: LocatedBy a e -> LocatedBy a e -> Bool
$c> :: forall a e.
(Ord a, Ord e) =>
LocatedBy a e -> LocatedBy a e -> Bool
<= :: LocatedBy a e -> LocatedBy a e -> Bool
$c<= :: forall a e.
(Ord a, Ord e) =>
LocatedBy a e -> LocatedBy a e -> Bool
< :: LocatedBy a e -> LocatedBy a e -> Bool
$c< :: forall a e.
(Ord a, Ord e) =>
LocatedBy a e -> LocatedBy a e -> Bool
compare :: LocatedBy a e -> LocatedBy a e -> Ordering
$ccompare :: forall a e.
(Ord a, Ord e) =>
LocatedBy a e -> LocatedBy a e -> Ordering
Ord, forall a b. a -> LocatedBy a b -> LocatedBy a a
forall a b. (a -> b) -> LocatedBy a a -> LocatedBy a b
forall a a b. a -> LocatedBy a b -> LocatedBy a a
forall a a b. (a -> b) -> LocatedBy a a -> LocatedBy a b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> LocatedBy a b -> LocatedBy a a
$c<$ :: forall a a b. a -> LocatedBy a b -> LocatedBy a a
fmap :: forall a b. (a -> b) -> LocatedBy a a -> LocatedBy a b
$cfmap :: forall a a b. (a -> b) -> LocatedBy a a -> LocatedBy a b
Functor, forall a. LocatedBy a a -> Bool
forall a a. Eq a => a -> LocatedBy a a -> Bool
forall a a. Num a => LocatedBy a a -> a
forall a a. Ord a => LocatedBy a a -> a
forall m a. Monoid m => (a -> m) -> LocatedBy a a -> m
forall a m. Monoid m => LocatedBy a m -> m
forall a a. LocatedBy a a -> Bool
forall a a. LocatedBy a a -> Int
forall a a. LocatedBy a a -> [a]
forall a b. (a -> b -> b) -> b -> LocatedBy a a -> b
forall a a. (a -> a -> a) -> LocatedBy a a -> a
forall a m a. Monoid m => (a -> m) -> LocatedBy a a -> m
forall a b a. (b -> a -> b) -> b -> LocatedBy a a -> b
forall a a b. (a -> b -> b) -> b -> LocatedBy a a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => LocatedBy a a -> a
$cproduct :: forall a a. Num a => LocatedBy a a -> a
sum :: forall a. Num a => LocatedBy a a -> a
$csum :: forall a a. Num a => LocatedBy a a -> a
minimum :: forall a. Ord a => LocatedBy a a -> a
$cminimum :: forall a a. Ord a => LocatedBy a a -> a
maximum :: forall a. Ord a => LocatedBy a a -> a
$cmaximum :: forall a a. Ord a => LocatedBy a a -> a
elem :: forall a. Eq a => a -> LocatedBy a a -> Bool
$celem :: forall a a. Eq a => a -> LocatedBy a a -> Bool
length :: forall a. LocatedBy a a -> Int
$clength :: forall a a. LocatedBy a a -> Int
null :: forall a. LocatedBy a a -> Bool
$cnull :: forall a a. LocatedBy a a -> Bool
toList :: forall a. LocatedBy a a -> [a]
$ctoList :: forall a a. LocatedBy a a -> [a]
foldl1 :: forall a. (a -> a -> a) -> LocatedBy a a -> a
$cfoldl1 :: forall a a. (a -> a -> a) -> LocatedBy a a -> a
foldr1 :: forall a. (a -> a -> a) -> LocatedBy a a -> a
$cfoldr1 :: forall a a. (a -> a -> a) -> LocatedBy a a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> LocatedBy a a -> b
$cfoldl' :: forall a b a. (b -> a -> b) -> b -> LocatedBy a a -> b
foldl :: forall b a. (b -> a -> b) -> b -> LocatedBy a a -> b
$cfoldl :: forall a b a. (b -> a -> b) -> b -> LocatedBy a a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> LocatedBy a a -> b
$cfoldr' :: forall a a b. (a -> b -> b) -> b -> LocatedBy a a -> b
foldr :: forall a b. (a -> b -> b) -> b -> LocatedBy a a -> b
$cfoldr :: forall a a b. (a -> b -> b) -> b -> LocatedBy a a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> LocatedBy a a -> m
$cfoldMap' :: forall a m a. Monoid m => (a -> m) -> LocatedBy a a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> LocatedBy a a -> m
$cfoldMap :: forall a m a. Monoid m => (a -> m) -> LocatedBy a a -> m
fold :: forall m. Monoid m => LocatedBy a m -> m
$cfold :: forall a m. Monoid m => LocatedBy a m -> m
Foldable, forall a. Functor (LocatedBy a)
forall a. Foldable (LocatedBy a)
forall a (m :: * -> *) a.
Monad m =>
LocatedBy a (m a) -> m (LocatedBy a a)
forall a (f :: * -> *) a.
Applicative f =>
LocatedBy a (f a) -> f (LocatedBy a a)
forall a (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LocatedBy a a -> m (LocatedBy a b)
forall a (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LocatedBy a a -> f (LocatedBy a b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LocatedBy a a -> f (LocatedBy a b)
sequence :: forall (m :: * -> *) a.
Monad m =>
LocatedBy a (m a) -> m (LocatedBy a a)
$csequence :: forall a (m :: * -> *) a.
Monad m =>
LocatedBy a (m a) -> m (LocatedBy a a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LocatedBy a a -> m (LocatedBy a b)
$cmapM :: forall a (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LocatedBy a a -> m (LocatedBy a b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
LocatedBy a (f a) -> f (LocatedBy a a)
$csequenceA :: forall a (f :: * -> *) a.
Applicative f =>
LocatedBy a (f a) -> f (LocatedBy a a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LocatedBy a a -> f (LocatedBy a b)
$ctraverse :: forall a (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LocatedBy a a -> f (LocatedBy a b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a e x. Rep (LocatedBy a e) x -> LocatedBy a e
forall a e x. LocatedBy a e -> Rep (LocatedBy a e) x
$cto :: forall a e x. Rep (LocatedBy a e) x -> LocatedBy a e
$cfrom :: forall a e x. LocatedBy a e -> Rep (LocatedBy a e) x
Generic)

instance Bifunctor LocatedBy where
  bimap :: forall a b c d.
(a -> b) -> (c -> d) -> LocatedBy a c -> LocatedBy b d
bimap a -> b
f c -> d
g (a
a :< c
e) = a -> b
f a
a forall a e. a -> e -> LocatedBy a e
:< c -> d
g c
e

instance (Eq p) => Eq1 (LocatedBy p) where
  liftEq :: forall a b.
(a -> b -> Bool) -> LocatedBy p a -> LocatedBy p b -> Bool
liftEq a -> b -> Bool
eq (p
p :< a
a) (p
q :< b
b) = p
p forall a. Eq a => a -> a -> Bool
== p
q Bool -> Bool -> Bool
&& a
a a -> b -> Bool
`eq` b
b

instance NFData p => NFData1 (LocatedBy p) where
  liftRnf :: forall a. (a -> ()) -> LocatedBy p a -> ()
liftRnf a -> ()
f (p
p :< a
a) = forall a. NFData a => a -> ()
rnf p
p seq :: forall a b. a -> b -> b
`seq` a -> ()
f a
a

location :: LocatedBy a e -> a
location :: forall a e. LocatedBy a e -> a
location (a
a :< e
_) = a
a

extract :: LocatedBy a e -> e
extract :: forall a e. LocatedBy a e -> e
extract (a
_ :< e
e) = e
e

stripLocation :: (Functor f) => Fix (Compose (LocatedBy p) f) -> Fix f
stripLocation :: forall (f :: * -> *) p.
Functor f =>
Fix (Compose (LocatedBy p) f) -> Fix f
stripLocation = forall t a. Recursive t => (Base t a -> a) -> t -> a
cata (forall (f :: * -> *). f (Fix f) -> Fix f
Fix forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a e. LocatedBy a e -> e
extract forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose)

addLocation :: (Functor f) => p -> Fix f -> Fix (Compose (LocatedBy p) f)
addLocation :: forall (f :: * -> *) p.
Functor f =>
p -> Fix f -> Fix (Compose (LocatedBy p) f)
addLocation p
p = forall t a. Recursive t => (Base t a -> a) -> t -> a
cata (forall (f :: * -> *). f (Fix f) -> Fix f
Fix forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose forall b c a. (b -> c) -> (a -> b) -> a -> c
. (p
p forall a e. a -> e -> LocatedBy a e
:<))

----------------------------------------------------------------------
-- Sexp

-- | S-expression atom type
data Atom
  = AtomNumber {-# UNPACK #-} !Scientific
  | AtomString {-# UNPACK #-} !Text
  | AtomSymbol {-# UNPACK #-} !Text
    deriving (Int -> Atom -> ShowS
[Atom] -> ShowS
Atom -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Atom] -> ShowS
$cshowList :: [Atom] -> ShowS
show :: Atom -> FilePath
$cshow :: Atom -> FilePath
showsPrec :: Int -> Atom -> ShowS
$cshowsPrec :: Int -> Atom -> ShowS
Show, Atom -> Atom -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Atom -> Atom -> Bool
$c/= :: Atom -> Atom -> Bool
== :: Atom -> Atom -> Bool
$c== :: Atom -> Atom -> Bool
Eq, Eq Atom
Atom -> Atom -> Bool
Atom -> Atom -> Ordering
Atom -> Atom -> Atom
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Atom -> Atom -> Atom
$cmin :: Atom -> Atom -> Atom
max :: Atom -> Atom -> Atom
$cmax :: Atom -> Atom -> Atom
>= :: Atom -> Atom -> Bool
$c>= :: Atom -> Atom -> Bool
> :: Atom -> Atom -> Bool
$c> :: Atom -> Atom -> Bool
<= :: Atom -> Atom -> Bool
$c<= :: Atom -> Atom -> Bool
< :: Atom -> Atom -> Bool
$c< :: Atom -> Atom -> Bool
compare :: Atom -> Atom -> Ordering
$ccompare :: Atom -> Atom -> Ordering
Ord, forall x. Rep Atom x -> Atom
forall x. Atom -> Rep Atom x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Atom x -> Atom
$cfrom :: forall x. Atom -> Rep Atom x
Generic)

-- | S-expression quotation type
data Prefix
  = Quote
  | Backtick
  | Comma
  | CommaAt
  | Hash
    deriving (Int -> Prefix -> ShowS
[Prefix] -> ShowS
Prefix -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Prefix] -> ShowS
$cshowList :: [Prefix] -> ShowS
show :: Prefix -> FilePath
$cshow :: Prefix -> FilePath
showsPrec :: Int -> Prefix -> ShowS
$cshowsPrec :: Int -> Prefix -> ShowS
Show, Prefix -> Prefix -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Prefix -> Prefix -> Bool
$c/= :: Prefix -> Prefix -> Bool
== :: Prefix -> Prefix -> Bool
$c== :: Prefix -> Prefix -> Bool
Eq, Eq Prefix
Prefix -> Prefix -> Bool
Prefix -> Prefix -> Ordering
Prefix -> Prefix -> Prefix
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Prefix -> Prefix -> Prefix
$cmin :: Prefix -> Prefix -> Prefix
max :: Prefix -> Prefix -> Prefix
$cmax :: Prefix -> Prefix -> Prefix
>= :: Prefix -> Prefix -> Bool
$c>= :: Prefix -> Prefix -> Bool
> :: Prefix -> Prefix -> Bool
$c> :: Prefix -> Prefix -> Bool
<= :: Prefix -> Prefix -> Bool
$c<= :: Prefix -> Prefix -> Bool
< :: Prefix -> Prefix -> Bool
$c< :: Prefix -> Prefix -> Bool
compare :: Prefix -> Prefix -> Ordering
$ccompare :: Prefix -> Prefix -> Ordering
Ord, forall x. Rep Prefix x -> Prefix
forall x. Prefix -> Rep Prefix x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Prefix x -> Prefix
$cfrom :: forall x. Prefix -> Rep Prefix x
Generic)

instance NFData Prefix

-- | S-expression functor
data SexpF e
  = AtomF        !Atom
  | ParenListF   [e]
  | BracketListF [e]
  | BraceListF   [e]
  | ModifiedF    !Prefix e
    deriving (forall a b. a -> SexpF b -> SexpF a
forall a b. (a -> b) -> SexpF a -> SexpF b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> SexpF b -> SexpF a
$c<$ :: forall a b. a -> SexpF b -> SexpF a
fmap :: forall a b. (a -> b) -> SexpF a -> SexpF b
$cfmap :: forall a b. (a -> b) -> SexpF a -> SexpF b
Functor, forall a. Eq a => a -> SexpF a -> Bool
forall a. Num a => SexpF a -> a
forall a. Ord a => SexpF a -> a
forall m. Monoid m => SexpF m -> m
forall a. SexpF a -> Bool
forall a. SexpF a -> Int
forall a. SexpF a -> [a]
forall a. (a -> a -> a) -> SexpF a -> a
forall m a. Monoid m => (a -> m) -> SexpF a -> m
forall b a. (b -> a -> b) -> b -> SexpF a -> b
forall a b. (a -> b -> b) -> b -> SexpF a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => SexpF a -> a
$cproduct :: forall a. Num a => SexpF a -> a
sum :: forall a. Num a => SexpF a -> a
$csum :: forall a. Num a => SexpF a -> a
minimum :: forall a. Ord a => SexpF a -> a
$cminimum :: forall a. Ord a => SexpF a -> a
maximum :: forall a. Ord a => SexpF a -> a
$cmaximum :: forall a. Ord a => SexpF a -> a
elem :: forall a. Eq a => a -> SexpF a -> Bool
$celem :: forall a. Eq a => a -> SexpF a -> Bool
length :: forall a. SexpF a -> Int
$clength :: forall a. SexpF a -> Int
null :: forall a. SexpF a -> Bool
$cnull :: forall a. SexpF a -> Bool
toList :: forall a. SexpF a -> [a]
$ctoList :: forall a. SexpF a -> [a]
foldl1 :: forall a. (a -> a -> a) -> SexpF a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> SexpF a -> a
foldr1 :: forall a. (a -> a -> a) -> SexpF a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> SexpF a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> SexpF a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> SexpF a -> b
foldl :: forall b a. (b -> a -> b) -> b -> SexpF a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> SexpF a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> SexpF a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> SexpF a -> b
foldr :: forall a b. (a -> b -> b) -> b -> SexpF a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> SexpF a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> SexpF a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> SexpF a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> SexpF a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> SexpF a -> m
fold :: forall m. Monoid m => SexpF m -> m
$cfold :: forall m. Monoid m => SexpF m -> m
Foldable, Functor SexpF
Foldable SexpF
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => SexpF (m a) -> m (SexpF a)
forall (f :: * -> *) a. Applicative f => SexpF (f a) -> f (SexpF a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SexpF a -> m (SexpF b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SexpF a -> f (SexpF b)
sequence :: forall (m :: * -> *) a. Monad m => SexpF (m a) -> m (SexpF a)
$csequence :: forall (m :: * -> *) a. Monad m => SexpF (m a) -> m (SexpF a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SexpF a -> m (SexpF b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SexpF a -> m (SexpF b)
sequenceA :: forall (f :: * -> *) a. Applicative f => SexpF (f a) -> f (SexpF a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => SexpF (f a) -> f (SexpF a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SexpF a -> f (SexpF b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SexpF a -> f (SexpF b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall e x. Rep (SexpF e) x -> SexpF e
forall e x. SexpF e -> Rep (SexpF e) x
$cto :: forall e x. Rep (SexpF e) x -> SexpF e
$cfrom :: forall e x. SexpF e -> Rep (SexpF e) x
Generic)

instance Eq a => Eq (SexpF a) where
  == :: SexpF a -> SexpF a -> Bool
(==) = forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool) -> f a -> f b -> Bool
liftEq forall a. Eq a => a -> a -> Bool
(==)

instance Eq1 SexpF where
  liftEq :: forall a b. (a -> b -> Bool) -> SexpF a -> SexpF b -> Bool
liftEq a -> b -> Bool
eq = SexpF a -> SexpF b -> Bool
go
    where
      go :: SexpF a -> SexpF b -> Bool
go (AtomF Atom
a) (AtomF Atom
b) = Atom
a forall a. Eq a => a -> a -> Bool
== Atom
b
      go (ParenListF [a]
as) (ParenListF [b]
bs) = forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool) -> f a -> f b -> Bool
liftEq a -> b -> Bool
eq [a]
as [b]
bs
      go (BracketListF [a]
as) (BracketListF [b]
bs) = forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool) -> f a -> f b -> Bool
liftEq a -> b -> Bool
eq [a]
as [b]
bs
      go (BraceListF [a]
as) (BraceListF [b]
bs) = forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool) -> f a -> f b -> Bool
liftEq a -> b -> Bool
eq [a]
as [b]
bs
      go (ModifiedF Prefix
q a
a) (ModifiedF Prefix
p b
b) = Prefix
q forall a. Eq a => a -> a -> Bool
== Prefix
p Bool -> Bool -> Bool
&& a
a a -> b -> Bool
`eq` b
b
      go SexpF a
_ SexpF b
_ = Bool
False

instance NFData Atom

instance NFData Position

instance NFData1 SexpF where
  liftRnf :: forall a. (a -> ()) -> SexpF a -> ()
liftRnf a -> ()
f = \case
    AtomF Atom
a -> forall a. NFData a => a -> ()
rnf Atom
a
    ParenListF [a]
as -> forall (f :: * -> *) a. NFData1 f => (a -> ()) -> f a -> ()
liftRnf a -> ()
f [a]
as
    BracketListF [a]
as -> forall (f :: * -> *) a. NFData1 f => (a -> ()) -> f a -> ()
liftRnf a -> ()
f [a]
as
    BraceListF [a]
as -> forall (f :: * -> *) a. NFData1 f => (a -> ()) -> f a -> ()
liftRnf a -> ()
f [a]
as
    ModifiedF Prefix
q a
a -> forall a. NFData a => a -> ()
rnf Prefix
q seq :: forall a b. a -> b -> b
`seq` a -> ()
f a
a

#if !MIN_VERSION_deepseq(1,4,3)
instance NFData1 (Compose (LocatedBy Position) SexpF) where
  liftRnf f (Compose (p :< a)) = rnf p `seq` liftRnf f a
#endif