{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./CASL_DL/AS_CASL_DL.der.hs
Description :  abstract syntax for CASL_DL logic extension of CASL
Copyright   :  (c) Klaus Luettich, Dominik Luecke, Uni Bremen 2004-2008
License     :  GPLv2 or higher, see LICENSE.txt

Maintainer  :  luecke@informatik.uni-bremen.de
Stability   :  provisional
Portability :  portable

Abstract syntax for CASL_DL logic extension of CASL
  Only the added syntax is specified
-}

module CASL_DL.AS_CASL_DL where

import Data.Data

import Common.Id
import Common.AS_Annotation

import CASL.AS_Basic_CASL

-- DrIFT command
{-! global: GetRange !-}

type DL_BASIC_SPEC = BASIC_SPEC () () DL_FORMULA

type AnDLFORM = Annoted (FORMULA DL_FORMULA)

data CardType = CMin | CMax | CExact deriving (CardType -> CardType -> Bool
(CardType -> CardType -> Bool)
-> (CardType -> CardType -> Bool) -> Eq CardType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CardType -> CardType -> Bool
$c/= :: CardType -> CardType -> Bool
== :: CardType -> CardType -> Bool
$c== :: CardType -> CardType -> Bool
Eq, Eq CardType
Eq CardType =>
(CardType -> CardType -> Ordering)
-> (CardType -> CardType -> Bool)
-> (CardType -> CardType -> Bool)
-> (CardType -> CardType -> Bool)
-> (CardType -> CardType -> Bool)
-> (CardType -> CardType -> CardType)
-> (CardType -> CardType -> CardType)
-> Ord CardType
CardType -> CardType -> Bool
CardType -> CardType -> Ordering
CardType -> CardType -> CardType
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 :: CardType -> CardType -> CardType
$cmin :: CardType -> CardType -> CardType
max :: CardType -> CardType -> CardType
$cmax :: CardType -> CardType -> CardType
>= :: CardType -> CardType -> Bool
$c>= :: CardType -> CardType -> Bool
> :: CardType -> CardType -> Bool
$c> :: CardType -> CardType -> Bool
<= :: CardType -> CardType -> Bool
$c<= :: CardType -> CardType -> Bool
< :: CardType -> CardType -> Bool
$c< :: CardType -> CardType -> Bool
compare :: CardType -> CardType -> Ordering
$ccompare :: CardType -> CardType -> Ordering
$cp1Ord :: Eq CardType
Ord, Typeable, Typeable CardType
Constr
DataType
Typeable CardType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CardType -> c CardType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CardType)
-> (CardType -> Constr)
-> (CardType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CardType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CardType))
-> ((forall b. Data b => b -> b) -> CardType -> CardType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CardType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CardType -> r)
-> (forall u. (forall d. Data d => d -> u) -> CardType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CardType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CardType -> m CardType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CardType -> m CardType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CardType -> m CardType)
-> Data CardType
CardType -> Constr
CardType -> DataType
(forall b. Data b => b -> b) -> CardType -> CardType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CardType -> c CardType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CardType
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) -> CardType -> u
forall u. (forall d. Data d => d -> u) -> CardType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CardType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CardType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CardType -> m CardType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CardType -> m CardType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CardType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CardType -> c CardType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CardType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CardType)
$cCExact :: Constr
$cCMax :: Constr
$cCMin :: Constr
$tCardType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CardType -> m CardType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CardType -> m CardType
gmapMp :: (forall d. Data d => d -> m d) -> CardType -> m CardType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CardType -> m CardType
gmapM :: (forall d. Data d => d -> m d) -> CardType -> m CardType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CardType -> m CardType
gmapQi :: Int -> (forall d. Data d => d -> u) -> CardType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CardType -> u
gmapQ :: (forall d. Data d => d -> u) -> CardType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CardType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CardType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CardType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CardType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CardType -> r
gmapT :: (forall b. Data b => b -> b) -> CardType -> CardType
$cgmapT :: (forall b. Data b => b -> b) -> CardType -> CardType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CardType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CardType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CardType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CardType)
dataTypeOf :: CardType -> DataType
$cdataTypeOf :: CardType -> DataType
toConstr :: CardType -> Constr
$ctoConstr :: CardType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CardType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CardType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CardType -> c CardType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CardType -> c CardType
$cp1Data :: Typeable CardType
Data)

