-- |
--
-- Module:      Language.Egison.Syntax.Pattern.Base
-- Description: Abstract syntax tree for Egison pattern expression
-- Stability:   experimental
--
-- This module defines an AST (Abstract Syntax Tree) for Egison pattern expression.

module Language.Egison.Syntax.Pattern.Expr
  ( Expr(..)
  )
where

import           GHC.Generics                   ( Generic )
import           Data.Data                      ( Data
                                                , Typeable
                                                )


-- | Egison pattern expressions.
-- @n@ is a type for name references in patterns, such as them in pattern constructors.
-- @v@ is a type for name bindings in patterns, such as them in pattern variables.
-- @e@ is a type for expressions in patterns, such as them in value patterns.
data Expr n v e
  -- | Wildcard pattern. Match with everything.
  = Wildcard
  -- | Pattern variable. The matched term is bound to the name.
  | Variable v
  -- | Value pattern. Match with equal terms.
  | Value e
  -- | Predicate pattern. Match with terms that satisfy the given predicate.
  | Predicate e
  -- | And pattern. Match when both patterns matches.
  | And (Expr n v e) (Expr n v e)
  -- | Or pattern. Match when one of given patterns matches.
  | Or (Expr n v e) (Expr n v e)
  -- | Not pattern. Match when the given pattern does not match.
  | Not (Expr n v e)
  -- | Tuple pattern. Match with tuples whose elements match with respective patterns.
  | Tuple [Expr n v e]
  -- | Collection pattern. Match with collections whose elements match with respective patterns.
  | Collection [Expr n v e]
  -- | User-defined infix pattern.
  | Infix n (Expr n v e) (Expr n v e)
  -- | User-defined normal pattern.
  | Pattern n [Expr n v e]
  deriving (Expr n v e -> Expr n v e -> Bool
(Expr n v e -> Expr n v e -> Bool)
-> (Expr n v e -> Expr n v e -> Bool) -> Eq (Expr n v e)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall n v e.
(Eq v, Eq e, Eq n) =>
Expr n v e -> Expr n v e -> Bool
/= :: Expr n v e -> Expr n v e -> Bool
$c/= :: forall n v e.
(Eq v, Eq e, Eq n) =>
Expr n v e -> Expr n v e -> Bool
== :: Expr n v e -> Expr n v e -> Bool
$c== :: forall n v e.
(Eq v, Eq e, Eq n) =>
Expr n v e -> Expr n v e -> Bool
Eq, Eq (Expr n v e)
Eq (Expr n v e)
-> (Expr n v e -> Expr n v e -> Ordering)
-> (Expr n v e -> Expr n v e -> Bool)
-> (Expr n v e -> Expr n v e -> Bool)
-> (Expr n v e -> Expr n v e -> Bool)
-> (Expr n v e -> Expr n v e -> Bool)
-> (Expr n v e -> Expr n v e -> Expr n v e)
-> (Expr n v e -> Expr n v e -> Expr n v e)
-> Ord (Expr n v e)
Expr n v e -> Expr n v e -> Bool
Expr n v e -> Expr n v e -> Ordering
Expr n v e -> Expr n v e -> Expr n v e
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 n v e. (Ord v, Ord e, Ord n) => Eq (Expr n v e)
forall n v e.
(Ord v, Ord e, Ord n) =>
Expr n v e -> Expr n v e -> Bool
forall n v e.
(Ord v, Ord e, Ord n) =>
Expr n v e -> Expr n v e -> Ordering
forall n v e.
(Ord v, Ord e, Ord n) =>
Expr n v e -> Expr n v e -> Expr n v e
min :: Expr n v e -> Expr n v e -> Expr n v e
$cmin :: forall n v e.
(Ord v, Ord e, Ord n) =>
Expr n v e -> Expr n v e -> Expr n v e
max :: Expr n v e -> Expr n v e -> Expr n v e
$cmax :: forall n v e.
(Ord v, Ord e, Ord n) =>
Expr n v e -> Expr n v e -> Expr n v e
>= :: Expr n v e -> Expr n v e -> Bool
$c>= :: forall n v e.
(Ord v, Ord e, Ord n) =>
Expr n v e -> Expr n v e -> Bool
> :: Expr n v e -> Expr n v e -> Bool
$c> :: forall n v e.
(Ord v, Ord e, Ord n) =>
Expr n v e -> Expr n v e -> Bool
<= :: Expr n v e -> Expr n v e -> Bool
$c<= :: forall n v e.
(Ord v, Ord e, Ord n) =>
Expr n v e -> Expr n v e -> Bool
< :: Expr n v e -> Expr n v e -> Bool
$c< :: forall n v e.
(Ord v, Ord e, Ord n) =>
Expr n v e -> Expr n v e -> Bool
compare :: Expr n v e -> Expr n v e -> Ordering
$ccompare :: forall n v e.
(Ord v, Ord e, Ord n) =>
Expr n v e -> Expr n v e -> Ordering
$cp1Ord :: forall n v e. (Ord v, Ord e, Ord n) => Eq (Expr n v e)
Ord, Int -> Expr n v e -> ShowS
[Expr n v e] -> ShowS
Expr n v e -> String
(Int -> Expr n v e -> ShowS)
-> (Expr n v e -> String)
-> ([Expr n v e] -> ShowS)
-> Show (Expr n v e)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall n v e.
(Show v, Show e, Show n) =>
Int -> Expr n v e -> ShowS
forall n v e. (Show v, Show e, Show n) => [Expr n v e] -> ShowS
forall n v e. (Show v, Show e, Show n) => Expr n v e -> String
showList :: [Expr n v e] -> ShowS
$cshowList :: forall n v e. (Show v, Show e, Show n) => [Expr n v e] -> ShowS
show :: Expr n v e -> String
$cshow :: forall n v e. (Show v, Show e, Show n) => Expr n v e -> String
showsPrec :: Int -> Expr n v e -> ShowS
$cshowsPrec :: forall n v e.
(Show v, Show e, Show n) =>
Int -> Expr n v e -> ShowS
Show, Typeable, Typeable (Expr n v e)
DataType
Constr
Typeable (Expr n v e)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr n v e -> c (Expr n v e))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Expr n v e))
-> (Expr n v e -> Constr)
-> (Expr n v e -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Expr n v e)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Expr n v e)))
-> ((forall b. Data b => b -> b) -> Expr n v e -> Expr n v e)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Expr n v e -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Expr n v e -> r)
-> (forall u. (forall d. Data d => d -> u) -> Expr n v e -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Expr n v e -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expr n v e -> m (Expr n v e))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr n v e -> m (Expr n v e))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr n v e -> m (Expr n v e))
-> Data (Expr n v e)
Expr n v e -> DataType
Expr n v e -> Constr
(forall b. Data b => b -> b) -> Expr n v e -> Expr n v e
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr n v e -> c (Expr n v e)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr n v e)
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Expr n v e -> u
forall u. (forall d. Data d => d -> u) -> Expr n v e -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expr n v e -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expr n v e -> r
forall n v e. (Data n, Data v, Data e) => Typeable (Expr n v e)
forall n v e. (Data n, Data v, Data e) => Expr n v e -> DataType
forall n v e. (Data n, Data v, Data e) => Expr n v e -> Constr
forall n v e.
(Data n, Data v, Data e) =>
(forall b. Data b => b -> b) -> Expr n v e -> Expr n v e
forall n v e u.
(Data n, Data v, Data e) =>
Int -> (forall d. Data d => d -> u) -> Expr n v e -> u
forall n v e u.
(Data n, Data v, Data e) =>
(forall d. Data d => d -> u) -> Expr n v e -> [u]
forall n v e r r'.
(Data n, Data v, Data e) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expr n v e -> r
forall n v e r r'.
(Data n, Data v, Data e) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expr n v e -> r
forall n v e (m :: * -> *).
(Data n, Data v, Data e, Monad m) =>
(forall d. Data d => d -> m d) -> Expr n v e -> m (Expr n v e)
forall n v e (m :: * -> *).
(Data n, Data v, Data e, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr n v e -> m (Expr n v e)
forall n v e (c :: * -> *).
(Data n, Data v, Data e) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr n v e)
forall n v e (c :: * -> *).
(Data n, Data v, Data e) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr n v e -> c (Expr n v e)
forall n v e (t :: * -> *) (c :: * -> *).
(Data n, Data v, Data e, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr n v e))
forall n v e (t :: * -> * -> *) (c :: * -> *).
(Data n, Data v, Data e, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expr n v e))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr n v e -> m (Expr n v e)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr n v e -> m (Expr n v e)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr n v e)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr n v e -> c (Expr n v e)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr n v e))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expr n v e))
$cPattern :: Constr
$cInfix :: Constr
$cCollection :: Constr
$cTuple :: Constr
$cNot :: Constr
$cOr :: Constr
$cAnd :: Constr
$cPredicate :: Constr
$cValue :: Constr
$cVariable :: Constr
$cWildcard :: Constr
$tExpr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Expr n v e -> m (Expr n v e)
$cgmapMo :: forall n v e (m :: * -> *).
(Data n, Data v, Data e, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr n v e -> m (Expr n v e)
gmapMp :: (forall d. Data d => d -> m d) -> Expr n v e -> m (Expr n v e)
$cgmapMp :: forall n v e (m :: * -> *).
(Data n, Data v, Data e, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr n v e -> m (Expr n v e)
gmapM :: (forall d. Data d => d -> m d) -> Expr n v e -> m (Expr n v e)
$cgmapM :: forall n v e (m :: * -> *).
(Data n, Data v, Data e, Monad m) =>
(forall d. Data d => d -> m d) -> Expr n v e -> m (Expr n v e)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Expr n v e -> u
$cgmapQi :: forall n v e u.
(Data n, Data v, Data e) =>
Int -> (forall d. Data d => d -> u) -> Expr n v e -> u
gmapQ :: (forall d. Data d => d -> u) -> Expr n v e -> [u]
$cgmapQ :: forall n v e u.
(Data n, Data v, Data e) =>
(forall d. Data d => d -> u) -> Expr n v e -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expr n v e -> r
$cgmapQr :: forall n v e r r'.
(Data n, Data v, Data e) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expr n v e -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expr n v e -> r
$cgmapQl :: forall n v e r r'.
(Data n, Data v, Data e) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expr n v e -> r
gmapT :: (forall b. Data b => b -> b) -> Expr n v e -> Expr n v e
$cgmapT :: forall n v e.
(Data n, Data v, Data e) =>
(forall b. Data b => b -> b) -> Expr n v e -> Expr n v e
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expr n v e))
$cdataCast2 :: forall n v e (t :: * -> * -> *) (c :: * -> *).
(Data n, Data v, Data e, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expr n v e))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Expr n v e))
$cdataCast1 :: forall n v e (t :: * -> *) (c :: * -> *).
(Data n, Data v, Data e, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr n v e))
dataTypeOf :: Expr n v e -> DataType
$cdataTypeOf :: forall n v e. (Data n, Data v, Data e) => Expr n v e -> DataType
toConstr :: Expr n v e -> Constr
$ctoConstr :: forall n v e. (Data n, Data v, Data e) => Expr n v e -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr n v e)
$cgunfold :: forall n v e (c :: * -> *).
(Data n, Data v, Data e) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr n v e)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr n v e -> c (Expr n v e)
$cgfoldl :: forall n v e (c :: * -> *).
(Data n, Data v, Data e) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr n v e -> c (Expr n v e)
$cp1Data :: forall n v e. (Data n, Data v, Data e) => Typeable (Expr n v e)
Data, (forall x. Expr n v e -> Rep (Expr n v e) x)
-> (forall x. Rep (Expr n v e) x -> Expr n v e)
-> Generic (Expr n v e)
forall x. Rep (Expr n v e) x -> Expr n v e
forall x. Expr n v e -> Rep (Expr n v e) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall n v e x. Rep (Expr n v e) x -> Expr n v e
forall n v e x. Expr n v e -> Rep (Expr n v e) x
$cto :: forall n v e x. Rep (Expr n v e) x -> Expr n v e
$cfrom :: forall n v e x. Expr n v e -> Rep (Expr n v e) x
Generic)