{- |
Module: Agda.Unused.Monad.Reader

A reader monad for determining unused code.
-}
module Agda.Unused.Monad.Reader

  ( -- * Definition
    
    Environment(..)

    -- * Ask

  , askSkip
  , askLocal
  , askRoot

    -- * Local

  , localSkip

  ) where

import Control.Monad.Reader
  (MonadReader, ask, local)

-- | An environment type for use in a reader monad.
data Environment
  = Environment
  { Environment -> Bool
environmentSkip
    :: !Bool
    -- ^ Whether to skip all names.
  , Environment -> Bool
environmentLocal
    :: !Bool
    -- ^ Whether to skip public names.
  , Environment -> FilePath
environmentRoot
    :: !FilePath
    -- ^ The project root path.
  } deriving Int -> Environment -> ShowS
[Environment] -> ShowS
Environment -> FilePath
(Int -> Environment -> ShowS)
-> (Environment -> FilePath)
-> ([Environment] -> ShowS)
-> Show Environment
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Environment] -> ShowS
$cshowList :: [Environment] -> ShowS
show :: Environment -> FilePath
$cshow :: Environment -> FilePath
showsPrec :: Int -> Environment -> ShowS
$cshowsPrec :: Int -> Environment -> ShowS
Show

-- | Ask whether to skip checking names.
askSkip
  :: MonadReader Environment m
  => m Bool
askSkip :: m Bool
askSkip
  = Environment -> Bool
environmentSkip (Environment -> Bool) -> m Environment -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Environment
forall r (m :: * -> *). MonadReader r m => m r
ask

-- | Ask whether to skip checking public names.
askLocal
  :: MonadReader Environment m
  => m Bool
askLocal :: m Bool
askLocal
  = Environment -> Bool
environmentLocal (Environment -> Bool) -> m Environment -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Environment
forall r (m :: * -> *). MonadReader r m => m r
ask

-- | Ask for the project root path.
askRoot
  :: MonadReader Environment m
  => m FilePath
askRoot :: m FilePath
askRoot
  = Environment -> FilePath
environmentRoot (Environment -> FilePath) -> m Environment -> m FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Environment
forall r (m :: * -> *). MonadReader r m => m r
ask

-- | Skip checking names in a local computation.
localSkip
  :: MonadReader Environment m
  => m a
  -> m a
localSkip :: m a -> m a
localSkip
  = (Environment -> Environment) -> m a -> m a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (\e :: Environment
e -> Environment
e {environmentSkip :: Bool
environmentSkip = Bool
True})