minCardinalityS, maxCardinalityS, cardinalityS :: String
cardinalityS :: String
cardinalityS = "cardinality"
minCardinalityS :: String
minCardinalityS = "minC" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. [a] -> [a]
tail String
cardinalityS
maxCardinalityS :: String
maxCardinalityS = "maxC" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. [a] -> [a]
tail String
cardinalityS

instance Show CardType where
    show :: CardType -> String
show ct :: CardType
ct = case CardType
ct of
        CMin -> String
minCardinalityS
        CMax -> String
maxCardinalityS
        CExact -> String
cardinalityS

-- | for a detailed specification of all the components look into the sources
data DL_FORMULA =
    Cardinality CardType
                PRED_SYMB -- refers to a declared (binary) predicate
                (TERM DL_FORMULA)
                {- this term is restricted to constructors
                denoting a (typed) variable -}
                (TERM DL_FORMULA)
               {- the second term is restricted to an Application denoting
               a literal of type nonNegativeInteger (Nat) -}
               (Maybe (FORMULA DL_FORMULA))
               -- an optional qualification for the number restriction
                Range
               -- position of keyword, brackets, parens and comma
             deriving (Int -> DL_FORMULA -> String -> String
[DL_FORMULA] -> String -> String
DL_FORMULA -> String
(Int -> DL_FORMULA -> String -> String)
-> (DL_FORMULA -> String)
-> ([DL_FORMULA] -> String -> String)
-> Show DL_FORMULA
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [DL_FORMULA] -> String -> String
$cshowList :: [DL_FORMULA] -> String -> String
show :: DL_FORMULA -> String
$cshow :: DL_FORMULA -> String
showsPrec :: Int -> DL_FORMULA -> String -> String
$cshowsPrec :: Int -> DL_FORMULA -> String -> String
Show, DL_FORMULA -> DL_FORMULA -> Bool
(DL_FORMULA -> DL_FORMULA -> Bool)
-> (DL_FORMULA -> DL_FORMULA -> Bool) -> Eq DL_FORMULA
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DL_FORMULA -> DL_FORMULA -> Bool
$c/= :: DL_FORMULA -> DL_FORMULA -> Bool
== :: DL_FORMULA -> DL_FORMULA -> Bool
$c== :: DL_FORMULA -> DL_FORMULA -> Bool
Eq, Eq DL_FORMULA
Eq DL_FORMULA =>
(DL_FORMULA -> DL_FORMULA -> Ordering)
-> (DL_FORMULA -> DL_FORMULA -> Bool)
-> (DL_FORMULA -> DL_FORMULA -> Bool)
-> (DL_FORMULA -> DL_FORMULA -> Bool)
-> (DL_FORMULA -> DL_FORMULA -> Bool)
-> (DL_FORMULA -> DL_FORMULA -> DL_FORMULA)
-> (DL_FORMULA -> DL_FORMULA -> DL_FORMULA)
-> Ord DL_FORMULA
DL_FORMULA -> DL_FORMULA -> Bool
DL_FORMULA -> DL_FORMULA -> Ordering
DL_FORMULA -> DL_FORMULA -> DL_FORMULA
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 :: DL_FORMULA -> DL_FORMULA -> DL_FORMULA
$cmin :: DL_FORMULA -> DL_FORMULA -> DL_FORMULA
max :: DL_FORMULA -> DL_FORMULA -> DL_FORMULA
$cmax :: DL_FORMULA -> DL_FORMULA -> DL_FORMULA
>= :: DL_FORMULA -> DL_FORMULA -> Bool
$c>= :: DL_FORMULA -> DL_FORMULA -> Bool
> :: DL_FORMULA -> DL_FORMULA -> Bool
$c> :: DL_FORMULA -> DL_FORMULA -> Bool
<= :: DL_FORMULA -> DL_FORMULA -> Bool
$c<= :: DL_FORMULA -> DL_FORMULA -> Bool
< :: DL_FORMULA -> DL_FORMULA -> Bool
$c< :: DL_FORMULA -> DL_FORMULA -> Bool
compare :: DL_FORMULA -> DL_FORMULA -> Ordering
$ccompare :: DL_FORMULA -> DL_FORMULA -> Ordering
$cp1Ord :: Eq DL_FORMULA
Ord, Typeable, Typeable DL_FORMULA
Constr
DataType
Typeable DL_FORMULA =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DL_FORMULA -> c DL_FORMULA)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DL_FORMULA)
-> (DL_FORMULA -> Constr)
-> (DL_FORMULA -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DL_FORMULA))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DL_FORMULA))
-> ((forall b. Data b => b -> b) -> DL_FORMULA -> DL_FORMULA)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DL_FORMULA -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DL_FORMULA -> r)
-> (forall u. (forall d. Data d => d -> u) -> DL_FORMULA -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DL_FORMULA -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DL_FORMULA -> m DL_FORMULA)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DL_FORMULA -> m DL_FORMULA)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DL_FORMULA -> m DL_FORMULA)
-> Data DL_FORMULA
DL_FORMULA -> Constr
DL_FORMULA -> DataType
(forall b. Data b => b -> b) -> DL_FORMULA -> DL_FORMULA
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DL_FORMULA -> c DL_FORMULA
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DL_FORMULA
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) -> DL_FORMULA -> u
forall u. (forall d. Data d => d -> u) -> DL_FORMULA -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DL_FORMULA -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DL_FORMULA -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DL_FORMULA -> m DL_FORMULA
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DL_FORMULA -> m DL_FORMULA
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DL_FORMULA
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DL_FORMULA -> c DL_FORMULA
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DL_FORMULA)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DL_FORMULA)
$cCardinality :: Constr
$tDL_FORMULA :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DL_FORMULA -> m DL_FORMULA
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DL_FORMULA -> m DL_FORMULA
gmapMp :: (forall d. Data d => d -> m d) -> DL_FORMULA -> m DL_FORMULA
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DL_FORMULA -> m DL_FORMULA
gmapM :: (forall d. Data d => d -> m d) -> DL_FORMULA -> m DL_FORMULA
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DL_FORMULA -> m DL_FORMULA
gmapQi :: Int -> (forall d. Data d => d -> u) -> DL_FORMULA -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DL_FORMULA -> u
gmapQ :: (forall d. Data d => d -> u) -> DL_FORMULA -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DL_FORMULA -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DL_FORMULA -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DL_FORMULA -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DL_FORMULA -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DL_FORMULA -> r
gmapT :: (forall b. Data b => b -> b) -> DL_FORMULA -> DL_FORMULA
$cgmapT :: (forall b. Data b => b -> b) -> DL_FORMULA -> DL_FORMULA
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DL_FORMULA)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DL_FORMULA)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DL_FORMULA)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DL_FORMULA)
dataTypeOf :: DL_FORMULA -> DataType
$cdataTypeOf :: DL_FORMULA -> DataType
toConstr :: DL_FORMULA -> Constr
$ctoConstr :: DL_FORMULA -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DL_FORMULA
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DL_FORMULA
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DL_FORMULA -> c DL_FORMULA
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DL_FORMULA -> c DL_FORMULA
$cp1Data :: Typeable DL_FORMULA
Data)
               -- TODO: Erweiterung ueber maybe

