{-# LANGUAGE DeriveDataTypeable #-}

{-# LANGUAGE DeriveFunctor #-}

{-# LANGUAGE TemplateHaskell #-}

{-# LANGUAGE GADTs #-}

-- |

module Language.PureScript.Names where

import Control.Monad (liftM)

import Control.Monad.Supply.Class

import Data.List

import Data.Data

import Data.Aeson.TH

-- |

data Ident

-- |

-- An alphanumeric identifier

--

= Ident String

-- |

-- A symbolic name for an infix operator

--

| Op String

-- |

-- A generated name for an identifier

--

| GenIdent (Maybe String) Integer deriving (Show, Read, Eq, Ord, Data, Typeable)

runIdent :: Ident -> String

runIdent (Ident i) = i

runIdent (Op op) = op

runIdent (GenIdent Nothing n) = "$" ++ show n

runIdent (GenIdent (Just name) n) = "$" ++ name ++ show n

showIdent :: Ident -> String

showIdent (Op op) = '(' : op ++ ")"

showIdent i = runIdent i

freshIdent :: (MonadSupply m) => String -> m Ident

freshIdent name = liftM (GenIdent (Just name)) fresh

freshIdent' :: (MonadSupply m) => m Ident

freshIdent' = liftM (GenIdent Nothing) fresh

-- |

newtype ProperName = ProperName { runProperName :: String } deriving (Show, Read, Eq, Ord, Data, Typeable)

-- |

newtype ModuleName = ModuleName [ProperName] deriving (Show, Read, Eq, Ord, Data, Typeable)

runModuleName :: ModuleName -> String

runModuleName (ModuleName pns) = intercalate "." (runProperName `map` pns)

moduleNameFromString :: String -> ModuleName

moduleNameFromString = ModuleName . splitProperNames

where

splitProperNames s = case dropWhile (== '.') s of

"" -> []

s' -> ProperName w : splitProperNames s''

where (w, s'') = break (== '.') s'

-- |

data Qualified a = Qualified (Maybe ModuleName) a deriving (Show, Read, Eq, Ord, Data, Typeable, Functor)

showQualified :: (a -> String) -> Qualified a -> String

showQualified f (Qualified Nothing a) = f a

showQualified f (Qualified (Just name) a) = runModuleName name ++ "." ++ f a

-- |

qualify :: ModuleName -> Qualified a -> (ModuleName, a)

qualify m (Qualified Nothing a) = (m, a)

qualify _ (Qualified (Just m) a) = (m, a)

-- |

mkQualified :: a -> ModuleName -> Qualified a

mkQualified name mn = Qualified (Just mn) name

-- | Remove the module name from a qualified name

disqualify :: Qualified a -> a

disqualify (Qualified _ a) = a

-- |

isUnqualified :: Qualified a -> Bool

isUnqualified (Qualified Nothing _) = True

isUnqualified _ = False

$(deriveJSON (defaultOptions { sumEncoding = ObjectWithSingleField }) ''Qualified)

$(deriveJSON (defaultOptions { sumEncoding = ObjectWithSingleField }) ''Ident)

$(deriveJSON (defaultOptions { sumEncoding = ObjectWithSingleField }) ''ProperName)

$(deriveJSON (defaultOptions { sumEncoding = ObjectWithSingleField }) ''ModuleName)