{-# LANGUAGE DeriveFunctor #-}

module Nm ( Nm (..)
          , TyNm
          ) where

import           Control.DeepSeq (NFData (..))
import qualified Data.Text       as T
import           Prettyprinter   (Pretty (..))
import           U

type TyNm a = Nm a

data Nm a = Nm { forall a. Nm a -> Text
name   :: T.Text
               , forall a. Nm a -> U
unique :: !U
               , forall a. Nm a -> a
loc    :: a
               } deriving ((forall a b. (a -> b) -> Nm a -> Nm b)
-> (forall a b. a -> Nm b -> Nm a) -> Functor Nm
forall a b. a -> Nm b -> Nm a
forall a b. (a -> b) -> Nm a -> Nm b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Nm a -> Nm b
fmap :: forall a b. (a -> b) -> Nm a -> Nm b
$c<$ :: forall a b. a -> Nm b -> Nm a
<$ :: forall a b. a -> Nm b -> Nm a
Functor)

instance Eq (Nm a) where
    == :: Nm a -> Nm a -> Bool
(==) (Nm Text
_ U
u a
_) (Nm Text
_ U
u' a
_) = U
u U -> U -> Bool
forall a. Eq a => a -> a -> Bool
== U
u'

instance Ord (Nm a) where
    compare :: Nm a -> Nm a -> Ordering
compare (Nm Text
_ U
u a
_) (Nm Text
_ U
u' a
_) = U -> U -> Ordering
forall a. Ord a => a -> a -> Ordering
compare U
u U
u'

instance Pretty (Nm a) where
    pretty :: forall ann. Nm a -> Doc ann
pretty (Nm Text
n U
_ a
_) = Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
n
    -- pretty (Nm n (U i) _) = pretty n <> pretty i

instance Show (Nm a) where
    show :: Nm a -> String
show = Doc Any -> String
forall a. Show a => a -> String
show (Doc Any -> String) -> (Nm a -> Doc Any) -> Nm a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Nm a -> Doc Any
forall a ann. Pretty a => a -> Doc ann
forall ann. Nm a -> Doc ann
pretty

instance NFData a => NFData (Nm a) where
    rnf :: Nm a -> ()
rnf (Nm Text
_ U
u a
x) = a -> ()
forall a. NFData a => a -> ()
rnf a
x () -> () -> ()
forall a b. a -> b -> b
`seq` U
u U -> () -> ()
forall a b. a -> b -> b
`seq` ()