caslDLCardTypes :: [CardType]
caslDLCardTypes :: [CardType]
caslDLCardTypes = [CardType
CExact, CardType
CMin, CardType
CMax]

casl_DL_reserved_words :: [String]
casl_DL_reserved_words :: [String]
casl_DL_reserved_words = (CardType -> String) -> [CardType] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map CardType -> String
forall a. Show a => a -> String
show [CardType]
caslDLCardTypes

{- parser will need 7 functions: concept1, concept2, concept3, concept4,
   classProperty, basicItem, basicSpec -}

-- Generated by DrIFT, look but don't touch!

instance GetRange CardType where
  getRange :: CardType -> Range
getRange = Range -> CardType -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: CardType -> [Pos]
rangeSpan x :: CardType
x = case CardType
x of
    CMin -> []
    CMax -> []
    CExact -> []

instance GetRange DL_FORMULA where
  getRange :: DL_FORMULA -> Range
getRange x :: DL_FORMULA
x = case DL_FORMULA
x of
    Cardinality _ _ _ _ _ p :: Range
p -> Range
p
  rangeSpan :: DL_FORMULA -> [Pos]
rangeSpan x :: DL_FORMULA
x = case DL_FORMULA
x of
    Cardinality a :: CardType
a b :: PRED_SYMB
b c :: TERM DL_FORMULA
c d :: TERM DL_FORMULA
d e :: Maybe (FORMULA DL_FORMULA)
e f :: Range
f -> [[Pos]] -> [Pos]
joinRanges [CardType -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan CardType
a, PRED_SYMB -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan PRED_SYMB
b,
                                           TERM DL_FORMULA -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM DL_FORMULA
c, TERM DL_FORMULA -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM DL_FORMULA
d, Maybe (FORMULA DL_FORMULA) -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Maybe (FORMULA DL_FORMULA)
e, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
f]