-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Haskell development library
--   
--   Haskell development library and tool with support of autocompletion,
--   symbol info, go to declaration, find references, hayoo search etc.
@package hsdev
@version 0.3.1.1

module Control.Apply.Util
(&) :: a -> (a -> b) -> b
chain :: [a -> a] -> a -> a

module Control.Concurrent.FiniteChan

-- | <a>Chan</a> is stoppable channel
data Chan a
newChan :: IO (Chan a)

-- | Is channel opened
openedChan :: Chan a -> IO Bool

-- | Is channel closed
closedChan :: Chan a -> IO Bool

-- | Is channel closed and all data consumed
doneChan :: Chan a -> IO Bool

-- | Write data to channel if it is open
sendChan :: Chan a -> a -> IO Bool

-- | Get data from channel
getChan :: Chan a -> IO (Maybe a)

-- | Close channel
closeChan :: Chan a -> IO ()

-- | Close channel and read all messages
stopChan :: Chan a -> IO [a]

module Control.Concurrent.Util
fork :: MonadIO m => IO () -> m ()
timeout :: Int -> IO a -> IO (Maybe a)
sync :: MonadIO m => (IO () -> m a) -> m a

module Control.Concurrent.Worker
data Worker m
Worker :: Chan (Async (), m ()) -> MVar (Async ()) -> Worker m
[workerChan] :: Worker m -> Chan (Async (), m ())
[workerTask] :: Worker m -> MVar (Async ())
data WorkerStopped
WorkerStopped :: WorkerStopped

-- | Create new worker
startWorker :: MonadIO m => (m () -> IO ()) -> (m () -> m ()) -> (m () -> m ()) -> IO (Worker m)

-- | Check whether worker alive
workerAlive :: Worker m -> IO Bool
workerDone :: Worker m -> IO Bool
sendTask :: (MonadCatch m, MonadIO m) => Worker m -> m a -> IO (Async a)

-- | Close worker channel
stopWorker :: Worker m -> IO ()

-- | Stop worker and wait for it
joinWorker :: Worker m -> IO ()

-- | Send empty task and wait until worker run it
syncTask :: (MonadCatch m, MonadIO m) => Worker m -> IO ()

-- | Run action in worker and wait for result
inWorkerWith :: (MonadIO m, MonadCatch m, MonadIO n) => (SomeException -> n a) -> Worker m -> m a -> n a

-- | Run action in worker and wait for result
inWorker :: (MonadIO m, MonadCatch m) => Worker m -> m a -> IO a
instance GHC.Show.Show Control.Concurrent.Worker.WorkerStopped
instance GHC.Exception.Exception Control.Concurrent.Worker.WorkerStopped

module Data.Deps

-- | Dependency map
newtype Deps a
Deps :: Map a [a] -> Deps a
[_depsMap] :: Deps a -> Map a [a]
depsMap :: Lens (Deps a) (Deps b) (Map a [a]) (Map b [b])
mapDeps :: Ord b => (a -> b) -> Deps a -> Deps b

-- | Make single dependency
dep :: a -> a -> Deps a

-- | Make dependency for one target, note that order of dependencies is
--   matter
deps :: a -> [a] -> Deps a

-- | Inverse dependencies, i.e. make map where keys are dependencies and
--   elements are targets depends on it
inverse :: Ord a => Deps a -> Deps a
newtype DepsError a

-- | Dependency cycle, list is cycle, where last item depends on first
CyclicDeps :: [a] -> DepsError a

-- | Flatten dependencies so that there will be no indirect dependencies
flatten :: Ord a => Deps a -> Either (DepsError a) (Deps a)
selfDepend :: Deps a -> Deps a

-- | Linearize dependencies so that all items can be processed in this
--   order, i.e. for each item all its dependencies goes before
linearize :: Ord a => Deps a -> Either (DepsError a) [a]
instance GHC.Read.Read a => GHC.Read.Read (Data.Deps.DepsError a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Deps.DepsError a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Deps.DepsError a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Deps.DepsError a)
instance GHC.Classes.Ord a => GHC.Base.Monoid (Data.Deps.Deps a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Deps.Deps a)
instance GHC.Classes.Ord a => Control.Lens.At.Ixed (Data.Deps.Deps a)
instance GHC.Classes.Ord a => Control.Lens.At.At (Data.Deps.Deps a)

module Data.Help
class Help a
brief :: Help a => a -> Text
help :: Help a => a -> [Text]
indent :: Text -> Text
indentHelp :: [Text] -> [Text]
detailed :: Help a => a -> [Text]
indented :: Help a => a -> [Text]

module Data.Lisp
data Lisp
Null :: Lisp
Bool :: Bool -> Lisp
Symbol :: String -> Lisp
String :: String -> Lisp
Number :: Scientific -> Lisp
List :: [Lisp] -> Lisp
lisp :: Int -> ReadP Lisp
encodeLisp :: ToJSON a => a -> ByteString
decodeLisp :: FromJSON a => ByteString -> Either String a
instance GHC.Classes.Eq Data.Lisp.Lisp
instance GHC.Read.Read Data.Lisp.Lisp
instance GHC.Show.Show Data.Lisp.Lisp
instance Data.Aeson.Types.ToJSON.ToJSON Data.Lisp.Lisp
instance Data.Aeson.Types.FromJSON.FromJSON Data.Lisp.Lisp

module Data.LookupTable

-- | k-v table
type LookupTable k v = MVar (Map k v)
newLookupTable :: (Ord k, MonadIO m) => m (LookupTable k v)

-- | Lookup, or insert if not exists
lookupTable :: (Ord k, MonadIO m) => k -> v -> LookupTable k v -> m v

-- | Lookup, or insert if not exists
lookupTableM :: (Ord k, MonadIO m) => k -> m v -> LookupTable k v -> m v

-- | <tt>lookupTableM</tt> with swapped args
cacheInTableM :: (Ord k, MonadIO m) => LookupTable k v -> k -> m v -> m v

-- | Just check existable
hasLookupTable :: (Ord k, MonadIO m) => k -> LookupTable k v -> m (Maybe v)

-- | Make function caching results in <tt>LookupTable</tt>
cachedInTable :: (Ord k, MonadIO m) => LookupTable k v -> (k -> m v) -> k -> m v

module Data.Maybe.JustIf

-- | Return <tt>Just</tt> if True
justIf :: a -> Bool -> Maybe a

module HsDev.Database.SQLite.Schema.TH
schemaExp :: ExpQ

module HsDev.Database.SQLite.Schema
schema :: Text
commands :: [Query]

module HsDev.Database.SQLite.Select
data Select a
Select :: [a] -> [a] -> [a] -> Select a
[selectColumns] :: Select a -> [a]
[selectTables] :: Select a -> [a]
[selectConditions] :: Select a -> [a]
select_ :: [a] -> Select a
from_ :: [a] -> Select a
where_ :: [a] -> Select a
buildQuery :: Select Text -> String
toQuery :: Select Text -> Query
qSymbolId :: Select Text
qSymbol :: Select Text
qModuleLocation :: Text -> Select Text
qModuleId :: Select Text
qBuildInfo :: Select Text

-- | Symbol from haskell-names
qNSymbol :: Text -> Text -> Select Text
qNote :: Text -> Text -> Select Text
instance Data.Traversable.Traversable HsDev.Database.SQLite.Select.Select
instance Data.Foldable.Foldable HsDev.Database.SQLite.Select.Select
instance GHC.Base.Functor HsDev.Database.SQLite.Select.Select
instance GHC.Show.Show a => GHC.Show.Show (HsDev.Database.SQLite.Select.Select a)
instance GHC.Read.Read a => GHC.Read.Read (HsDev.Database.SQLite.Select.Select a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (HsDev.Database.SQLite.Select.Select a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (HsDev.Database.SQLite.Select.Select a)
instance GHC.Base.Monoid (HsDev.Database.SQLite.Select.Select a)

module HsDev.Project.Compat
showVer :: Version -> String
componentName :: UnqualComponentName -> Text
testSuiteEnabled :: TestSuite -> Bool
flattenCondTree :: Monoid a => (c -> a -> a) -> CondTree v c a -> a
parsePackageDesc :: String -> ParseResult GenericPackageDescription

module HsDev.Server.Message.Lisp
type Msg a = (Bool, a)
isLisp :: Lens' (Msg a) Bool
msg :: Lens (Msg a) (Msg b) a b
jsonMsg :: a -> Msg a
lispMsg :: a -> Msg a

-- | Decode lisp or json
decodeMsg :: FromJSON a => ByteString -> Either (Msg String) (Msg a)

-- | Encode lisp or json
encodeMsg :: ToJSON a => Msg a -> ByteString

module HsDev.Symbols.Name

-- | Qualified name
type Name = QName ()
qualName :: String -> String -> Name
unqualName :: String -> Name
nameModule :: Name -> Maybe Text
nameIdent :: Name -> Text
fromName_ :: Name () -> Text
toName_ :: Text -> Name ()
toModuleName_ :: Text -> ModuleName ()
fromModuleName_ :: ModuleName () -> Text
fromName :: Name -> Text
toName :: Text -> Name
name_ :: Iso' (Name ()) Text
moduleName_ :: Iso' (ModuleName ()) Text

module HsDev.Tools.Ghc.Compat
pkgDatabase :: DynFlags -> Maybe [PackageConfig]
type UnitId = UnitId
type InstalledUnitId = InstalledUnitId
toInstalledUnitId :: UnitId -> InstalledUnitId
unitId :: PackageConfig -> InstalledUnitId
moduleUnitId :: Module -> UnitId
depends :: DynFlags -> PackageConfig -> [InstalledUnitId]
getPackageDetails :: DynFlags -> InstalledUnitId -> PackageConfig
patSynType :: PatSyn -> Type
cleanupHandler :: DynFlags -> m a -> m a
renderStyle :: Mode -> Int -> Doc -> String
type LogAction = DynFlags -> Severity -> SrcSpan -> MsgDoc -> IO ()
setLogAction :: LogAction -> DynFlags -> DynFlags
addLogAction :: LogAction -> DynFlags -> DynFlags
languages :: [String]
flags :: [String]
recSelParent :: RecSelParent -> String
recSelCtors :: RecSelParent -> [String]
getFixity :: Fixity -> (Int, FixityDirection)
unqualStyle :: DynFlags -> PprStyle
exposedModuleName :: (a, Maybe b) -> a
exprType :: GhcMonad m => String -> m Type

module HsDev.Tools.Ghc.MGhc
data Session s d
Session :: s -> d -> Session s d
[_sessionKey] :: Session s d -> s
[_sessionData] :: Session s d -> d
sessionKey :: Lens' (Session s d) s
sessionData :: Lens' (Session s d) d
data SessionState s d
SessionState :: Maybe (Session s d) -> Map s (HscEnv, d) -> SessionState s d
[_sessionActive] :: SessionState s d -> Maybe (Session s d)
[_sessionMap] :: SessionState s d -> Map s (HscEnv, d)
sessionActive :: Lens' (SessionState s d) (Maybe (Session s d))
sessionMap :: Lens' (SessionState s d) (Map s (HscEnv, d))

-- | Multi-session ghc monad
newtype MGhcT s d m a
MGhcT :: GhcT (ReaderT (Maybe FilePath) (StateT (SessionState s d) m)) a -> MGhcT s d m a
[unMGhcT] :: MGhcT s d m a -> GhcT (ReaderT (Maybe FilePath) (StateT (SessionState s d) m)) a

-- | Run multi-session ghc
runMGhcT :: (MonadIO m, ExceptionMonad m, Ord s, Monoid d) => Maybe FilePath -> MGhcT s d m a -> m a

-- | Lift <a>Ghc</a> monad onto <tt>MGhc</tt>
liftGhc :: MonadIO m => Ghc a -> MGhcT s d m a

-- | Get current session
currentSession :: MonadIO m => MGhcT s d m (Maybe (Session s d))

-- | Get current session data
getSessionData :: MonadIO m => MGhcT s d m (Maybe d)

-- | Set current session data
setSessionData :: MonadIO m => d -> MGhcT s d m ()

-- | Does session exist
hasSession :: (MonadIO m, Ord s) => s -> MGhcT s d m Bool

-- | Find session
findSession :: (MonadIO m, Ord s) => s -> MGhcT s d m (Maybe (Session s d))

-- | Find session by
findSessionBy :: MonadIO m => (s -> Bool) -> MGhcT s d m [Session s d]

-- | Save current session
saveSession :: (MonadIO m, ExceptionMonad m, Ord s) => MGhcT s d m (Maybe (Session s d))

-- | Initialize new session
initSession :: (MonadIO m, ExceptionMonad m, Ord s) => MGhcT s d m ()

-- | Create new named session, deleting existing session
newSession :: (MonadIO m, ExceptionMonad m, Ord s, Monoid d) => s -> MGhcT s d m ()

-- | Switch to session, creating if not exist, returns True if session was
--   created
switchSession :: (MonadIO m, ExceptionMonad m, Ord s, Monoid d) => s -> MGhcT s d m Bool

-- | Switch to session, creating if not exist and initializing with passed
--   function
switchSession_ :: (MonadIO m, ExceptionMonad m, Ord s, Monoid d) => s -> Maybe (MGhcT s d m ()) -> MGhcT s d m ()

-- | Delete existing session
deleteSession :: (MonadIO m, ExceptionMonad m, Ord s, Monoid d) => s -> MGhcT s d m ()

-- | Save and restore session
restoreSession :: (MonadIO m, MonadMask m, ExceptionMonad m, Ord s, Monoid d) => MGhcT s d m a -> MGhcT s d m a

-- | Run action using session, restoring session back
usingSession :: (MonadIO m, MonadMask m, ExceptionMonad m, Ord s, Monoid d) => s -> MGhcT s d m a -> MGhcT s d m a

-- | Run with temporary session, like <tt>usingSession</tt>, but deletes
--   self session
tempSession :: (MonadIO m, MonadMask m, ExceptionMonad m, Ord s, Monoid d) => s -> MGhcT s d m a -> MGhcT s d m a
instance System.Log.Simple.Monad.MonadLog m => System.Log.Simple.Monad.MonadLog (HsDev.Tools.Ghc.MGhc.MGhcT s d m)
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (HsDev.Tools.Ghc.MGhc.MGhcT s d m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (HsDev.Tools.Ghc.MGhc.MGhcT s d m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (HsDev.Tools.Ghc.MGhc.MGhcT s d m)
instance GHC.Base.Monad m => Control.Monad.Reader.Class.MonadReader (GHC.Base.Maybe GHC.IO.FilePath) (HsDev.Tools.Ghc.MGhc.MGhcT s d m)
instance GHC.Base.Monad m => Control.Monad.State.Class.MonadState (HsDev.Tools.Ghc.MGhc.SessionState s d) (HsDev.Tools.Ghc.MGhc.MGhcT s d m)
instance Exception.ExceptionMonad m => GhcMonad.GhcMonad (HsDev.Tools.Ghc.MGhc.MGhcT s d m)
instance Control.Monad.IO.Class.MonadIO m => DynFlags.HasDynFlags (HsDev.Tools.Ghc.MGhc.MGhcT s d m)
instance Exception.ExceptionMonad m => Exception.ExceptionMonad (HsDev.Tools.Ghc.MGhc.MGhcT s d m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (HsDev.Tools.Ghc.MGhc.MGhcT s d m)
instance GHC.Base.Monad m => GHC.Base.Monad (HsDev.Tools.Ghc.MGhc.MGhcT s d m)
instance GHC.Base.Monad m => GHC.Base.Applicative (HsDev.Tools.Ghc.MGhc.MGhcT s d m)
instance GHC.Base.Functor m => GHC.Base.Functor (HsDev.Tools.Ghc.MGhc.MGhcT s d m)
instance (GHC.Show.Show d, GHC.Show.Show s) => GHC.Show.Show (HsDev.Tools.Ghc.MGhc.Session s d)
instance (GHC.Read.Read d, GHC.Read.Read s) => GHC.Read.Read (HsDev.Tools.Ghc.MGhc.Session s d)
instance (GHC.Classes.Ord d, GHC.Classes.Ord s) => GHC.Classes.Ord (HsDev.Tools.Ghc.MGhc.Session s d)
instance (GHC.Classes.Eq d, GHC.Classes.Eq s) => GHC.Classes.Eq (HsDev.Tools.Ghc.MGhc.Session s d)
instance Data.Default.Class.Default (HsDev.Tools.Ghc.MGhc.SessionState s d)
instance Exception.ExceptionMonad m => Exception.ExceptionMonad (Control.Monad.Trans.State.Lazy.StateT s m)
instance Exception.ExceptionMonad m => Exception.ExceptionMonad (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Trans.Class.MonadTrans GhcMonad.GhcT
instance Control.Monad.Morph.MFunctor GhcMonad.GhcT
instance Control.Monad.State.Class.MonadState st m => Control.Monad.State.Class.MonadState st (GhcMonad.GhcT m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (GhcMonad.GhcT m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (GhcMonad.GhcT m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (GhcMonad.GhcT m)
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (GhcMonad.GhcT m)

module HsDev.Tools.Ghc.Prelude

-- | Reduce list to one element
reduce :: ([a] -> a) -> [a] -> [a]

-- | Trim string
trim :: String -> String

-- | Match regex
rx :: String -> String -> Maybe String

-- | Replace regex
srx :: String -> String -> String -> String

-- | Split by regex
splitRx :: String -> String -> [String]
lowerCase :: String -> String
upperCase :: String -> String

-- | Convert to title case
titleCase :: String -> String

-- | Convert to camel case
camelCase :: String -> String

-- | Convert to underscore case
underscoreCase :: String -> String

module HsDev.Version
cabalVersion :: ExpQ

module HsDev.Util

-- | Run action with current directory set
withCurrentDirectory :: (MonadIO m, MonadMask m) => FilePath -> m a -> m a

-- | Get directory contents safely: no fail, ignoring symbolic links, also
--   prepends paths with dir name
directoryContents :: FilePath -> IO [FilePath]

-- | Collect all file names in directory recursively
traverseDirectory :: FilePath -> IO [FilePath]

-- | Search something up
searchPath :: (MonadIO m, MonadPlus m) => FilePath -> (FilePath -> m a) -> m a

-- | Is haskell source?
haskellSource :: FilePath -> Bool

-- | Is cabal file?
cabalFile :: FilePath -> Bool

-- | Add N tabs to line
tab :: Int -> String -> String

-- | Trim string
trim :: String -> String

-- | Split list
split :: (a -> Bool) -> [a] -> [[a]]

-- | nub is quadratic, <a>https://github.com/nh2/haskell-ordnub/#ordnub</a>
ordNub :: Ord a => [a] -> [a]
uniqueBy :: Ord b => (a -> b) -> [a] -> [a]
mapBy :: Ord b => (a -> b) -> [a] -> Map b a

-- | Workaround, sometimes we get HM.lookup "foo" v == Nothing, but lookup
--   "foo" (HM.toList v) == Just smth
(.::) :: FromJSON a => HashMap Text Value -> Text -> Parser a

-- | Returns <tt>Nothing</tt> when key doesn't exist or value is
--   <tt>Null</tt>
(.::?) :: FromJSON a => HashMap Text Value -> Text -> Parser (Maybe a)

-- | Same as <tt>.::?</tt> for list, returns empty list for non-existant
--   key or <tt>Null</tt> value
(.::?!) :: FromJSON a => HashMap Text Value -> Text -> Parser [a]

-- | Union two JSON objects
objectUnion :: Value -> Value -> Value

-- | No Nulls in JSON object
noNulls :: [Pair] -> [Pair]

-- | Try convert json to value
fromJSON' :: FromJSON a => Value -> Maybe a

-- | Lift IO exception to ExceptT
liftException :: MonadCatch m => m a -> ExceptT String m a

-- | Same as <tt>liftException</tt>
liftE :: MonadCatch m => m a -> ExceptT String m a

-- | Run actions ignoring errors
tries :: MonadPlus m => [m a] -> m [a]
triesMap :: MonadPlus m => (a -> m b) -> [a] -> m [b]

-- | Lift IO exception to MonadError
liftExceptionM :: (MonadCatch m, MonadError String m) => m a -> m a

-- | Lift IO exceptions to ExceptT
liftIOErrors :: MonadCatch m => ExceptT String m a -> ExceptT String m a

-- | Log exceptions and ignore
logAll :: (MonadLog m, MonadCatch m) => m () -> m ()
fromUtf8 :: ByteString -> String
toUtf8 :: String -> ByteString

-- | Read file in UTF8
readFileUtf8 :: FilePath -> IO Text
writeFileUtf8 :: FilePath -> Text -> IO ()
hGetLineBS :: Handle -> IO ByteString
logIO :: MonadCatch m => String -> (String -> m ()) -> m () -> m ()
ignoreIO :: MonadCatch m => m () -> m ()
logAsync :: (MonadIO m, MonadCatch m) => (String -> m ()) -> m () -> m ()
class FromCmd a
cmdP :: FromCmd a => Parser a
cmdJson :: String -> [Pair] -> Value
guardCmd :: String -> Object -> Parser ()

-- | Add help command to parser
withHelp :: Parser a -> Parser a

-- | Subcommand
cmd :: String -> String -> Parser a -> Mod CommandFields a

-- | Parse arguments or return help
parseArgs :: String -> ParserInfo a -> [String] -> Either String a

-- | Get hsdev version as list of integers
version :: Maybe [Int]

-- | Parse Distribution.Text
parseDT :: (Monad m, Text a) => String -> String -> m a

-- | Measure time of action
timer :: MonadLog m => Text -> m a -> m a

-- | Monads in which <a>IO</a> computations may be embedded. Any monad
--   built by applying a sequence of monad transformers to the <a>IO</a>
--   monad will be an instance of this class.
--   
--   Instances should satisfy the following laws, which state that
--   <a>liftIO</a> is a transformer of monads:
--   
--   <ul>
--   <li><pre><a>liftIO</a> . <a>return</a> = <a>return</a></pre></li>
--   <li><pre><a>liftIO</a> (m &gt;&gt;= f) = <a>liftIO</a> m &gt;&gt;=
--   (<a>liftIO</a> . f)</pre></li>
--   </ul>
class Monad m => MonadIO (m :: * -> *)

-- | Lift a computation from the <a>IO</a> monad.
liftIO :: MonadIO m => IO a -> m a

module HsDev.Tools.ClearImports

-- | Dump minimal imports
dumpMinimalImports :: [String] -> FilePath -> ExceptT String IO String

-- | Read imports from file
waitImports :: FilePath -> IO [String]

-- | Clean temporary files
cleanTmpImports :: FilePath -> IO ()

-- | Dump and read imports
findMinimalImports :: [String] -> FilePath -> ExceptT String IO [String]

-- | Groups several lines related to one import by indents
groupImports :: [String] -> [[String]]

-- | Split import to import and import-list
splitImport :: [String] -> (String, String)

-- | Returns minimal imports for file specified
clearImports :: [String] -> FilePath -> ExceptT String IO [(String, String)]

module System.Directory.Paths

-- | Takes much less memory than <a>FilePath</a>
type Path = Text
path :: Lens' Path FilePath
fromFilePath :: FilePath -> Path
joinPaths :: [Path] -> Path
splitPaths :: Path -> [Path]
normPath :: Path -> Path
subPath :: Path -> Path -> Path

-- | Make path relative
relPathTo :: Path -> Path -> Path
dirExists :: Path -> IO Bool
fileExists :: Path -> IO Bool
takeDir :: Path -> Path

-- | Is one path parent of another
isParent :: Path -> Path -> Bool

-- | Something with paths inside
class Paths a
paths :: Paths a => Traversal' a FilePath

-- | Canonicalize all paths
canonicalize :: Paths a => a -> IO a

-- | Absolutise paths
absolutise :: Paths a => Path -> a -> a

-- | Relativise paths
relativise :: Paths a => Path -> a -> a
instance System.Directory.Paths.Paths GHC.IO.FilePath
instance System.Directory.Paths.Paths System.Directory.Paths.Path

module HsDev.Display
class Display a
display :: Display a => a -> String
displayType :: Display a => a -> String
instance HsDev.Display.Display GHC.IO.FilePath
instance HsDev.Display.Display System.Directory.Paths.Path

module HsDev.PackageDb.Types
data PackageDb
GlobalDb :: PackageDb
UserDb :: PackageDb
PackageDb :: Path -> PackageDb
[_packageDb] :: PackageDb -> Path
packageDb :: Traversal' PackageDb Path

-- | Stack of PackageDb in reverse order
newtype PackageDbStack
PackageDbStack :: [PackageDb] -> PackageDbStack
[_packageDbStack] :: PackageDbStack -> [PackageDb]
packageDbStack :: Iso' PackageDbStack [PackageDb]

-- | Make <tt>PackageDbStack</tt> from list of <tt>PackageDb</tt>
mkPackageDbStack :: [PackageDb] -> PackageDbStack

-- | Global db stack
globalDb :: PackageDbStack

-- | User db stack
userDb :: PackageDbStack

-- | Make package-db stack from paths
fromPackageDbs :: [Path] -> PackageDbStack

-- | Get top package-db for package-db stack
topPackageDb :: PackageDbStack -> PackageDb

-- | Get list of package-db in stack, adds additional global-db at bottom
packageDbs :: PackageDbStack -> [PackageDb]

-- | Get stacks for each package-db in stack
packageDbStacks :: PackageDbStack -> [PackageDbStack]

-- | Is one package-db stack substack of another
isSubStack :: PackageDbStack -> PackageDbStack -> Bool

-- | Get ghc options for package-db
packageDbOpt :: PackageDb -> String

-- | Get ghc options for package-db stack
packageDbStackOpts :: PackageDbStack -> [String]
instance Control.DeepSeq.NFData HsDev.PackageDb.Types.PackageDbStack
instance HsDev.Display.Display HsDev.PackageDb.Types.PackageDbStack
instance Text.Format.Formattable HsDev.PackageDb.Types.PackageDbStack
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.PackageDb.Types.PackageDbStack
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.PackageDb.Types.PackageDbStack
instance System.Directory.Paths.Paths HsDev.PackageDb.Types.PackageDbStack
instance GHC.Show.Show HsDev.PackageDb.Types.PackageDbStack
instance GHC.Classes.Ord HsDev.PackageDb.Types.PackageDbStack
instance GHC.Classes.Eq HsDev.PackageDb.Types.PackageDbStack
instance Control.DeepSeq.NFData HsDev.PackageDb.Types.PackageDb
instance GHC.Show.Show HsDev.PackageDb.Types.PackageDb
instance HsDev.Display.Display HsDev.PackageDb.Types.PackageDb
instance Text.Format.Formattable HsDev.PackageDb.Types.PackageDb
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.PackageDb.Types.PackageDb
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.PackageDb.Types.PackageDb
instance System.Directory.Paths.Paths HsDev.PackageDb.Types.PackageDb
instance GHC.Classes.Ord HsDev.PackageDb.Types.PackageDb
instance GHC.Classes.Eq HsDev.PackageDb.Types.PackageDb

module HsDev.Project.Types

-- | Cabal project
data Project
Project :: Text -> Path -> Path -> Maybe ProjectDescription -> Maybe PackageDbStack -> Project
[_projectName] :: Project -> Text
[_projectPath] :: Project -> Path
[_projectCabal] :: Project -> Path
[_projectDescription] :: Project -> Maybe ProjectDescription
[_projectPackageDbStack] :: Project -> Maybe PackageDbStack
projectName :: Lens' Project Text
projectPath :: Lens' Project Path
projectCabal :: Lens' Project Path
projectDescription :: Lens' Project (Maybe ProjectDescription)
projectPackageDbStack :: Lens' Project (Maybe PackageDbStack)

-- | Make project by .cabal file
project :: FilePath -> Project
data ProjectDescription
ProjectDescription :: Text -> Maybe Library -> [Executable] -> [Test] -> ProjectDescription
[_projectVersion] :: ProjectDescription -> Text
[_projectLibrary] :: ProjectDescription -> Maybe Library
[_projectExecutables] :: ProjectDescription -> [Executable]
[_projectTests] :: ProjectDescription -> [Test]
projectVersion :: Lens' ProjectDescription Text
projectLibrary :: Lens' ProjectDescription (Maybe Library)
projectExecutables :: Lens' ProjectDescription [Executable]
projectTests :: Lens' ProjectDescription [Test]

-- | Build target infos
infos :: Traversal' ProjectDescription Info

-- | Build target infos, more detailed
targetInfos :: ProjectDescription -> [TargetInfo]
class Target a
targetName :: Target a => Traversal' a Text
buildInfo :: Target a => Lens' a Info
targetMain :: Target a => a -> Maybe Path
targetModules :: Target a => a -> [[Text]]
data TargetInfo
TargetInfo :: Maybe Text -> Info -> Maybe Path -> [[Text]] -> TargetInfo
[_targetInfoName] :: TargetInfo -> Maybe Text
[_targetBuildInfo] :: TargetInfo -> Info
[_targetInfoMain] :: TargetInfo -> Maybe Path
[_targetInfoModules] :: TargetInfo -> [[Text]]
targetInfoName :: Lens' TargetInfo (Maybe Text)
targetBuildInfo :: Lens' TargetInfo Info
targetInfoMain :: Lens' TargetInfo (Maybe Path)
targetInfoModules :: Lens' TargetInfo [[Text]]
targetInfo :: Target a => a -> TargetInfo

-- | Library in project
data Library
Library :: [[Text]] -> Info -> Library
[_libraryModules] :: Library -> [[Text]]
[_libraryBuildInfo] :: Library -> Info
libraryModules :: Lens' Library [[Text]]
libraryBuildInfo :: Lens' Library Info

-- | Executable
data Executable
Executable :: Text -> Path -> Info -> Executable
[_executableName] :: Executable -> Text
[_executablePath] :: Executable -> Path
[_executableBuildInfo] :: Executable -> Info
executableName :: Lens' Executable Text
executablePath :: Lens' Executable Path
executableBuildInfo :: Lens' Executable Info

-- | Test
data Test
Test :: Text -> Bool -> Maybe Path -> Info -> Test
[_testName] :: Test -> Text
[_testEnabled] :: Test -> Bool
[_testMain] :: Test -> Maybe Path
[_testBuildInfo] :: Test -> Info
testName :: Lens' Test Text
testEnabled :: Lens' Test Bool
testBuildInfo :: Lens' Test Info
testMain :: Lens' Test (Maybe Path)

-- | Build info
data Info
Info :: [Text] -> Maybe Language -> [Extension] -> [Text] -> [Path] -> [[Text]] -> Info
[_infoDepends] :: Info -> [Text]
[_infoLanguage] :: Info -> Maybe Language
[_infoExtensions] :: Info -> [Extension]
[_infoGHCOptions] :: Info -> [Text]
[_infoSourceDirs] :: Info -> [Path]
[_infoOtherModules] :: Info -> [[Text]]
infoDepends :: Lens' Info [Text]
infoLanguage :: Lens' Info (Maybe Language)
infoExtensions :: Lens' Info [Extension]
infoGHCOptions :: Lens' Info [Text]
infoSourceDirs :: Lens' Info [Path]
infoOtherModules :: Lens' Info [[Text]]

-- | Entity with project extensions
data Extensions a
Extensions :: [Extension] -> [Text] -> a -> Extensions a
[_extensions] :: Extensions a -> [Extension]
[_ghcOptions] :: Extensions a -> [Text]
[_entity] :: Extensions a -> a
extensions :: forall a_a1nyJ. Lens' (Extensions a_a1nyJ) [Extension]
ghcOptions :: forall a_a1nyJ. Lens' (Extensions a_a1nyJ) [Text]
entity :: forall a_a1nyJ a_a1oXv. Lens (Extensions a_a1nyJ) (Extensions a_a1oXv) a_a1nyJ a_a1oXv
instance HsDev.Project.Types.Target HsDev.Project.Types.Library
instance HsDev.Project.Types.Target HsDev.Project.Types.Executable
instance HsDev.Project.Types.Target HsDev.Project.Types.Test
instance HsDev.Project.Types.Target HsDev.Project.Types.TargetInfo
instance GHC.Show.Show a => GHC.Show.Show (HsDev.Project.Types.Extensions a)
instance GHC.Read.Read a => GHC.Read.Read (HsDev.Project.Types.Extensions a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (HsDev.Project.Types.Extensions a)
instance GHC.Show.Show HsDev.Project.Types.TargetInfo
instance GHC.Classes.Ord HsDev.Project.Types.TargetInfo
instance GHC.Classes.Eq HsDev.Project.Types.TargetInfo
instance GHC.Read.Read HsDev.Project.Types.ProjectDescription
instance GHC.Classes.Eq HsDev.Project.Types.ProjectDescription
instance GHC.Read.Read HsDev.Project.Types.Library
instance GHC.Classes.Eq HsDev.Project.Types.Library
instance GHC.Read.Read HsDev.Project.Types.Executable
instance GHC.Classes.Eq HsDev.Project.Types.Executable
instance GHC.Read.Read HsDev.Project.Types.Test
instance GHC.Classes.Eq HsDev.Project.Types.Test
instance GHC.Read.Read HsDev.Project.Types.Info
instance GHC.Classes.Eq HsDev.Project.Types.Info
instance GHC.Classes.Ord a => GHC.Classes.Ord (HsDev.Project.Types.Extensions a)
instance GHC.Base.Functor HsDev.Project.Types.Extensions
instance GHC.Base.Applicative HsDev.Project.Types.Extensions
instance Data.Foldable.Foldable HsDev.Project.Types.Extensions
instance Data.Traversable.Traversable HsDev.Project.Types.Extensions
instance System.Directory.Paths.Paths HsDev.Project.Types.TargetInfo
instance Control.DeepSeq.NFData HsDev.Project.Types.Project
instance GHC.Classes.Eq HsDev.Project.Types.Project
instance GHC.Classes.Ord HsDev.Project.Types.Project
instance GHC.Show.Show HsDev.Project.Types.Project
instance HsDev.Display.Display HsDev.Project.Types.Project
instance Text.Format.Formattable HsDev.Project.Types.Project
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Project.Types.Project
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Project.Types.Project
instance System.Directory.Paths.Paths HsDev.Project.Types.Project
instance GHC.Show.Show HsDev.Project.Types.ProjectDescription
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Project.Types.ProjectDescription
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Project.Types.ProjectDescription
instance System.Directory.Paths.Paths HsDev.Project.Types.ProjectDescription
instance GHC.Show.Show HsDev.Project.Types.Library
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Project.Types.Library
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Project.Types.Library
instance System.Directory.Paths.Paths HsDev.Project.Types.Library
instance GHC.Show.Show HsDev.Project.Types.Executable
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Project.Types.Executable
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Project.Types.Executable
instance System.Directory.Paths.Paths HsDev.Project.Types.Executable
instance GHC.Show.Show HsDev.Project.Types.Test
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Project.Types.Test
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Project.Types.Test
instance System.Directory.Paths.Paths HsDev.Project.Types.Test
instance GHC.Base.Monoid HsDev.Project.Types.Info
instance GHC.Classes.Ord HsDev.Project.Types.Info
instance GHC.Show.Show HsDev.Project.Types.Info
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Project.Types.Info
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Project.Types.Info
instance System.Directory.Paths.Paths HsDev.Project.Types.Info
instance Data.Aeson.Types.ToJSON.ToJSON Language.Haskell.Extension.Language
instance Data.Aeson.Types.FromJSON.FromJSON Language.Haskell.Extension.Language
instance Data.Aeson.Types.ToJSON.ToJSON Language.Haskell.Extension.Extension
instance Data.Aeson.Types.FromJSON.FromJSON Language.Haskell.Extension.Extension

module HsDev.Symbols.Location

-- | Just package name and version without its location
data ModulePackage
ModulePackage :: Text -> Text -> ModulePackage
[_packageName] :: ModulePackage -> Text
[_packageVersion] :: ModulePackage -> Text
mkPackage :: Text -> ModulePackage
data PackageConfig
PackageConfig :: ModulePackage -> [Text] -> Bool -> PackageConfig
[_package] :: PackageConfig -> ModulePackage
[_packageModules] :: PackageConfig -> [Text]
[_packageExposed] :: PackageConfig -> Bool

-- | Location of module
data ModuleLocation
FileModule :: Path -> Maybe Project -> ModuleLocation
[_moduleFile] :: ModuleLocation -> Path
[_moduleProject] :: ModuleLocation -> Maybe Project
InstalledModule :: [Path] -> ModulePackage -> Text -> ModuleLocation
[_moduleInstallDirs] :: ModuleLocation -> [Path]
[_modulePackage] :: ModuleLocation -> ModulePackage
[_installedModuleName] :: ModuleLocation -> Text
OtherLocation :: Text -> ModuleLocation
[_otherLocationName] :: ModuleLocation -> Text
NoLocation :: ModuleLocation
locationId :: ModuleLocation -> Text
noLocation :: ModuleLocation
data ModuleId
ModuleId :: Text -> ModuleLocation -> ModuleId
[_moduleName] :: ModuleId -> Text
[_moduleLocation] :: ModuleId -> ModuleLocation
moduleName :: Lens' ModuleId Text
moduleLocation :: Lens' ModuleId ModuleLocation

-- | Symbol
data SymbolId
SymbolId :: Text -> ModuleId -> SymbolId
[_symbolName] :: SymbolId -> Text
[_symbolModule] :: SymbolId -> ModuleId
symbolName :: Lens' SymbolId Text
symbolModule :: Lens' SymbolId ModuleId
data Position
Position :: Int -> Int -> Position
[_positionLine] :: Position -> Int
[_positionColumn] :: Position -> Int
data Region
Region :: Position -> Position -> Region
[_regionFrom] :: Region -> Position
[_regionTo] :: Region -> Position
region :: Position -> Position -> Region
regionAt :: Position -> Region
regionLines :: Region -> Int

-- | Get string at region
regionStr :: Region -> Text -> Text

-- | Location of symbol
data Location
Location :: ModuleLocation -> Maybe Position -> Location
[_locationModule] :: Location -> ModuleLocation
[_locationPosition] :: Location -> Maybe Position
packageName :: Lens' ModulePackage Text
packageVersion :: Lens' ModulePackage Text
package :: Lens' PackageConfig ModulePackage
packageModules :: Lens' PackageConfig [Text]
packageExposed :: Lens' PackageConfig Bool
moduleFile :: Traversal' ModuleLocation Path
moduleProject :: Traversal' ModuleLocation (Maybe Project)
moduleInstallDirs :: Traversal' ModuleLocation [Path]
modulePackage :: Traversal' ModuleLocation ModulePackage
installedModuleName :: Traversal' ModuleLocation Text
otherLocationName :: Traversal' ModuleLocation Text
positionLine :: Lens' Position Int
positionColumn :: Lens' Position Int
regionFrom :: Lens' Region Position
regionTo :: Lens' Region Position
locationModule :: Lens' Location ModuleLocation
locationPosition :: Lens' Location (Maybe Position)

-- | Get source module root directory, i.e. for "...srcFooBar.hs" with
--   module <a>Bar</a> will return "...src"
sourceModuleRoot :: Text -> Path -> Path

-- | Path to module source &gt;importPath <a>Quux.Blah</a> = "Quux/Blah.hs"
importPath :: Text -> Path

-- | Root of sources, package dir or root directory of standalone modules
sourceRoot :: ModuleId -> Maybe Path
sourceRoot_ :: ModuleId -> Path

-- | Recalc positions to interpret '\t' as one symbol instead of N
class RecalcTabs a

-- | Interpret '\t' as one symbol instead of N
recalcTabs :: RecalcTabs a => Text -> Int -> a -> a

-- | Inverse of <a>recalcTabs</a>: interpret '\t' as N symbols instead of 1
calcTabs :: RecalcTabs a => Text -> Int -> a -> a
instance HsDev.Symbols.Location.RecalcTabs HsDev.Symbols.Location.Position
instance HsDev.Symbols.Location.RecalcTabs HsDev.Symbols.Location.Region
instance Control.DeepSeq.NFData HsDev.Symbols.Location.Location
instance GHC.Show.Show HsDev.Symbols.Location.Location
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Symbols.Location.Location
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Symbols.Location.Location
instance GHC.Classes.Ord HsDev.Symbols.Location.Location
instance GHC.Classes.Eq HsDev.Symbols.Location.Location
instance Control.DeepSeq.NFData HsDev.Symbols.Location.Region
instance GHC.Show.Show HsDev.Symbols.Location.Region
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Symbols.Location.Region
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Symbols.Location.Region
instance GHC.Read.Read HsDev.Symbols.Location.Region
instance GHC.Classes.Ord HsDev.Symbols.Location.Region
instance GHC.Classes.Eq HsDev.Symbols.Location.Region
instance Control.DeepSeq.NFData HsDev.Symbols.Location.Position
instance GHC.Show.Show HsDev.Symbols.Location.Position
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Symbols.Location.Position
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Symbols.Location.Position
instance GHC.Read.Read HsDev.Symbols.Location.Position
instance GHC.Classes.Ord HsDev.Symbols.Location.Position
instance GHC.Classes.Eq HsDev.Symbols.Location.Position
instance Control.DeepSeq.NFData HsDev.Symbols.Location.SymbolId
instance GHC.Show.Show HsDev.Symbols.Location.SymbolId
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Symbols.Location.SymbolId
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Symbols.Location.SymbolId
instance GHC.Classes.Ord HsDev.Symbols.Location.SymbolId
instance GHC.Classes.Eq HsDev.Symbols.Location.SymbolId
instance Control.DeepSeq.NFData HsDev.Symbols.Location.ModuleId
instance GHC.Show.Show HsDev.Symbols.Location.ModuleId
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Symbols.Location.ModuleId
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Symbols.Location.ModuleId
instance GHC.Classes.Ord HsDev.Symbols.Location.ModuleId
instance GHC.Classes.Eq HsDev.Symbols.Location.ModuleId
instance Control.DeepSeq.NFData HsDev.Symbols.Location.ModuleLocation
instance GHC.Show.Show HsDev.Symbols.Location.ModuleLocation
instance HsDev.Display.Display HsDev.Symbols.Location.ModuleLocation
instance Text.Format.Formattable HsDev.Symbols.Location.ModuleLocation
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Symbols.Location.ModuleLocation
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Symbols.Location.ModuleLocation
instance System.Directory.Paths.Paths HsDev.Symbols.Location.ModuleLocation
instance GHC.Classes.Eq HsDev.Symbols.Location.ModuleLocation
instance GHC.Classes.Ord HsDev.Symbols.Location.ModuleLocation
instance Control.DeepSeq.NFData HsDev.Symbols.Location.PackageConfig
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Symbols.Location.PackageConfig
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Symbols.Location.PackageConfig
instance GHC.Show.Show HsDev.Symbols.Location.PackageConfig
instance GHC.Read.Read HsDev.Symbols.Location.PackageConfig
instance GHC.Classes.Ord HsDev.Symbols.Location.PackageConfig
instance GHC.Classes.Eq HsDev.Symbols.Location.PackageConfig
instance Control.DeepSeq.NFData HsDev.Symbols.Location.ModulePackage
instance GHC.Show.Show HsDev.Symbols.Location.ModulePackage
instance GHC.Read.Read HsDev.Symbols.Location.ModulePackage
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Symbols.Location.ModulePackage
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Symbols.Location.ModulePackage
instance GHC.Classes.Ord HsDev.Symbols.Location.ModulePackage
instance GHC.Classes.Eq HsDev.Symbols.Location.ModulePackage

module HsDev.Types

-- | hsdev exception type
data HsDevError
HsDevFailure :: HsDevError
ModuleNotSource :: ModuleLocation -> HsDevError
BrowseNoModuleInfo :: String -> HsDevError
FileNotFound :: Path -> HsDevError
ToolNotFound :: String -> HsDevError
ProjectNotFound :: Text -> HsDevError
PackageNotFound :: Text -> HsDevError
ToolError :: String -> String -> HsDevError
NotInspected :: ModuleLocation -> HsDevError
InspectError :: String -> HsDevError
InspectCabalError :: FilePath -> String -> HsDevError
IOFailed :: String -> HsDevError
GhcError :: String -> HsDevError
RequestError :: String -> String -> HsDevError
ResponseError :: String -> String -> HsDevError
SQLiteError :: String -> HsDevError
OtherError :: String -> HsDevError
UnhandledError :: String -> HsDevError
instance Control.DeepSeq.NFData HsDev.Types.HsDevError
instance GHC.Show.Show HsDev.Types.HsDevError
instance GHC.Base.Monoid HsDev.Types.HsDevError
instance Text.Format.Formattable HsDev.Types.HsDevError
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Types.HsDevError
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Types.HsDevError
instance GHC.Exception.Exception HsDev.Types.HsDevError

module HsDev.Server.Message

-- | Message with id to link request and response
data Message a
Message :: Maybe String -> a -> Message a
[_messageId] :: Message a -> Maybe String
[_message] :: Message a -> a
messageId :: forall a_a1MIm. Lens' (Message a_a1MIm) (Maybe String)
message :: forall a_a1MIm a_a1MNL. Lens (Message a_a1MIm) (Message a_a1MNL) a_a1MIm a_a1MNL

-- | Get messages by id
messagesById :: Maybe String -> [Message a] -> [a]

-- | Notification from server
newtype Notification
Notification :: Value -> Notification

-- | Result from server
data Result

-- | Result
Result :: Value -> Result

-- | Error
Error :: HsDevError -> Result

-- | Part of result list, returns via notification
newtype ResultPart
ResultPart :: Value -> ResultPart
newtype Response
Response :: Either Notification Result -> Response
[unResponse] :: Response -> Either Notification Result
isNotification :: Response -> Bool
result :: ToJSON a => a -> Response
responseError :: HsDevError -> Response
groupResponses :: [Response] -> [([Notification], Result)]

-- | Decode lisp or json request
decodeMessage :: FromJSON a => ByteString -> Either (Msg String) (Msg (Message a))
encodeMessage :: ToJSON a => Msg (Message a) -> ByteString
instance GHC.Show.Show HsDev.Server.Message.Response
instance GHC.Show.Show HsDev.Server.Message.Result
instance GHC.Show.Show HsDev.Server.Message.Notification
instance GHC.Classes.Eq HsDev.Server.Message.Notification
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Server.Message.Response
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Server.Message.Response
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Server.Message.ResultPart
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Server.Message.ResultPart
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Server.Message.Result
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Server.Message.Result
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Server.Message.Notification
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Server.Message.Notification
instance Data.Aeson.Types.ToJSON.ToJSON a => Data.Aeson.Types.ToJSON.ToJSON (HsDev.Server.Message.Message a)
instance Data.Aeson.Types.FromJSON.FromJSON a => Data.Aeson.Types.FromJSON.FromJSON (HsDev.Server.Message.Message a)
instance Data.Foldable.Foldable HsDev.Server.Message.Message
instance Data.Traversable.Traversable HsDev.Server.Message.Message
instance GHC.Base.Functor HsDev.Server.Message.Message
instance GHC.Show.Show a => GHC.Show.Show (HsDev.Server.Message.Message a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (HsDev.Server.Message.Message a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (HsDev.Server.Message.Message a)

module HsDev.Error

-- | Throw <a>HsDevError</a>
hsdevError :: MonadThrow m => HsDevError -> m a

-- | Throw as <a>OtherError</a>
hsdevOtherError :: (Exception e, MonadThrow m) => e -> m a

-- | Throw as <a>OtherError</a>
hsdevLift :: MonadThrow m => ExceptT String m a -> m a

-- | Throw as some <a>HsDevError</a>
hsdevLiftWith :: MonadThrow m => (String -> HsDevError) -> ExceptT String m a -> m a
hsdevCatch :: MonadCatch m => m a -> m (Either HsDevError a)

-- | Rethrow IO exceptions as <a>HsDevError</a>
hsdevLiftIO :: MonadCatch m => m a -> m a

-- | Rethrow IO exceptions
hsdevLiftIOWith :: MonadCatch m => (String -> HsDevError) -> m a -> m a

-- | Ignore hsdev exception
hsdevIgnore :: MonadCatch m => a -> m a -> m a

-- | Handle hsdev exception
hsdevHandle :: MonadCatch m => (HsDevError -> m a) -> m a -> m a

module HsDev.Tools.Types

-- | Note severity
data Severity
Error :: Severity
Warning :: Severity
Hint :: Severity

-- | Note over some region
data Note a
Note :: ModuleLocation -> Region -> Maybe Severity -> a -> Note a
[_noteSource] :: Note a -> ModuleLocation
[_noteRegion] :: Note a -> Region
[_noteLevel] :: Note a -> Maybe Severity
[_note] :: Note a -> a
noteSource :: forall a_a1PVy. Lens' (Note a_a1PVy) ModuleLocation
noteRegion :: forall a_a1PVy. Lens' (Note a_a1PVy) Region
noteLevel :: forall a_a1PVy. Lens' (Note a_a1PVy) (Maybe Severity)
note :: forall a_a1PVy a_a1Q7t. Lens (Note a_a1PVy) (Note a_a1Q7t) a_a1PVy a_a1Q7t

-- | Output message from some tool (ghc, ghc-mod, hlint) with optional
--   suggestion
data OutputMessage
OutputMessage :: Text -> Maybe Text -> OutputMessage
[_message] :: OutputMessage -> Text
[_messageSuggestion] :: OutputMessage -> Maybe Text
message :: Lens' OutputMessage Text
messageSuggestion :: Lens' OutputMessage (Maybe Text)
outputMessage :: Text -> OutputMessage
instance GHC.Show.Show HsDev.Tools.Types.OutputMessage
instance GHC.Read.Read HsDev.Tools.Types.OutputMessage
instance GHC.Classes.Ord HsDev.Tools.Types.OutputMessage
instance GHC.Classes.Eq HsDev.Tools.Types.OutputMessage
instance Control.DeepSeq.NFData HsDev.Tools.Types.OutputMessage
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Tools.Types.OutputMessage
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Tools.Types.OutputMessage
instance GHC.Base.Functor HsDev.Tools.Types.Note
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (HsDev.Tools.Types.Note a)
instance Data.Aeson.Types.ToJSON.ToJSON a => Data.Aeson.Types.ToJSON.ToJSON (HsDev.Tools.Types.Note a)
instance Data.Aeson.Types.FromJSON.FromJSON a => Data.Aeson.Types.FromJSON.FromJSON (HsDev.Tools.Types.Note a)
instance HsDev.Symbols.Location.RecalcTabs (HsDev.Tools.Types.Note a)
instance System.Directory.Paths.Paths (HsDev.Tools.Types.Note a)
instance GHC.Show.Show a => GHC.Show.Show (HsDev.Tools.Types.Note a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (HsDev.Tools.Types.Note a)
instance GHC.Show.Show HsDev.Tools.Types.Severity
instance GHC.Read.Read HsDev.Tools.Types.Severity
instance GHC.Classes.Ord HsDev.Tools.Types.Severity
instance GHC.Classes.Eq HsDev.Tools.Types.Severity
instance GHC.Enum.Bounded HsDev.Tools.Types.Severity
instance GHC.Enum.Enum HsDev.Tools.Types.Severity
instance Control.DeepSeq.NFData HsDev.Tools.Types.Severity
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Tools.Types.Severity
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Tools.Types.Severity

module HsDev.Tools.Base

-- | Run tool, throwing HsDevError on fail
runTool :: FilePath -> [String] -> String -> IO String

-- | Run tool with not stdin
runTool_ :: FilePath -> [String] -> IO String
type Result = Either String String
type ToolM a = ExceptT String IO a

-- | Run command and wait for result
runWait :: FilePath -> [String] -> String -> IO Result

-- | Run command with no input
runWait_ :: FilePath -> [String] -> IO Result

-- | Tool
tool :: FilePath -> [String] -> String -> ToolM String

-- | Tool with no input
tool_ :: FilePath -> [String] -> ToolM String
matchRx :: String -> String -> Maybe (Int -> Maybe String)
splitRx :: String -> String -> [String]
replaceRx :: String -> String -> String -> String
at :: (Int -> Maybe a) -> Int -> a
at_ :: IsString s => (Int -> Maybe s) -> Int -> s

module HsDev.Tools.Cabal
data CabalPackage
CabalPackage :: String -> Maybe String -> Maybe Version -> [Version] -> Maybe String -> Maybe License -> CabalPackage
[cabalPackageName] :: CabalPackage -> String
[cabalPackageSynopsis] :: CabalPackage -> Maybe String
[cabalPackageDefaultVersion] :: CabalPackage -> Maybe Version
[cabalPackageInstalledVersions] :: CabalPackage -> [Version]
[cabalPackageHomepage] :: CabalPackage -> Maybe String
[cabalPackageLicense] :: CabalPackage -> Maybe License
cabalList :: [String] -> ToolM [CabalPackage]

-- | A <a>Version</a> represents the version of a software entity.
--   
--   Instances of <a>Eq</a> and <a>Ord</a> are provided, which gives exact
--   equality and lexicographic ordering of the version number components
--   (i.e. 2.1 &gt; 2.0, 1.2.3 &gt; 1.2.2, etc.).
--   
--   This type is opaque and distinct from the <a>Version</a> type in
--   <a>Data.Version</a> since <tt>Cabal-2.0</tt>. The difference extends
--   to the <a>Binary</a> instance using a different (and more compact)
--   encoding.
data Version :: *

-- | Indicates the license under which a package's source code is released.
--   Versions of the licenses not listed here will be rejected by Hackage
--   and cause <tt>cabal check</tt> to issue a warning.
data License :: *

-- | GNU General Public License, <a>version 2</a> or <a>version 3</a>.
GPL :: Maybe Version -> License

-- | <a>GNU Affero General Public License, version 3</a>.
AGPL :: Maybe Version -> License

-- | GNU Lesser General Public License, <a>version 2.1</a> or <a>version
--   3</a>.
LGPL :: Maybe Version -> License

-- | <a>2-clause BSD license</a>.
BSD2 :: License

-- | <a>3-clause BSD license</a>.
BSD3 :: License

-- | <a>4-clause BSD license</a>. This license has not been approved by the
--   OSI and is incompatible with the GNU GPL. It is provided for
--   historical reasons and should be avoided.
BSD4 :: License

-- | <a>MIT license</a>.
MIT :: License

-- | <a>ISC license</a>
ISC :: License

-- | <a>Mozilla Public License, version 2.0</a>.
MPL :: Version -> License

-- | <a>Apache License, version 2.0</a>.
Apache :: Maybe Version -> License

-- | The author of a package disclaims any copyright to its source code and
--   dedicates it to the public domain. This is not a software license.
--   Please note that it is not possible to dedicate works to the public
--   domain in every jurisdiction, nor is a work that is in the public
--   domain in one jurisdiction necessarily in the public domain elsewhere.
PublicDomain :: License

-- | Explicitly 'All Rights Reserved', eg for proprietary software. The
--   package may not be legally modified or redistributed by anyone but the
--   rightsholder.
AllRightsReserved :: License

-- | No license specified which legally defaults to 'All Rights Reserved'.
--   The package may not be legally modified or redistributed by anyone but
--   the rightsholder.
UnspecifiedLicense :: License

-- | Any other software license.
OtherLicense :: License

-- | Indicates an erroneous license name.
UnknownLicense :: String -> License
instance GHC.Show.Show HsDev.Tools.Cabal.CabalPackage
instance GHC.Read.Read HsDev.Tools.Cabal.CabalPackage
instance GHC.Classes.Eq HsDev.Tools.Cabal.CabalPackage
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Tools.Cabal.CabalPackage
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Tools.Cabal.CabalPackage

module HsDev.Tools.Tabs

-- | Some tools counts tab as 8 symbols and return such file positions;
--   convert them (consider tab = one symbol)
recalcNotesTabs :: Map Path Text -> [Note a] -> IO [Note a]

module HsDev.Tools.Refact
data Refact
Refact :: Text -> Replace Text -> Refact
[_refactMessage] :: Refact -> Text
[_refactAction] :: Refact -> Replace Text
refactMessage :: Lens' Refact Text
refactAction :: Lens' Refact (Replace Text)
refact :: [Refact] -> Text -> Text
update :: Regioned a => [Refact] -> [a] -> [a]

-- | Replace region with data
replace :: EditAction e s => Region -> s -> e s

-- | Cuts region
cut :: EditAction e s => Region -> e s

-- | Pastes <a>Contents</a> at some <a>Point</a>
paste :: EditAction e s => Point -> s -> e s
fromRegion :: Region -> Region
fromPosition :: Position -> Point
instance Data.Text.Region.Types.Regioned HsDev.Tools.Refact.Refact
instance GHC.Show.Show HsDev.Tools.Refact.Refact
instance GHC.Classes.Eq HsDev.Tools.Refact.Refact
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Tools.Refact.Refact
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Tools.Refact.Refact

module HsDev.Tools.AutoFix
corrections :: [Note OutputMessage] -> [Note Refact]
type CorrectorMatch = Note OutputMessage -> Maybe (Note Refact)
correctors :: [CorrectorMatch]
match :: String -> ((Int -> Maybe Text) -> Region -> Refact) -> CorrectorMatch
findCorrector :: Note OutputMessage -> Maybe (Note Refact)
instance Data.Text.Region.Types.Regioned a => Data.Text.Region.Types.Regioned (HsDev.Tools.Types.Note a)

module HsDev.Tools.HLint
hlint :: FilePath -> Maybe Text -> ExceptT String IO [Note OutputMessage]
instance GHC.Classes.Ord HsDev.Tools.HLint.Indent
instance GHC.Classes.Eq HsDev.Tools.HLint.Indent
instance GHC.Show.Show HsDev.Tools.HLint.Indent

module HsDev.Tools.Ghc.Base

-- | Run ghc
ghcRun :: GhcMonad m => [String] -> m a -> m a

-- | Run ghc
ghcRunWith :: GhcMonad m => (DynFlags -> DynFlags) -> [String] -> m a -> m a
interpretedFlags :: DynFlags -> DynFlags
noLinkFlags :: DynFlags -> DynFlags

-- | Alter <tt>DynFlags</tt> temporary
withFlags :: GhcMonad m => m a -> m a

-- | Update <tt>DynFlags</tt>
modifyFlags :: GhcMonad m => (DynFlags -> DynFlags) -> m ()

-- | Clear loaded targets
clearTargets :: GhcMonad m => m ()

-- | Make target with its source code optional
makeTarget :: GhcMonad m => Text -> Maybe Text -> m Target

-- | Load all targets
loadTargets :: GhcMonad m => [Target] -> m ()

-- | Load and set interactive context
loadInteractive :: GhcMonad m => Path -> Maybe Text -> m ()

-- | Reload targets
reload :: GhcMonad m => m ()

-- | Collect messages from ghc for underlying computation
collectMessages :: GhcMonad m => m a -> m (a, [Note OutputMessage])

-- | Same as <tt>collectMessages</tt>, but when no result except notes
--   needed
collectMessages_ :: GhcMonad m => m () -> m [Note OutputMessage]

-- | Format type for output
formatType :: DynFlags -> Type -> String

-- | Get region of <tt>SrcSpan</tt>
spanRegion :: SrcSpan -> Region

-- | Set current directory and restore it after action
withCurrentDirectory :: GhcMonad m => FilePath -> m a -> m a

-- | Log ghc warnings and errors as to chan You may have to apply
--   recalcTabs on result notes
logToChan :: Chan (Note OutputMessage) -> LogAction

-- | Don't log ghc warnings and errors
logToNull :: LogAction

module HsDev.Tools.Ghc.Repl

-- | Import some modules
importModules :: GhcMonad m => [String] -> m ()

-- | Default interpreter modules
preludeModules :: [String]

-- | Evaluate expression
evaluate :: GhcMonad m => String -> m String

-- | Get expression type as string
expressionType :: GhcMonad m => String -> m String
data ReplResult a
ReplError :: String -> ReplResult a
ReplOk :: a -> ReplResult a
tryRepl :: (GhcMonad m, MonadCatch m) => m a -> m (ReplResult a)
instance GHC.Show.Show a => GHC.Show.Show (HsDev.Tools.Ghc.Repl.ReplResult a)
instance GHC.Read.Read a => GHC.Read.Read (HsDev.Tools.Ghc.Repl.ReplResult a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (HsDev.Tools.Ghc.Repl.ReplResult a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (HsDev.Tools.Ghc.Repl.ReplResult a)
instance Data.Aeson.Types.ToJSON.ToJSON a => Data.Aeson.Types.ToJSON.ToJSON (HsDev.Tools.Ghc.Repl.ReplResult a)
instance Data.Aeson.Types.FromJSON.FromJSON a => Data.Aeson.Types.FromJSON.FromJSON (HsDev.Tools.Ghc.Repl.ReplResult a)

module HsDev.Tools.Ghc.Worker
data SessionType
SessionGhci :: SessionType
SessionGhc :: SessionType
SessionHaddock :: SessionType
SessionTmp :: SessionType
data SessionConfig
SessionConfig :: SessionType -> PackageDbStack -> SessionConfig
type GhcM a = MGhcT SessionConfig (First DynFlags) (LogT IO) a
type GhcWorker = Worker (MGhcT SessionConfig (First DynFlags) (LogT IO))

-- | Multi-session ghc monad
newtype MGhcT s d m a
MGhcT :: GhcT (ReaderT (Maybe FilePath) (StateT (SessionState s d) m)) a -> MGhcT s d m a
[unMGhcT] :: MGhcT s d m a -> GhcT (ReaderT (Maybe FilePath) (StateT (SessionState s d) m)) a
runGhcM :: MonadLog m => Maybe FilePath -> GhcM a -> m a

-- | Multi-session ghc worker
ghcWorker :: MonadLog m => m GhcWorker

-- | Create session with options
workerSession :: SessionType -> PackageDbStack -> [String] -> GhcM ()

-- | Get ghc session
ghcSession :: PackageDbStack -> [String] -> GhcM ()

-- | Get ghci session
ghciSession :: GhcM ()

-- | Get haddock session with flags
haddockSession :: PackageDbStack -> [String] -> GhcM ()

-- | Get haddock session with flags
tmpSession :: PackageDbStack -> [String] -> GhcM ()

-- | A minimal implementation of a <a>GhcMonad</a>. If you need a custom
--   monad, e.g., to maintain additional state consider wrapping this monad
--   or using <a>GhcT</a>.
data Ghc a :: * -> *
newtype LogT (m :: * -> *) a :: (* -> *) -> * -> *
LogT :: ReaderT * Log m a -> LogT a
[runLogT] :: LogT a -> ReaderT * Log m a
instance GHC.Classes.Ord HsDev.Tools.Ghc.Worker.SessionConfig
instance GHC.Classes.Eq HsDev.Tools.Ghc.Worker.SessionConfig
instance GHC.Classes.Ord HsDev.Tools.Ghc.Worker.SessionType
instance GHC.Classes.Eq HsDev.Tools.Ghc.Worker.SessionType
instance GHC.Show.Show HsDev.Tools.Ghc.Worker.SessionConfig
instance Text.Format.Formattable HsDev.Tools.Ghc.Worker.SessionConfig
instance GHC.Show.Show HsDev.Tools.Ghc.Worker.SessionType
instance Text.Format.Formattable HsDev.Tools.Ghc.Worker.SessionType
instance (GHC.Base.Monad m, GhcMonad.GhcMonad m) => GhcMonad.GhcMonad (Control.Monad.Trans.Reader.ReaderT r m)
instance Exception.ExceptionMonad m => Exception.ExceptionMonad (System.Log.Simple.Monad.LogT m)
instance Control.Monad.Catch.MonadThrow GhcMonad.Ghc

module HsDev.Tools.Ghc.System
data BuildInfo
BuildInfo :: String -> String -> String -> String -> String -> BuildInfo
[targetArch] :: BuildInfo -> String
[targetOS] :: BuildInfo -> String
[cabalOS] :: BuildInfo -> String
[compilerName] :: BuildInfo -> String
[compilerVersion] :: BuildInfo -> String
buildInfo :: DynFlags -> BuildInfo
examineCompilerVersion :: DynFlags -> String

-- | Can contain {arch}, {os}/{platform}, {compiler}, {version}
formatBuildPath :: String -> BuildInfo -> String
buildPath :: String -> GhcM FilePath

module HsDev.Symbols.Parsed

-- | Annotation of parsed and resolved nodes
type Ann = Scoped SrcSpanInfo

-- | Parsed and resolved module
type Parsed = Module Ann

-- | Get all qualified names
qnames :: Data (ast Ann) => Traversal' (ast Ann) (QName Ann)

-- | Get all names
names :: Data (ast Ann) => Traversal' (ast Ann) (Name Ann)

-- | Get all binders
binders :: Annotated ast => Traversal' (ast Ann) (ast Ann)

-- | Get all names locally defined
locals :: Annotated ast => Traversal' (ast Ann) (ast Ann)

-- | Get all names, references global symbol
globals :: Annotated ast => Traversal' (ast Ann) (ast Ann)

-- | Get all resolved references
references :: Annotated ast => Traversal' (ast Ann) (ast Ann)

-- | Get all names with not in scope error
unresolveds :: Annotated ast => Traversal' (ast Ann) (ast Ann)

-- | Get all usages of symbol
usages :: Annotated ast => Name -> Traversal' (ast Ann) (ast Ann)

-- | Get usages of symbols with unqualified name
named :: Annotated ast => Text -> Traversal' (ast Ann) (ast Ann)

-- | Get imports
imports :: Data (ast Ann) => Traversal' (ast Ann) (ImportDecl Ann)

-- | Get declarations
declarations :: Data (ast Ann) => Traversal' (ast Ann) (Decl Ann)

-- | Get module names
moduleNames :: Data (ast Ann) => Traversal' (ast Ann) (ModuleName Ann)

-- | Get annotation
annL :: Annotated ast => Lens' (ast a) a

-- | Get haskell-names symbols
symbolL :: Data a => Traversal' a Symbol

-- | Get source file
file :: Annotated ast => Lens' (ast Ann) FilePath

-- | Get source location
pos :: Annotated ast => Lens' (ast Ann) Position

-- | Definition position, if binder - returns current position
defPos :: Annotated ast => Traversal' (ast Ann) Position

-- | Resolved global name
resolvedName :: Annotated ast => Traversal' (ast Ann) Name

-- | Does ast node binds something
isBinder :: Annotated ast => ast Ann -> Bool

-- | Does ast node locally defined
isLocal :: Annotated ast => ast Ann -> Bool

-- | Does ast node reference something
isGlobal :: Annotated ast => ast Ann -> Bool

-- | Does ast node reference something
isReference :: Annotated ast => ast Ann -> Bool

-- | Is ast node not resolved
isUnresolved :: Annotated ast => ast Ann -> Bool

-- | Resolve error
resolveError :: Annotated ast => ast Ann -> Maybe String

-- | Node references to specified symbol
refsTo :: Annotated ast => Name -> ast Ann -> Bool

-- | Node references to specified unqualified name
refsToName :: Annotated ast => Text -> ast Ann -> Bool
nameInfoL :: Lens' (Scoped a) (NameInfo a)
positionL :: (SrcInfo isrc, Data isrc) => Lens' isrc Position
regionL :: Annotated ast => Lens' (ast Ann) Region
fileL :: (SrcInfo isrc, Data isrc) => Lens' isrc FilePath

-- | Get <a>Symbol</a> as <a>Name</a>
symbolNameL :: Lens' Symbol Name

-- | pretty-print with the default style and <a>defaultMode</a>.
prettyPrint :: Pretty a => a -> String

module HsDev.Symbols.Class
class Sourced a
sourcedName :: Sourced a => Lens' a Text
sourcedDocs :: Sourced a => Traversal' a Text
sourcedModule :: Sourced a => Lens' a ModuleId
sourcedLocation :: Sourced a => Traversal' a Position
sourcedModuleName :: Sourced a => Lens' a Text
instance HsDev.Symbols.Class.Sourced HsDev.Symbols.Location.ModuleId
instance HsDev.Symbols.Class.Sourced HsDev.Symbols.Location.SymbolId

module HsDev.Symbols.Documented

-- | Documented symbol
class Documented a
brief :: Documented a => a -> Text
detailed :: Documented a => a -> Text
detailed :: (Documented a, Sourced a) => a -> Text

-- | Default detailed docs
defaultDetailed :: (Sourced a, Documented a) => a -> [Text]
instance HsDev.Symbols.Documented.Documented HsDev.Symbols.Location.ModulePackage
instance HsDev.Symbols.Documented.Documented HsDev.Symbols.Location.ModuleLocation
instance HsDev.Symbols.Documented.Documented HsDev.Project.Types.Project

module HsDev.Project

-- | infoSourceDirs lens with default
infoSourceDirsDef :: Lens' Info [Path]

-- | Get all source file names of target without prepending them with
--   source-dirs
targetFiles :: Target t => t -> [Path]

-- | Get all source file names relative to project root
projectTargetFiles :: (MonadLog m, Target t) => Project -> t -> m [Path]

-- | Analyze cabal file
analyzeCabal :: String -> Either String ProjectDescription

-- | Read project info from .cabal
readProject :: FilePath -> IO Project

-- | Load project description
loadProject :: Project -> IO Project

-- | Extensions for target
withExtensions :: a -> Info -> Extensions a

-- | Check if source related to target, source must be relative to project
--   directory
fileInTarget :: Path -> Info -> Bool

-- | Get first target for source file
fileTarget :: Project -> Path -> Maybe Info

-- | Get possible targets for source file There can be many candidates in
--   case of module related to several executables or tests
fileTargets :: Project -> Path -> [Info]

-- | Finds source dir file belongs to
findSourceDir :: Project -> Path -> Maybe (Extensions Path)

-- | Returns source dirs for library, executables and tests
sourceDirs :: ProjectDescription -> [Extensions Path]

-- | Get options for specific target
targetOpts :: Info -> [String]

-- | Extension as flag name
showExtension :: Extension -> String

-- | Convert -Xext to ext
flagExtension :: String -> Maybe String

-- | Convert ext to -Xext
extensionFlag :: String -> String

-- | Extensions as opts to GHC
extensionsOpts :: Extensions a -> [String]

module HsDev.Symbols.Types

-- | Module
data Module
Module :: ModuleId -> Maybe Text -> [Text] -> [Symbol] -> [Fixity] -> Map Name [Symbol] -> Maybe Parsed -> Module
[_moduleId] :: Module -> ModuleId
[_moduleDocs] :: Module -> Maybe Text
[_moduleImports] :: Module -> [Text]
[_moduleExports] :: Module -> [Symbol]
[_moduleFixities] :: Module -> [Fixity]
[_moduleScope] :: Module -> Map Name [Symbol]
[_moduleSource] :: Module -> Maybe Parsed

-- | Make each symbol appear only once
moduleSymbols :: Traversal' Module Symbol
exportedSymbols :: Traversal' Module Symbol
scopeSymbols :: Traversal' Module (Symbol, [Name])
fixitiesMap :: Lens' Module (Map Name Fixity)
moduleFixities :: Lens' Module [Fixity]
moduleId :: Lens' Module ModuleId
moduleDocs :: Lens' Module (Maybe Text)
moduleImports :: Lens' Module [Text]
moduleExports :: Lens' Module [Symbol]
moduleScope :: Lens' Module (Map Name [Symbol])
moduleSource :: Lens' Module (Maybe Parsed)
data Symbol
Symbol :: SymbolId -> Maybe Text -> Maybe Position -> SymbolInfo -> Symbol
[_symbolId] :: Symbol -> SymbolId
[_symbolDocs] :: Symbol -> Maybe Text
[_symbolPosition] :: Symbol -> Maybe Position
[_symbolInfo] :: Symbol -> SymbolInfo
symbolId :: Lens' Symbol SymbolId
symbolDocs :: Lens' Symbol (Maybe Text)
symbolPosition :: Lens' Symbol (Maybe Position)
symbolInfo :: Lens' Symbol SymbolInfo
data SymbolInfo
Function :: Maybe Text -> SymbolInfo
[_functionType] :: SymbolInfo -> Maybe Text
Method :: Maybe Text -> Text -> SymbolInfo
[_functionType] :: SymbolInfo -> Maybe Text
[_parentClass] :: SymbolInfo -> Text
Selector :: Maybe Text -> Text -> [Text] -> SymbolInfo
[_functionType] :: SymbolInfo -> Maybe Text
[_parentType] :: SymbolInfo -> Text
[_selectorConstructors] :: SymbolInfo -> [Text]
Constructor :: [Text] -> Text -> SymbolInfo
[_typeArgs] :: SymbolInfo -> [Text]
[_parentType] :: SymbolInfo -> Text
Type :: [Text] -> [Text] -> SymbolInfo
[_typeArgs] :: SymbolInfo -> [Text]
[_typeContext] :: SymbolInfo -> [Text]
NewType :: [Text] -> [Text] -> SymbolInfo
[_typeArgs] :: SymbolInfo -> [Text]
[_typeContext] :: SymbolInfo -> [Text]
Data :: [Text] -> [Text] -> SymbolInfo
[_typeArgs] :: SymbolInfo -> [Text]
[_typeContext] :: SymbolInfo -> [Text]
Class :: [Text] -> [Text] -> SymbolInfo
[_typeArgs] :: SymbolInfo -> [Text]
[_typeContext] :: SymbolInfo -> [Text]
TypeFam :: [Text] -> [Text] -> Maybe Text -> SymbolInfo
[_typeArgs] :: SymbolInfo -> [Text]
[_typeContext] :: SymbolInfo -> [Text]
[_familyAssociate] :: SymbolInfo -> Maybe Text
DataFam :: [Text] -> [Text] -> Maybe Text -> SymbolInfo
[_typeArgs] :: SymbolInfo -> [Text]
[_typeContext] :: SymbolInfo -> [Text]
[_familyAssociate] :: SymbolInfo -> Maybe Text
PatConstructor :: [Text] -> Maybe Text -> SymbolInfo
[_typeArgs] :: SymbolInfo -> [Text]
[_patternType] :: SymbolInfo -> Maybe Text
PatSelector :: Maybe Text -> Maybe Text -> Text -> SymbolInfo
[_functionType] :: SymbolInfo -> Maybe Text
[_patternType] :: SymbolInfo -> Maybe Text
[_patternConstructor] :: SymbolInfo -> Text
functionType :: Traversal' SymbolInfo (Maybe Text)
parentClass :: Traversal' SymbolInfo Text
parentType :: Traversal' SymbolInfo Text
selectorConstructors :: Traversal' SymbolInfo [Text]
typeArgs :: Traversal' SymbolInfo [Text]
typeContext :: Traversal' SymbolInfo [Text]
familyAssociate :: Traversal' SymbolInfo (Maybe Text)
symbolInfoType :: SymbolInfo -> String
symbolType :: Symbol -> String
patternType :: Traversal' SymbolInfo (Maybe Text)
patternConstructor :: Traversal' SymbolInfo Text

-- | Scoped entity with qualifier
data Scoped a
Scoped :: Maybe Text -> a -> Scoped a
[_scopeQualifier] :: Scoped a -> Maybe Text
[_scoped] :: Scoped a -> a
scopeQualifier :: forall a_a2h5l. Lens' (Scoped a_a2h5l) (Maybe Text)
scoped :: forall a_a2h5l a_a2jYx. Lens (Scoped a_a2h5l) (Scoped a_a2jYx) a_a2h5l a_a2jYx

-- | Symbol usage
data SymbolUsage
SymbolUsage :: Symbol -> Maybe Text -> ModuleId -> Region -> SymbolUsage
[_symbolUsed] :: SymbolUsage -> Symbol
[_symbolUsedQualifier] :: SymbolUsage -> Maybe Text
[_symbolUsedIn] :: SymbolUsage -> ModuleId
[_symbolUsedRegion] :: SymbolUsage -> Region
symbolUsed :: Lens' SymbolUsage Symbol
symbolUsedQualifier :: Lens' SymbolUsage (Maybe Text)
symbolUsedIn :: Lens' SymbolUsage ModuleId
symbolUsedRegion :: Lens' SymbolUsage Region
infoOf :: EmptySymbolInfo a => a -> SymbolInfo
nullifyInfo :: SymbolInfo -> SymbolInfo

-- | Inspection data
data Inspection

-- | No inspection
InspectionNone :: Inspection

-- | Time and flags of inspection
InspectionAt :: POSIXTime -> [Text] -> Inspection
[_inspectionAt] :: Inspection -> POSIXTime
[_inspectionOpts] :: Inspection -> [Text]
inspectionAt :: Traversal' Inspection POSIXTime
inspectionOpts :: Traversal' Inspection [Text]

-- | Is left <tt>Inspection</tt> fresh comparing to right one
fresh :: Inspection -> Inspection -> Bool

-- | Inspected entity
data Inspected k t a
Inspected :: Inspection -> k -> Set t -> Either HsDevError a -> Inspected k t a
[_inspection] :: Inspected k t a -> Inspection
[_inspectedKey] :: Inspected k t a -> k
[_inspectionTags] :: Inspected k t a -> Set t
[_inspectionResult] :: Inspected k t a -> Either HsDevError a
inspection :: forall k_a2h5i t_a2h5j a_a2h5k. Lens' (Inspected k_a2h5i t_a2h5j a_a2h5k) Inspection
inspectedKey :: forall k_a2h5i t_a2h5j a_a2h5k k_a2k2t. Lens (Inspected k_a2h5i t_a2h5j a_a2h5k) (Inspected k_a2k2t t_a2h5j a_a2h5k) k_a2h5i k_a2k2t
inspectionTags :: forall k_a2h5i t_a2h5j a_a2h5k t_a2k2v. Lens (Inspected k_a2h5i t_a2h5j a_a2h5k) (Inspected k_a2h5i t_a2k2v a_a2h5k) (Set t_a2h5j) (Set t_a2k2v)
inspectionResult :: forall k_a2h5i t_a2h5j a_a2h5k a_a2k2u. Lens (Inspected k_a2h5i t_a2h5j a_a2h5k) (Inspected k_a2h5i t_a2h5j a_a2k2u) (Either HsDevError a_a2h5k) (Either HsDevError a_a2k2u)
inspected :: Traversal (Inspected k t a) (Inspected k t b) a b
newtype InspectM k t m a
InspectM :: ReaderT k (ExceptT HsDevError (StateT (Inspection, Set t) m)) a -> InspectM k t m a
[runInspectM] :: InspectM k t m a -> ReaderT k (ExceptT HsDevError (StateT (Inspection, Set t) m)) a
runInspect :: (Monad m, Ord t) => k -> InspectM k t m a -> m (Inspected k t a)

-- | Continue inspection
continueInspect :: (Monad m, Ord t) => Inspected k t a -> (a -> InspectM k t m b) -> m (Inspected k t b)
inspect :: MonadCatch m => m Inspection -> (k -> m a) -> InspectM k t m a
inspect_ :: MonadCatch m => m Inspection -> m a -> InspectM k t m a
withInspection :: MonadCatch m => m Inspection -> InspectM k t m a -> InspectM k t m a
inspectedTup :: Inspected k t a -> (Inspection, k, Set t, Maybe a)

-- | Empty tags
noTags :: Set t

-- | One tag
tag :: t -> Set t
data ModuleTag
InferredTypesTag :: ModuleTag
RefinedDocsTag :: ModuleTag
OnlyHeaderTag :: ModuleTag
DirtyTag :: ModuleTag
ResolvedNamesTag :: ModuleTag

-- | Inspected module
type InspectedModule = Inspected ModuleLocation ModuleTag Module
notInspected :: ModuleLocation -> InspectedModule
instance HsDev.Symbols.Class.Sourced HsDev.Symbols.Types.Module
instance HsDev.Symbols.Class.Sourced HsDev.Symbols.Types.Symbol
instance GHC.Enum.Bounded HsDev.Symbols.Types.ModuleTag
instance GHC.Enum.Enum HsDev.Symbols.Types.ModuleTag
instance GHC.Show.Show HsDev.Symbols.Types.ModuleTag
instance GHC.Read.Read HsDev.Symbols.Types.ModuleTag
instance GHC.Classes.Ord HsDev.Symbols.Types.ModuleTag
instance GHC.Classes.Eq HsDev.Symbols.Types.ModuleTag
instance GHC.Base.Monad m => Control.Monad.State.Class.MonadState (HsDev.Symbols.Types.Inspection, Data.Set.Internal.Set t) (HsDev.Symbols.Types.InspectM k t m)
instance GHC.Base.Monad m => Control.Monad.Error.Class.MonadError HsDev.Types.HsDevError (HsDev.Symbols.Types.InspectM k t m)
instance GHC.Base.Monad m => Control.Monad.Reader.Class.MonadReader k (HsDev.Symbols.Types.InspectM k t m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (HsDev.Symbols.Types.InspectM k t m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (HsDev.Symbols.Types.InspectM k t m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (HsDev.Symbols.Types.InspectM k t m)
instance GHC.Base.Monad m => GHC.Base.MonadPlus (HsDev.Symbols.Types.InspectM k t m)
instance GHC.Base.Monad m => GHC.Base.Monad (HsDev.Symbols.Types.InspectM k t m)
instance GHC.Base.Monad m => GHC.Base.Alternative (HsDev.Symbols.Types.InspectM k t m)
instance GHC.Base.Monad m => GHC.Base.Applicative (HsDev.Symbols.Types.InspectM k t m)
instance GHC.Base.Functor m => GHC.Base.Functor (HsDev.Symbols.Types.InspectM k t m)
instance GHC.Classes.Ord HsDev.Symbols.Types.Inspection
instance GHC.Classes.Eq HsDev.Symbols.Types.Inspection
instance GHC.Classes.Ord HsDev.Symbols.Types.SymbolUsage
instance GHC.Classes.Eq HsDev.Symbols.Types.SymbolUsage
instance GHC.Classes.Ord a => GHC.Classes.Ord (HsDev.Symbols.Types.Scoped a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (HsDev.Symbols.Types.Scoped a)
instance GHC.Show.Show HsDev.Symbols.Types.SymbolInfo
instance GHC.Read.Read HsDev.Symbols.Types.SymbolInfo
instance GHC.Classes.Ord HsDev.Symbols.Types.SymbolInfo
instance GHC.Classes.Eq HsDev.Symbols.Types.SymbolInfo
instance GHC.Show.Show HsDev.Symbols.Types.InspectedModule
instance Control.DeepSeq.NFData HsDev.Symbols.Types.ModuleTag
instance HsDev.Display.Display HsDev.Symbols.Types.ModuleTag
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Symbols.Types.ModuleTag
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Symbols.Types.ModuleTag
instance Control.Monad.Trans.Class.MonadTrans (HsDev.Symbols.Types.InspectM k t)
instance (GHC.Classes.Eq k, GHC.Classes.Eq t, GHC.Classes.Eq a) => GHC.Classes.Eq (HsDev.Symbols.Types.Inspected k t a)
instance (GHC.Classes.Ord k, GHC.Classes.Ord t, GHC.Classes.Ord a) => GHC.Classes.Ord (HsDev.Symbols.Types.Inspected k t a)
instance GHC.Base.Functor (HsDev.Symbols.Types.Inspected k t)
instance Data.Foldable.Foldable (HsDev.Symbols.Types.Inspected k t)
instance Data.Traversable.Traversable (HsDev.Symbols.Types.Inspected k t)
instance (Control.DeepSeq.NFData k, Control.DeepSeq.NFData t, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (HsDev.Symbols.Types.Inspected k t a)
instance (Data.Aeson.Types.ToJSON.ToJSON k, Data.Aeson.Types.ToJSON.ToJSON t, Data.Aeson.Types.ToJSON.ToJSON a) => Data.Aeson.Types.ToJSON.ToJSON (HsDev.Symbols.Types.Inspected k t a)
instance (Data.Aeson.Types.FromJSON.FromJSON k, GHC.Classes.Ord t, Data.Aeson.Types.FromJSON.FromJSON t, Data.Aeson.Types.FromJSON.FromJSON a) => Data.Aeson.Types.FromJSON.FromJSON (HsDev.Symbols.Types.Inspected k t a)
instance Control.DeepSeq.NFData HsDev.Symbols.Types.Inspection
instance GHC.Show.Show HsDev.Symbols.Types.Inspection
instance GHC.Base.Monoid HsDev.Symbols.Types.Inspection
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Symbols.Types.Inspection
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Symbols.Types.Inspection
instance GHC.Show.Show HsDev.Symbols.Types.SymbolUsage
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Symbols.Types.SymbolUsage
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Symbols.Types.SymbolUsage
instance GHC.Show.Show a => GHC.Show.Show (HsDev.Symbols.Types.Scoped a)
instance Data.Aeson.Types.ToJSON.ToJSON a => Data.Aeson.Types.ToJSON.ToJSON (HsDev.Symbols.Types.Scoped a)
instance Data.Aeson.Types.FromJSON.FromJSON a => Data.Aeson.Types.FromJSON.FromJSON (HsDev.Symbols.Types.Scoped a)
instance HsDev.Symbols.Types.EmptySymbolInfo HsDev.Symbols.Types.SymbolInfo
instance (GHC.Base.Monoid a, HsDev.Symbols.Types.EmptySymbolInfo r) => HsDev.Symbols.Types.EmptySymbolInfo (a -> r)
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Symbols.Types.Module
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Symbols.Types.Module
instance Control.DeepSeq.NFData HsDev.Symbols.Types.Module
instance GHC.Classes.Eq HsDev.Symbols.Types.Module
instance GHC.Classes.Ord HsDev.Symbols.Types.Module
instance GHC.Show.Show HsDev.Symbols.Types.Module
instance HsDev.Symbols.Documented.Documented HsDev.Symbols.Types.Module
instance GHC.Classes.Eq HsDev.Symbols.Types.Symbol
instance GHC.Classes.Ord HsDev.Symbols.Types.Symbol
instance Control.DeepSeq.NFData HsDev.Symbols.Types.Symbol
instance GHC.Show.Show HsDev.Symbols.Types.Symbol
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Symbols.Types.Symbol
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Symbols.Types.Symbol
instance HsDev.Symbols.Documented.Documented HsDev.Symbols.Types.Symbol
instance Control.DeepSeq.NFData HsDev.Symbols.Types.SymbolInfo
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Symbols.Types.SymbolInfo
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Symbols.Types.SymbolInfo
instance Control.DeepSeq.NFData l => Control.DeepSeq.NFData (Language.Haskell.Exts.Syntax.ModuleName l)
instance Control.DeepSeq.NFData l => Control.DeepSeq.NFData (Language.Haskell.Exts.Syntax.Name l)
instance Control.DeepSeq.NFData Language.Haskell.Exts.Syntax.Boxed
instance Control.DeepSeq.NFData l => Control.DeepSeq.NFData (Language.Haskell.Exts.Syntax.SpecialCon l)
instance Control.DeepSeq.NFData l => Control.DeepSeq.NFData (Language.Haskell.Exts.Syntax.QName l)
instance Data.Aeson.Types.ToJSON.ToJSON (Language.Haskell.Exts.Syntax.Assoc ())
instance Data.Aeson.Types.FromJSON.FromJSON (Language.Haskell.Exts.Syntax.Assoc ())
instance Data.Aeson.Types.ToJSON.ToJSON Language.Haskell.Exts.Fixity.Fixity
instance Data.Aeson.Types.FromJSON.FromJSON Language.Haskell.Exts.Fixity.Fixity
instance Control.DeepSeq.NFData (Language.Haskell.Exts.Syntax.Assoc ())
instance Control.DeepSeq.NFData Language.Haskell.Exts.Fixity.Fixity
instance GHC.Read.Read Data.Time.Clock.Internal.POSIXTime.POSIXTime
instance HsDev.Symbols.Documented.Documented HsDev.Symbols.Location.ModuleId
instance HsDev.Symbols.Documented.Documented HsDev.Symbols.Location.SymbolId

module HsDev.Symbols.HaskellNames
class ToEnvironment a
environment :: ToEnvironment a => a -> Environment
fromSymbol :: Symbol -> Symbol
toSymbol :: Symbol -> Symbol
instance HsDev.Symbols.HaskellNames.ToEnvironment HsDev.Symbols.Types.Module
instance HsDev.Symbols.HaskellNames.ToEnvironment [HsDev.Symbols.Types.Module]

module HsDev.Symbols

-- | Find project file is related to
locateProject :: FilePath -> IO (Maybe Project)

-- | Search project up
searchProject :: FilePath -> IO (Maybe Project)

-- | Locate source dir of file
locateSourceDir :: FilePath -> IO (Maybe (Extensions Path))

-- | Make <a>Info</a> for standalone <a>Module</a>
standaloneInfo :: [PackageConfig] -> Module -> Info

-- | Options for GHC of module and project
moduleOpts :: [PackageConfig] -> Module -> [String]

-- | Options for GHC of project
projectTargetOpts :: [PackageConfig] -> Project -> Info -> [String]

-- | Set tag to <a>Inspected</a>
setTag :: Ord t => t -> Inspected i t a -> Inspected i t a

-- | Check whether <a>Inspected</a> has tag
hasTag :: Ord t => t -> Inspected i t a -> Bool

-- | Drop tag from <a>Inspected</a>
removeTag :: Ord t => t -> Inspected i t a -> Inspected i t a

-- | Drop all tags
dropTags :: Inspected i t a -> Inspected i t a

-- | Set inspection tag
inspectTag :: (Monad m, Ord t) => t -> InspectM k t m a -> InspectM k t m a

-- | Unser inspection tag
inspectUntag :: (Monad m, Ord t) => t -> InspectM k t m a -> InspectM k t m a

module HsDev.Tools.Hayoo

-- | Hayoo response
data HayooResult
HayooResult :: Int -> Int -> Int -> [HayooSymbol] -> HayooResult
[resultMax] :: HayooResult -> Int
[resultOffset] :: HayooResult -> Int
[resultCount] :: HayooResult -> Int
[resultResult] :: HayooResult -> [HayooSymbol]

-- | Hayoo symbol
data HayooSymbol
HayooSymbol :: String -> String -> String -> String -> String -> String -> String -> [String] -> Double -> String -> HayooSymbol
[resultUri] :: HayooSymbol -> String
[tag] :: HayooSymbol -> String
[hayooPackage] :: HayooSymbol -> String
[hayooName] :: HayooSymbol -> String
[hayooSource] :: HayooSymbol -> String
[hayooDescription] :: HayooSymbol -> String
[hayooSignature] :: HayooSymbol -> String
[hayooModules] :: HayooSymbol -> [String]
[hayooScore] :: HayooSymbol -> Double
[hayooType] :: HayooSymbol -> String

-- | <tt>HayooFunction</tt> as <a>Symbol</a>
hayooAsSymbol :: HayooSymbol -> Maybe Symbol

-- | Search hayoo
hayoo :: String -> Maybe Int -> ExceptT String IO HayooResult

-- | Remove tags in description
untagDescription :: String -> String
instance GHC.Show.Show HsDev.Tools.Hayoo.HayooResult
instance GHC.Read.Read HsDev.Tools.Hayoo.HayooResult
instance GHC.Classes.Ord HsDev.Tools.Hayoo.HayooResult
instance GHC.Classes.Eq HsDev.Tools.Hayoo.HayooResult
instance GHC.Show.Show HsDev.Tools.Hayoo.HayooSymbol
instance GHC.Read.Read HsDev.Tools.Hayoo.HayooSymbol
instance GHC.Classes.Ord HsDev.Tools.Hayoo.HayooSymbol
instance GHC.Classes.Eq HsDev.Tools.Hayoo.HayooSymbol
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Tools.Hayoo.HayooResult
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Tools.Hayoo.HayooValue
instance HsDev.Symbols.Class.Sourced HsDev.Tools.Hayoo.HayooSymbol
instance HsDev.Symbols.Documented.Documented HsDev.Tools.Hayoo.HayooSymbol
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Tools.Hayoo.HayooSymbol

module HsDev.Tools.Ghc.Types
data TypedExpr
TypedExpr :: Maybe Text -> Text -> TypedExpr
[_typedExpr] :: TypedExpr -> Maybe Text
[_typedType] :: TypedExpr -> Text
typedExpr :: Lens' TypedExpr (Maybe Text)
typedType :: Lens' TypedExpr Text
moduleTypes :: GhcMonad m => Path -> m [(SrcSpan, Type)]

-- | Get all types in module
fileTypes :: (MonadLog m, GhcMonad m) => Module -> Maybe Text -> m [Note TypedExpr]

-- | Set types to module
setModuleTypes :: [Note TypedExpr] -> Module -> Module

-- | Infer types in module
inferTypes :: (MonadLog m, GhcMonad m) => Module -> Maybe Text -> m Module
instance Control.DeepSeq.NFData HsDev.Tools.Ghc.Types.TypedExpr
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Tools.Ghc.Types.TypedExpr
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Tools.Ghc.Types.TypedExpr
instance GHC.Show.Show HsDev.Tools.Ghc.Types.TypedExpr
instance GHC.Read.Read HsDev.Tools.Ghc.Types.TypedExpr
instance GHC.Classes.Ord HsDev.Tools.Ghc.Types.TypedExpr
instance GHC.Classes.Eq HsDev.Tools.Ghc.Types.TypedExpr
instance HsDev.Tools.Ghc.Types.HasType (HsExpr.LHsExpr Var.Id)
instance HsDev.Tools.Ghc.Types.HasType (HsBinds.LHsBind Var.Id)
instance HsDev.Tools.Ghc.Types.HasType (HsPat.LPat Var.Id)

module HsDev.Symbols.Resolve
type RefineTable = Map (Text, Text, SymbolInfo) Symbol
refineTable :: [Symbol] -> RefineTable
refineSymbol :: RefineTable -> Symbol -> Symbol
refineSymbols :: RefineTable -> Module -> Module
symbolUniqId :: Symbol -> (Text, Text, SymbolInfo)

module HsDev.Inspect.Types

-- | Preloaded module with contents and extensions
data Preloaded
Preloaded :: ModuleId -> ParseMode -> Module SrcSpanInfo -> Text -> Preloaded
[_preloadedId] :: Preloaded -> ModuleId
[_preloadedMode] :: Preloaded -> ParseMode

-- | Loaded module head without declarations
[_preloadedModule] :: Preloaded -> Module SrcSpanInfo
[_preloaded] :: Preloaded -> Text
preloadedId :: Lens' Preloaded ModuleId
preloadedMode :: Lens' Preloaded ParseMode
preloadedModule :: Lens' Preloaded (Module SrcSpanInfo)
asModule :: Lens' Preloaded Module
preloaded :: Lens' Preloaded Text
type InspectedPreloaded = Inspected ModuleLocation ModuleTag Preloaded

-- | Symbols environment, used to resolve names in source
type Environment = Environment

-- | Fixities environment, needed to parse source
type FixitiesTable = Map Name Fixity

-- | Resolved module
data Resolved
Resolved :: ModuleName () -> Parsed -> [Symbol] -> [Text] -> [Symbol] -> Table -> [Fixity] -> Resolved
[_resolvedModule] :: Resolved -> ModuleName ()
[_resolvedSource] :: Resolved -> Parsed
[_resolvedDefs] :: Resolved -> [Symbol]
[_resolvedImports] :: Resolved -> [Text]
[_resolvedExports] :: Resolved -> [Symbol]
[_resolvedScope] :: Resolved -> Table
[_resolvedFixities] :: Resolved -> [Fixity]
resolvedModule :: Lens' Resolved (ModuleName ())
resolvedSource :: Lens' Resolved Parsed
resolvedDefs :: Lens' Resolved [Symbol]
resolvedImports :: Lens' Resolved [Text]
resolvedExports :: Lens' Resolved [Symbol]
resolvedScope :: Lens' Resolved Table
resolvedFixities :: Lens' Resolved [Fixity]

-- | Like <tt>InspectedModule</tt>, but for <tt>Resolved</tt>
type InspectedResolved = Inspected ModuleLocation ModuleTag Resolved

-- | Get environment for resolved module
resolvedEnv :: Resolved -> Environment

-- | Get fixities table from resolved module
resolvedFixitiesTable :: Resolved -> FixitiesTable

-- | Drop extra info
dropScope :: Functor f => f (Scoped l) -> f l

-- | Empty scope info
noScope :: l -> Scoped l

-- | Set empty scope
withNoScope :: Functor f => f l -> f (Scoped l)
instance Control.DeepSeq.NFData HsDev.Inspect.Types.Resolved
instance Control.DeepSeq.NFData HsDev.Inspect.Types.Preloaded

module HsDev.Inspect.Definitions

-- | Get top symbols
getSymbols :: [Decl Ann] -> [Symbol]

-- | Get symbols from declarations
getDecl :: Decl Ann -> [Symbol]

module HsDev.PackageDb

-- | Get path to package-db
packageDbPath :: PackageDb -> IO Path

-- | Read package-db conf files
readPackageDb :: PackageDb -> IO (Map ModulePackage [ModuleLocation])

module HsDev.Tools.Ghc.Check

-- | Check module source
check :: (MonadLog m, GhcMonad m) => Module -> Maybe Text -> m [Note OutputMessage]

-- | A minimal implementation of a <a>GhcMonad</a>. If you need a custom
--   monad, e.g., to maintain additional state consider wrapping this monad
--   or using <a>GhcT</a>.
data Ghc a :: * -> *
data PackageDb
GlobalDb :: PackageDb
UserDb :: PackageDb
PackageDb :: Path -> PackageDb
[_packageDb] :: PackageDb -> Path

-- | Stack of PackageDb in reverse order
newtype PackageDbStack
PackageDbStack :: [PackageDb] -> PackageDbStack
[_packageDbStack] :: PackageDbStack -> [PackageDb]

-- | Cabal project
data Project
Project :: Text -> Path -> Path -> Maybe ProjectDescription -> Maybe PackageDbStack -> Project
[_projectName] :: Project -> Text
[_projectPath] :: Project -> Path
[_projectCabal] :: Project -> Path
[_projectDescription] :: Project -> Maybe ProjectDescription
[_projectPackageDbStack] :: Project -> Maybe PackageDbStack

module HsDev.Stack

-- | Invoke stack command, we are trying to get actual stack near current
--   hsdev executable
stack :: [String] -> GhcM String

-- | Make yaml opts
yaml :: Maybe FilePath -> [String]

-- | Stack path
path :: Maybe FilePath -> GhcM PathsConf

-- | Get path for
pathOf :: String -> Lens' PathsConf (Maybe FilePath)

-- | Build stack project
build :: [String] -> Maybe FilePath -> GhcM ()

-- | Build only dependencies
buildDeps :: Maybe FilePath -> GhcM ()
data StackEnv
StackEnv :: FilePath -> FilePath -> FilePath -> FilePath -> FilePath -> FilePath -> StackEnv
[_stackRoot] :: StackEnv -> FilePath
[_stackProject] :: StackEnv -> FilePath
[_stackConfig] :: StackEnv -> FilePath
[_stackGhc] :: StackEnv -> FilePath
[_stackSnapshot] :: StackEnv -> FilePath
[_stackLocal] :: StackEnv -> FilePath
stackRoot :: Lens' StackEnv FilePath
stackProject :: Lens' StackEnv FilePath
stackConfig :: Lens' StackEnv FilePath
stackGhc :: Lens' StackEnv FilePath
stackSnapshot :: Lens' StackEnv FilePath
stackLocal :: Lens' StackEnv FilePath
getStackEnv :: PathsConf -> Maybe StackEnv

-- | Projects paths
projectEnv :: FilePath -> GhcM StackEnv

-- | Get package-db stack for stack environment
stackPackageDbStack :: Lens' StackEnv PackageDbStack

-- | Get compiler version
stackCompiler :: GhcM String

-- | Get arch for stack
stackArch :: String

-- | The parameterizable maybe monad, obtained by composing an arbitrary
--   monad with the <a>Maybe</a> monad.
--   
--   Computations are actions that may produce a value or exit.
--   
--   The <a>return</a> function yields a computation that produces that
--   value, while <tt>&gt;&gt;=</tt> sequences two subcomputations, exiting
--   if either computation does.
newtype MaybeT (m :: * -> *) a :: (* -> *) -> * -> *
MaybeT :: m Maybe a -> MaybeT a
[runMaybeT] :: MaybeT a -> m Maybe a

module HsDev.Scan.Browse

-- | Browse packages
browsePackages :: [String] -> PackageDbStack -> GhcM [PackageConfig]

-- | Get packages with deps
browsePackagesDeps :: [String] -> PackageDbStack -> GhcM (Deps PackageConfig)

-- | List modules from ghc, accepts ghc-opts, stack of package-db to get
--   modules for and list of packages to explicitely expose them with
--   '-package' flag, otherwise hidden packages won't be loaded
listModules :: [String] -> PackageDbStack -> [ModulePackage] -> GhcM [ModuleLocation]

-- | Like <tt>browseModules</tt>, but groups modules by package and
--   inspects each package separately Trying to fix error: when there are
--   several same packages (of different version), only <tt>Module</tt>
--   from one of them can be lookuped and therefore modules from different
--   version packages won't be actually inspected
browseModules :: [String] -> PackageDbStack -> [ModuleLocation] -> GhcM [InspectedModule]

-- | Inspect installed modules, doesn't set session and package flags!
browseModules' :: [String] -> [ModuleLocation] -> GhcM [InspectedModule]
readPackage :: PackageConfig -> ModulePackage
readPackageConfig :: PackageConfig -> PackageConfig
ghcModuleLocation :: PackageConfig -> Module -> ModuleLocation
packageConfigs :: GhcM [PackageConfig]
packageDbModules :: GhcM [(PackageConfig, Module)]
lookupModule_ :: DynFlags -> ModuleName -> [Module]

-- | Get modules packages
modulesPackages :: [ModuleLocation] -> [ModulePackage]

-- | Group modules by packages
modulesPackagesGroups :: [ModuleLocation] -> [(ModulePackage, [ModuleLocation])]

-- | Run action for each package with prepared '-package' flags
withEachPackage :: (ModulePackage -> [ModuleLocation] -> GhcM a) -> [ModuleLocation] -> GhcM [a]

module HsDev.Tools.HDocs

-- | Get docs for modules
hdocsy :: PackageDbStack -> [ModuleLocation] -> [String] -> GhcM [Map String String]

-- | Get docs for module
hdocs :: PackageDbStack -> ModuleLocation -> [String] -> GhcM (Map String String)

-- | Get docs for package
hdocsPackage :: PackageConfig -> GhcM (Map Text (Map Text Text))

-- | Get all docs
hdocsCabal :: PackageDbStack -> [String] -> GhcM [(ModulePackage, (Map Text (Map Text Text)))]

-- | Set docs for module
setSymbolDocs :: MonadIO m => LookupTable (Text, Text) (Maybe Text) -> Map Text Text -> Symbol -> m Symbol

-- | Set docs for module symbols
setDocs :: MonadIO m => LookupTable (Text, Text) (Maybe Text) -> Map Text Text -> Module -> m Module

-- | Set docs for modules
setModuleDocs :: MonadIO m => LookupTable (Text, Text) (Maybe Text) -> Map Text (Map Text Text) -> Module -> m Module
hdocsProcess :: String -> [String] -> IO (Maybe (Map String String))

-- | Read docs for one module
readDocs :: Text -> [String] -> Path -> GhcM (Maybe (Map String String))

-- | Read docs for one module
readModuleDocs :: [String] -> Module -> GhcM (Maybe (Map String String))
readProjectTargetDocs :: [String] -> Project -> [Path] -> GhcM (Map String (Map String String))
hdocsSupported :: Bool

module HsDev.Sandbox
data SandboxType
CabalSandbox :: SandboxType
StackWork :: SandboxType
data Sandbox
Sandbox :: SandboxType -> Path -> Sandbox
[_sandboxType] :: Sandbox -> SandboxType
[_sandbox] :: Sandbox -> Path
sandboxType :: Lens' Sandbox SandboxType
sandbox :: Lens' Sandbox Path
isSandbox :: Path -> Bool
guessSandboxType :: Path -> Maybe SandboxType
sandboxFromPath :: Path -> Maybe Sandbox

-- | Find sandbox in path
findSandbox :: Path -> IO (Maybe Sandbox)

-- | Search sandbox by parent directory
searchSandbox :: Path -> IO (Maybe Sandbox)

-- | Get project sandbox: search up for .cabal, then search for stack.yaml
--   in current directory and cabal sandbox in current + parents
projectSandbox :: Path -> IO (Maybe Sandbox)

-- | Get package-db stack for sandbox
sandboxPackageDbStack :: Sandbox -> GhcM PackageDbStack

-- | Search package-db stack with user-db as default
searchPackageDbStack :: Path -> GhcM PackageDbStack

-- | Restore package-db stack by package-db
restorePackageDbStack :: PackageDb -> GhcM PackageDbStack

-- | User package-db: <a>arch</a>-<a>os</a>-<a>version</a>
userPackageDb :: GhcM FilePath

-- | Get sandbox package-db:
--   <a>arch</a>-<a>os</a>-<a>compiler</a>-<a>version</a>-packages.conf.d
cabalSandboxPackageDb :: FilePath -> GhcM FilePath

-- | Options for GHC for module and project
getModuleOpts :: [String] -> Module -> GhcM (PackageDbStack, [String])

-- | Options for GHC for project target
getProjectTargetOpts :: [String] -> Project -> Info -> GhcM (PackageDbStack, [String])

-- | Get sandbox of project (if any)
getProjectSandbox :: MonadLog m => Project -> m (Maybe Sandbox)

-- | Get project package-db stack
getProjectPackageDbStack :: Project -> GhcM PackageDbStack
instance Control.DeepSeq.NFData HsDev.Sandbox.SandboxType
instance Control.DeepSeq.NFData HsDev.Sandbox.Sandbox
instance GHC.Show.Show HsDev.Sandbox.Sandbox
instance HsDev.Display.Display HsDev.Sandbox.Sandbox
instance Text.Format.Formattable HsDev.Sandbox.Sandbox
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Sandbox.Sandbox
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Sandbox.Sandbox
instance System.Directory.Paths.Paths HsDev.Sandbox.Sandbox
instance GHC.Classes.Ord HsDev.Sandbox.Sandbox
instance GHC.Classes.Eq HsDev.Sandbox.Sandbox
instance GHC.Enum.Bounded HsDev.Sandbox.SandboxType
instance GHC.Enum.Enum HsDev.Sandbox.SandboxType
instance GHC.Show.Show HsDev.Sandbox.SandboxType
instance GHC.Read.Read HsDev.Sandbox.SandboxType
instance GHC.Classes.Ord HsDev.Sandbox.SandboxType
instance GHC.Classes.Eq HsDev.Sandbox.SandboxType

module HsDev.Tools.Ghc.Session

-- | Session for module
targetSession :: [String] -> Module -> GhcM ()

-- | Interpret file
interpretModule :: Module -> Maybe Text -> GhcM ()

module HsDev.Database.SQLite.Instances
newtype JSON a
JSON :: a -> JSON a
[getJSON] :: JSON a -> a
instance GHC.Show.Show a => GHC.Show.Show (HsDev.Database.SQLite.Instances.JSON a)
instance GHC.Read.Read a => GHC.Read.Read (HsDev.Database.SQLite.Instances.JSON a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (HsDev.Database.SQLite.Instances.JSON a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (HsDev.Database.SQLite.Instances.JSON a)
instance Data.Aeson.Types.ToJSON.ToJSON a => Database.SQLite.Simple.ToField.ToField (HsDev.Database.SQLite.Instances.JSON a)
instance Data.Aeson.Types.FromJSON.FromJSON a => Database.SQLite.Simple.FromField.FromField (HsDev.Database.SQLite.Instances.JSON a)
instance Database.SQLite.Simple.ToField.ToField Data.Aeson.Types.Internal.Value
instance Database.SQLite.Simple.FromField.FromField Data.Aeson.Types.Internal.Value
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Symbols.Location.Position
instance Database.SQLite.Simple.ToRow.ToRow HsDev.Symbols.Location.Position
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Symbols.Location.Region
instance Database.SQLite.Simple.ToRow.ToRow HsDev.Symbols.Location.Region
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Symbols.Location.ModulePackage
instance Database.SQLite.Simple.ToRow.ToRow HsDev.Symbols.Location.ModulePackage
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Symbols.Location.ModuleLocation
instance Database.SQLite.Simple.ToRow.ToRow HsDev.Symbols.Location.ModuleLocation
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Symbols.Location.ModuleId
instance Database.SQLite.Simple.ToRow.ToRow HsDev.Symbols.Location.ModuleId
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Symbols.Location.SymbolId
instance Database.SQLite.Simple.ToRow.ToRow HsDev.Symbols.Location.SymbolId
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Symbols.Types.SymbolInfo
instance Database.SQLite.Simple.ToRow.ToRow HsDev.Symbols.Types.SymbolInfo
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Symbols.Types.Symbol
instance Database.SQLite.Simple.ToRow.ToRow HsDev.Symbols.Types.Symbol
instance Database.SQLite.Simple.FromRow.FromRow a => Database.SQLite.Simple.FromRow.FromRow (HsDev.Symbols.Types.Scoped a)
instance Database.SQLite.Simple.ToRow.ToRow a => Database.SQLite.Simple.ToRow.ToRow (HsDev.Symbols.Types.Scoped a)
instance Database.SQLite.Simple.ToRow.ToRow HsDev.Project.Types.Project
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Project.Types.Project
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Project.Types.Library
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Project.Types.Executable
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Project.Types.Test
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Project.Types.Info
instance Database.SQLite.Simple.FromField.FromField Language.Haskell.Extension.Language
instance Database.SQLite.Simple.ToField.ToField HsDev.PackageDb.Types.PackageDb
instance Database.SQLite.Simple.FromField.FromField HsDev.PackageDb.Types.PackageDb
instance Database.SQLite.Simple.ToField.ToField HsDev.PackageDb.Types.PackageDbStack
instance Database.SQLite.Simple.FromField.FromField HsDev.PackageDb.Types.PackageDbStack
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Symbols.Types.SymbolUsage
instance Database.SQLite.Simple.FromField.FromField Data.Time.Clock.Internal.POSIXTime.POSIXTime
instance Database.SQLite.Simple.ToField.ToField Data.Time.Clock.Internal.POSIXTime.POSIXTime
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Symbols.Types.Inspection
instance Database.SQLite.Simple.ToRow.ToRow HsDev.Symbols.Types.Inspection
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Tools.Ghc.Types.TypedExpr
instance Database.SQLite.Simple.ToRow.ToRow HsDev.Tools.Ghc.Types.TypedExpr
instance Database.SQLite.Simple.FromField.FromField (Language.Haskell.Exts.Syntax.Name ())
instance Database.SQLite.Simple.ToField.ToField (Language.Haskell.Exts.Syntax.Name ())
instance Database.SQLite.Simple.FromField.FromField (Language.Haskell.Exts.Syntax.ModuleName ())
instance Database.SQLite.Simple.ToField.ToField (Language.Haskell.Exts.Syntax.ModuleName ())
instance Database.SQLite.Simple.FromRow.FromRow Language.Haskell.Names.Types.Symbol
instance Database.SQLite.Simple.ToRow.ToRow Language.Haskell.Names.Types.Symbol
instance Database.SQLite.Simple.FromField.FromField HsDev.Tools.Types.Severity
instance Database.SQLite.Simple.ToField.ToField HsDev.Tools.Types.Severity
instance Database.SQLite.Simple.FromRow.FromRow HsDev.Tools.Types.OutputMessage
instance Database.SQLite.Simple.ToRow.ToRow HsDev.Tools.Types.OutputMessage
instance Database.SQLite.Simple.FromRow.FromRow a => Database.SQLite.Simple.FromRow.FromRow (HsDev.Tools.Types.Note a)
instance Database.SQLite.Simple.ToRow.ToRow a => Database.SQLite.Simple.ToRow.ToRow (HsDev.Tools.Types.Note a)

module System.Directory.Watcher

-- | Event type
data EventType
Added :: EventType
Modified :: EventType
Removed :: EventType

-- | Event
data Event
Event :: EventType -> FilePath -> POSIXTime -> Event
[_eventType] :: Event -> EventType
[_eventPath] :: Event -> FilePath
[_eventTime] :: Event -> POSIXTime
eventType :: Lens' Event EventType
eventPath :: Lens' Event FilePath
eventTime :: Lens' Event POSIXTime

-- | Directories watcher
data Watcher a
Watcher :: MVar (Map FilePath (Bool, IO ())) -> WatchManager -> Chan (a, Event) -> Watcher a

-- | Map from directory to watch stopper
[watcherDirs] :: Watcher a -> MVar (Map FilePath (Bool, IO ()))
[watcherMan] :: Watcher a -> WatchManager
[watcherChan] :: Watcher a -> Chan (a, Event)

-- | Create watcher
withWatcher :: (Watcher a -> IO b) -> IO b

-- | Watch directory
watchDir :: Watcher a -> FilePath -> (Event -> Bool) -> a -> IO ()
watchDir_ :: Watcher () -> FilePath -> (Event -> Bool) -> IO ()

-- | Unwatch directory, return <tt>False</tt>, if not watched
unwatchDir :: Watcher a -> FilePath -> IO Bool

-- | Check if we are watching dir
isWatchingDir :: Watcher a -> FilePath -> IO Bool

-- | Watch directory tree
watchTree :: Watcher a -> FilePath -> (Event -> Bool) -> a -> IO ()
watchTree_ :: Watcher () -> FilePath -> (Event -> Bool) -> IO ()

-- | Unwatch directory tree
unwatchTree :: Watcher a -> FilePath -> IO Bool

-- | Check if we are watching tree
isWatchingTree :: Watcher a -> FilePath -> IO Bool

-- | Read next event
readEvent :: Watcher a -> IO (a, Event)

-- | Get event group
eventGroup :: Watcher a -> NominalDiffTime -> ([(a, Event)] -> IO ()) -> IO ()

-- | Process all events
onEvents :: Watcher a -> NominalDiffTime -> ([(a, Event)] -> IO ()) -> IO ()

-- | Process all events
onEvents_ :: Watcher a -> ([(a, Event)] -> IO ()) -> IO ()
instance GHC.Show.Show System.Directory.Watcher.Event
instance GHC.Classes.Ord System.Directory.Watcher.Event
instance GHC.Classes.Eq System.Directory.Watcher.Event
instance GHC.Show.Show System.Directory.Watcher.EventType
instance GHC.Read.Read System.Directory.Watcher.EventType
instance GHC.Enum.Bounded System.Directory.Watcher.EventType
instance GHC.Enum.Enum System.Directory.Watcher.EventType
instance GHC.Classes.Ord System.Directory.Watcher.EventType
instance GHC.Classes.Eq System.Directory.Watcher.EventType

module HsDev.Watcher.Types
data Watched
WatchedProject :: Project -> [String] -> Watched
WatchedPackageDb :: PackageDbStack -> [String] -> Watched
WatchedModule :: Watched
type Watcher = Watcher Watched

-- | Stack of PackageDb in reverse order
data PackageDbStack

-- | Cabal project
data Project

module HsDev.Server.Types
type ServerMonadBase m = (MonadIO m, MonadMask m, MonadBaseControl IO m, Alternative m, MonadPlus m)
data SessionLog
SessionLog :: Log -> IO [Message] -> IO () -> SessionLog
[sessionLogger] :: SessionLog -> Log
[sessionListenLog] :: SessionLog -> IO [Message]
[sessionLogWait] :: SessionLog -> IO ()
data Session
Session :: Connection -> String -> SessionLog -> Watcher -> (Path -> Maybe Text -> IO ()) -> GhcWorker -> Worker (ServerM IO) -> IO () -> IO () -> Chan (IO ()) -> [(String, String)] -> Session
[sessionSqlDatabase] :: Session -> Connection
[sessionSqlPath] :: Session -> String
[sessionLog] :: Session -> SessionLog
[sessionWatcher] :: Session -> Watcher
[sessionFileContents] :: Session -> Path -> Maybe Text -> IO ()
[sessionGhc] :: Session -> GhcWorker
[sessionUpdater] :: Session -> Worker (ServerM IO)
[sessionExit] :: Session -> IO ()
[sessionWait] :: Session -> IO ()
[sessionClients] :: Session -> Chan (IO ())
[sessionDefines] :: Session -> [(String, String)]
class (ServerMonadBase m, MonadLog m) => SessionMonad m
getSession :: SessionMonad m => m Session
localSession :: SessionMonad m => (Session -> Session) -> m a -> m a
askSession :: SessionMonad m => (Session -> a) -> m a
newtype ServerM m a
ServerM :: ReaderT Session m a -> ServerM m a
[runServerM] :: ServerM m a -> ReaderT Session m a
data CommandOptions
CommandOptions :: FilePath -> (Notification -> IO ()) -> IO () -> IO () -> CommandOptions
[commandOptionsRoot] :: CommandOptions -> FilePath
[commandOptionsNotify] :: CommandOptions -> Notification -> IO ()
[commandOptionsLink] :: CommandOptions -> IO ()
[commandOptionsHold] :: CommandOptions -> IO ()
class (SessionMonad m, MonadPlus m) => CommandMonad m
getOptions :: CommandMonad m => m CommandOptions
askOptions :: CommandMonad m => (CommandOptions -> a) -> m a
newtype ClientM m a
ClientM :: ServerM (ReaderT CommandOptions m) a -> ClientM m a
[runClientM] :: ClientM m a -> ServerM (ReaderT CommandOptions m) a

-- | Run action on session
withSession :: Session -> ServerM m a -> m a

-- | Listen server's log
serverListen :: SessionMonad m => m [Message]

-- | Set server's log config
serverSetLogLevel :: SessionMonad m => Level -> m Level

-- | Wait for server
serverWait :: SessionMonad m => m ()

-- | Wait while clients disconnects
serverWaitClients :: SessionMonad m => m ()

-- | Get sql connection
serverSqlDatabase :: SessionMonad m => m Connection

-- | Open new sql connection
openSqlConnection :: SessionMonad m => m Connection

-- | Close sql connection
closeSqlConnection :: SessionMonad m => Connection -> m ()

-- | Locally opens new connection, updating <tt>Session</tt>
withSqlConnection :: SessionMonad m => m a -> m a

-- | With sql transaction
withSqlTransaction :: SessionMonad m => ServerM IO a -> m a

-- | Set custom file contents
serverSetFileContents :: SessionMonad m => Path -> Maybe Text -> m ()

-- | In ghc session
inSessionGhc :: SessionMonad m => GhcM a -> m a

-- | In updater
inSessionUpdater :: SessionMonad m => ServerM IO a -> m a

-- | Post to updater and return
postSessionUpdater :: SessionMonad m => ServerM IO a -> m (Async a)

-- | Exit session
serverExit :: SessionMonad m => m ()
commandRoot :: CommandMonad m => m FilePath
commandNotify :: CommandMonad m => Notification -> m ()
commandLink :: CommandMonad m => m ()
commandHold :: CommandMonad m => m ()

-- | Server control command
data ServerCommand
Version :: ServerCommand
Start :: ServerOpts -> ServerCommand
Run :: ServerOpts -> ServerCommand
Stop :: ClientOpts -> ServerCommand
Connect :: ClientOpts -> ServerCommand
Remote :: ClientOpts -> Bool -> Command -> ServerCommand
data ConnectionPort
NetworkPort :: Int -> ConnectionPort
UnixPort :: String -> ConnectionPort

-- | Server options
data ServerOpts
ServerOpts :: ConnectionPort -> Int -> Maybe FilePath -> String -> Maybe FilePath -> Bool -> ServerOpts
[serverPort] :: ServerOpts -> ConnectionPort
[serverTimeout] :: ServerOpts -> Int
[serverLog] :: ServerOpts -> Maybe FilePath
[serverLogLevel] :: ServerOpts -> String
[serverDbFile] :: ServerOpts -> Maybe FilePath
[serverSilent] :: ServerOpts -> Bool

-- | Silent server with no connection, useful for ghci
silentOpts :: ServerOpts

-- | Client options
data ClientOpts
ClientOpts :: ConnectionPort -> Bool -> Bool -> Int -> Bool -> ClientOpts
[clientPort] :: ClientOpts -> ConnectionPort
[clientPretty] :: ClientOpts -> Bool
[clientStdin] :: ClientOpts -> Bool
[clientTimeout] :: ClientOpts -> Int
[clientSilent] :: ClientOpts -> Bool
serverOptsArgs :: ServerOpts -> [String]
data Request
Request :: Command -> FilePath -> Bool -> Int -> Bool -> Request
[requestCommand] :: Request -> Command
[requestDirectory] :: Request -> FilePath
[requestNoFile] :: Request -> Bool
[requestTimeout] :: Request -> Int
[requestSilent] :: Request -> Bool

-- | Command from client
data Command
Ping :: Command
Listen :: (Maybe String) -> Command
SetLogLevel :: String -> Command
Scan :: [Path] -> Bool -> [Path] -> [FileSource] -> [Path] -> [String] -> Bool -> Bool -> Command
[scanProjects] :: Command -> [Path]
[scanCabal] :: Command -> Bool
[scanSandboxes] :: Command -> [Path]
[scanFiles] :: Command -> [FileSource]
[scanPaths] :: Command -> [Path]
[scanGhcOpts] :: Command -> [String]
[scanDocs] :: Command -> Bool
[scanInferTypes] :: Command -> Bool
SetFileContents :: Path -> (Maybe Text) -> Command
RefineDocs :: [Path] -> [Path] -> Command
[docsProjects] :: Command -> [Path]
[docsFiles] :: Command -> [Path]
InferTypes :: [Path] -> [Path] -> Command
[inferProjects] :: Command -> [Path]
[inferFiles] :: Command -> [Path]
Remove :: [Path] -> Bool -> [Path] -> [Path] -> Command
[removeProjects] :: Command -> [Path]
[removeCabal] :: Command -> Bool
[removeSandboxes] :: Command -> [Path]
[removeFiles] :: Command -> [Path]
RemoveAll :: Command
InfoPackages :: Command
InfoProjects :: Command
InfoSandboxes :: Command
InfoSymbol :: SearchQuery -> [TargetFilter] -> Bool -> Bool -> Command
InfoModule :: SearchQuery -> [TargetFilter] -> Bool -> Bool -> Command
InfoProject :: (Either Text Path) -> Command
InfoSandbox :: Path -> Command
Lookup :: Text -> Path -> Command
Whois :: Text -> Path -> Command
Whoat :: Int -> Int -> Path -> Command
ResolveScopeModules :: SearchQuery -> Path -> Command
ResolveScope :: SearchQuery -> Path -> Command
FindUsages :: Int -> Int -> Path -> Command
Complete :: Text -> Bool -> Path -> Command
Hayoo :: String -> Int -> Int -> Command
[hayooQuery] :: Command -> String
[hayooPage] :: Command -> Int
[hayooPages] :: Command -> Int
CabalList :: [Text] -> Command
[cabalListPackages] :: Command -> [Text]
UnresolvedSymbols :: [Path] -> Command
[unresolvedFiles] :: Command -> [Path]
Lint :: [FileSource] -> Command
[lintFiles] :: Command -> [FileSource]
Check :: [FileSource] -> [String] -> Bool -> Command
[checkFiles] :: Command -> [FileSource]
[checkGhcOpts] :: Command -> [String]
[checkClear] :: Command -> Bool
CheckLint :: [FileSource] -> [String] -> Bool -> Command
[checkLintFiles] :: Command -> [FileSource]
[checkLintGhcOpts] :: Command -> [String]
[checkLinkClear] :: Command -> Bool
Types :: [FileSource] -> [String] -> Bool -> Command
[typesFiles] :: Command -> [FileSource]
[typesGhcOpts] :: Command -> [String]
[typesClear] :: Command -> Bool
AutoFix :: [Note OutputMessage] -> Command
Refactor :: [Note Refact] -> [Note Refact] -> Bool -> Command
Rename :: Text -> Text -> Path -> Command
GhcEval :: [String] -> Maybe FileSource -> Command
[ghcEvalExpressions] :: Command -> [String]
[ghcEvalSource] :: Command -> Maybe FileSource
GhcType :: [String] -> Maybe FileSource -> Command
[ghcTypeExpressions] :: Command -> [String]
[ghcTypeSource] :: Command -> Maybe FileSource
Langs :: Command
Flags :: Command
Link :: Bool -> Command
[linkHold] :: Command -> Bool
StopGhc :: Command
Exit :: Command
data FileSource
FileSource :: Path -> Maybe Text -> FileSource
[fileSource] :: FileSource -> Path
[fileContents] :: FileSource -> Maybe Text
data TargetFilter
TargetProject :: Text -> TargetFilter
TargetFile :: Path -> TargetFilter
TargetModule :: Text -> TargetFilter
TargetPackage :: Text -> TargetFilter
TargetInstalled :: TargetFilter
TargetSourced :: TargetFilter
TargetStandalone :: TargetFilter
data SearchQuery
SearchQuery :: Text -> SearchType -> SearchQuery
data SearchType
SearchExact :: SearchType
SearchPrefix :: SearchType
SearchInfix :: SearchType
SearchSuffix :: SearchType
class FromCmd a
cmdP :: FromCmd a => Parser a
instance GHC.Show.Show HsDev.Server.Types.ServerCommand
instance GHC.Show.Show HsDev.Server.Types.Request
instance GHC.Show.Show HsDev.Server.Types.Command
instance GHC.Show.Show HsDev.Server.Types.SearchQuery
instance GHC.Show.Show HsDev.Server.Types.SearchType
instance GHC.Show.Show HsDev.Server.Types.TargetFilter
instance GHC.Classes.Eq HsDev.Server.Types.TargetFilter
instance GHC.Show.Show HsDev.Server.Types.FileSource
instance GHC.Show.Show HsDev.Server.Types.ClientOpts
instance GHC.Show.Show HsDev.Server.Types.ServerOpts
instance GHC.Read.Read HsDev.Server.Types.ConnectionPort
instance GHC.Classes.Eq HsDev.Server.Types.ConnectionPort
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (HsDev.Server.Types.ClientM m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (HsDev.Server.Types.ClientM m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (HsDev.Server.Types.ClientM m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (HsDev.Server.Types.ClientM m)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (HsDev.Server.Types.ClientM m)
instance GHC.Base.Monad m => GHC.Base.Monad (HsDev.Server.Types.ClientM m)
instance GHC.Base.Alternative m => GHC.Base.Alternative (HsDev.Server.Types.ClientM m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (HsDev.Server.Types.ClientM m)
instance GHC.Base.Functor m => GHC.Base.Functor (HsDev.Server.Types.ClientM m)
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (HsDev.Server.Types.ServerM m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (HsDev.Server.Types.ServerM m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (HsDev.Server.Types.ServerM m)
instance Control.Monad.Trans.Class.MonadTrans HsDev.Server.Types.ServerM
instance GHC.Base.Monad m => Control.Monad.Reader.Class.MonadReader HsDev.Server.Types.Session (HsDev.Server.Types.ServerM m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (HsDev.Server.Types.ServerM m)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (HsDev.Server.Types.ServerM m)
instance GHC.Base.Monad m => GHC.Base.Monad (HsDev.Server.Types.ServerM m)
instance GHC.Base.Alternative m => GHC.Base.Alternative (HsDev.Server.Types.ServerM m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (HsDev.Server.Types.ServerM m)
instance GHC.Base.Functor m => GHC.Base.Functor (HsDev.Server.Types.ServerM m)
instance HsDev.Util.FromCmd HsDev.Server.Types.ServerCommand
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Server.Types.Request
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Server.Types.Request
instance System.Directory.Paths.Paths HsDev.Server.Types.Command
instance HsDev.Util.FromCmd HsDev.Server.Types.Command
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Server.Types.Command
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Server.Types.Command
instance HsDev.Util.FromCmd HsDev.Server.Types.SearchQuery
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Server.Types.SearchQuery
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Server.Types.SearchQuery
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Server.Types.SearchType
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Server.Types.SearchType
instance System.Directory.Paths.Paths HsDev.Server.Types.TargetFilter
instance HsDev.Util.FromCmd HsDev.Server.Types.TargetFilter
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Server.Types.TargetFilter
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Server.Types.TargetFilter
instance System.Directory.Paths.Paths HsDev.Server.Types.FileSource
instance HsDev.Util.FromCmd HsDev.Server.Types.FileSource
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Server.Types.FileSource
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Server.Types.FileSource
instance Data.Default.Class.Default HsDev.Server.Types.ClientOpts
instance HsDev.Util.FromCmd HsDev.Server.Types.ClientOpts
instance Data.Default.Class.Default HsDev.Server.Types.ServerOpts
instance HsDev.Util.FromCmd HsDev.Server.Types.ServerOpts
instance Data.Default.Class.Default HsDev.Server.Types.ConnectionPort
instance GHC.Show.Show HsDev.Server.Types.ConnectionPort
instance Text.Format.Formattable HsDev.Server.Types.ConnectionPort
instance Control.Monad.Trans.Class.MonadTrans HsDev.Server.Types.ClientM
instance (Control.Monad.IO.Class.MonadIO m, Control.Monad.Catch.MonadMask m) => System.Log.Simple.Monad.MonadLog (HsDev.Server.Types.ClientM m)
instance HsDev.Server.Types.ServerMonadBase m => HsDev.Server.Types.SessionMonad (HsDev.Server.Types.ClientM m)
instance HsDev.Server.Types.ServerMonadBase m => HsDev.Server.Types.CommandMonad (HsDev.Server.Types.ClientM m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (HsDev.Server.Types.ClientM m)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (HsDev.Server.Types.ClientM m)
instance Control.Monad.Morph.MFunctor HsDev.Server.Types.ClientM
instance HsDev.Server.Types.CommandMonad m => HsDev.Server.Types.CommandMonad (Control.Monad.Trans.Reader.ReaderT r m)
instance (HsDev.Server.Types.CommandMonad m, GHC.Base.Monoid w) => HsDev.Server.Types.CommandMonad (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance HsDev.Server.Types.CommandMonad m => HsDev.Server.Types.CommandMonad (Control.Monad.Trans.State.Lazy.StateT s m)
instance Data.Default.Class.Default HsDev.Server.Types.CommandOptions
instance HsDev.Server.Types.ServerMonadBase m => HsDev.Server.Types.SessionMonad (HsDev.Server.Types.ServerM m)
instance HsDev.Server.Types.SessionMonad m => HsDev.Server.Types.SessionMonad (Control.Monad.Trans.Reader.ReaderT r m)
instance (HsDev.Server.Types.SessionMonad m, GHC.Base.Monoid w) => HsDev.Server.Types.SessionMonad (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance HsDev.Server.Types.SessionMonad m => HsDev.Server.Types.SessionMonad (Control.Monad.Trans.State.Lazy.StateT s m)
instance (Control.Monad.IO.Class.MonadIO m, Control.Monad.Catch.MonadMask m) => System.Log.Simple.Monad.MonadLog (HsDev.Server.Types.ServerM m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (HsDev.Server.Types.ServerM m)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (HsDev.Server.Types.ServerM m)
instance Control.Monad.Morph.MFunctor HsDev.Server.Types.ServerM

module HsDev.Database.Update.Types
data Status
StatusWorking :: Status
StatusOk :: Status
StatusError :: HsDevError -> Status
data Progress
Progress :: Int -> Int -> Progress
[progressCurrent] :: Progress -> Int
[progressTotal] :: Progress -> Int
data Task
Task :: String -> Status -> String -> String -> Maybe Progress -> Task
[_taskName] :: Task -> String
[_taskStatus] :: Task -> Status
[_taskSubjectType] :: Task -> String
[_taskSubjectName] :: Task -> String
[_taskProgress] :: Task -> Maybe Progress
data UpdateOptions
UpdateOptions :: [Task] -> [String] -> Bool -> Bool -> UpdateOptions
[_updateTasks] :: UpdateOptions -> [Task]
[_updateGhcOpts] :: UpdateOptions -> [String]
[_updateDocs] :: UpdateOptions -> Bool
[_updateInfer] :: UpdateOptions -> Bool
updateTasks :: Lens' UpdateOptions [Task]
updateGhcOpts :: Lens' UpdateOptions [String]
updateDocs :: Lens' UpdateOptions Bool
updateInfer :: Lens' UpdateOptions Bool
data UpdateState
UpdateState :: UpdateOptions -> Worker (ServerM IO) -> UpdateState
[_updateOptions] :: UpdateState -> UpdateOptions
[_updateWorker] :: UpdateState -> Worker (ServerM IO)
updateOptions :: Lens' UpdateState UpdateOptions
updateWorker :: Lens' UpdateState (Worker (ServerM IO))
withUpdateState :: SessionMonad m => UpdateOptions -> (UpdateState -> m a) -> m a
sendUpdateAction :: UpdateMonad m => ServerM IO () -> m ()
newtype UpdateM m a
UpdateM :: ReaderT UpdateState (WriterT [ModuleLocation] (ClientM m)) a -> UpdateM m a
[runUpdateM] :: UpdateM m a -> ReaderT UpdateState (WriterT [ModuleLocation] (ClientM m)) a
type UpdateMonad m = (CommandMonad m, MonadReader UpdateState m, MonadWriter [ModuleLocation] m)
taskName :: Lens' Task String
taskStatus :: Lens' Task Status
taskSubjectType :: Lens' Task String
taskSubjectName :: Lens' Task String
taskProgress :: Lens' Task (Maybe Progress)
instance GHC.Base.Monad m => Control.Monad.Writer.Class.MonadWriter [HsDev.Symbols.Location.ModuleLocation] (HsDev.Database.Update.Types.UpdateM m)
instance GHC.Base.Monad m => Control.Monad.Reader.Class.MonadReader HsDev.Database.Update.Types.UpdateState (HsDev.Database.Update.Types.UpdateM m)
instance GHC.Base.Functor m => GHC.Base.Functor (HsDev.Database.Update.Types.UpdateM m)
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (HsDev.Database.Update.Types.UpdateM m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (HsDev.Database.Update.Types.UpdateM m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (HsDev.Database.Update.Types.UpdateM m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (HsDev.Database.Update.Types.UpdateM m)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (HsDev.Database.Update.Types.UpdateM m)
instance GHC.Base.Monad m => GHC.Base.Monad (HsDev.Database.Update.Types.UpdateM m)
instance GHC.Base.Alternative m => GHC.Base.Alternative (HsDev.Database.Update.Types.UpdateM m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (HsDev.Database.Update.Types.UpdateM m)
instance Control.Monad.Trans.Class.MonadTrans HsDev.Database.Update.Types.UpdateM
instance (Control.Monad.IO.Class.MonadIO m, Control.Monad.Catch.MonadMask m) => System.Log.Simple.Monad.MonadLog (HsDev.Database.Update.Types.UpdateM m)
instance HsDev.Server.Types.ServerMonadBase m => HsDev.Server.Types.SessionMonad (HsDev.Database.Update.Types.UpdateM m)
instance HsDev.Server.Types.ServerMonadBase m => HsDev.Server.Types.CommandMonad (HsDev.Database.Update.Types.UpdateM m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (HsDev.Database.Update.Types.UpdateM m)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (HsDev.Database.Update.Types.UpdateM m)
instance Data.Default.Class.Default HsDev.Database.Update.Types.UpdateOptions
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Database.Update.Types.Task
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Database.Update.Types.Task
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Database.Update.Types.Progress
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Database.Update.Types.Progress
instance Data.Aeson.Types.ToJSON.ToJSON HsDev.Database.Update.Types.Status
instance Data.Aeson.Types.FromJSON.FromJSON HsDev.Database.Update.Types.Status

module HsDev.Database.SQLite.Transaction

-- | Three types of transactions
data TransactionType
Deferred :: TransactionType
Immediate :: TransactionType
Exclusive :: TransactionType

-- | Retry config
data Retries
Retries :: [Int] -> (SQLError -> Bool) -> Retries
[retriesIntervals] :: Retries -> [Int]
[retriesError] :: Retries -> SQLError -> Bool

-- | The default value for this type.
def :: Default a => a

-- | Don't retry
noRetry :: Retries

-- | Retry forever
retryForever :: Int -> Retries

-- | Retry with interval N times
retryN :: Int -> Int -> Retries

-- | Run actions inside transaction
withTransaction :: (MonadIO m, MonadMask m) => Connection -> TransactionType -> Retries -> m a -> m a

-- | Begin transaction
beginTransaction :: MonadIO m => Connection -> TransactionType -> m ()

-- | Commit transaction
commitTransaction :: MonadIO m => Connection -> m ()

-- | Rollback transaction
rollbackTransaction :: MonadIO m => Connection -> m ()

-- | Run transaction in <tt>SessionMonad</tt>
transaction :: SessionMonad m => TransactionType -> Retries -> m a -> m a

-- | Transaction with default retries config
transaction_ :: SessionMonad m => TransactionType -> m a -> m a

-- | Retry operation
retry :: (MonadIO m, MonadCatch m) => Retries -> m a -> m a

-- | Retry with default params
retry_ :: (MonadIO m, MonadCatch m) => m a -> m a
instance GHC.Show.Show HsDev.Database.SQLite.Transaction.TransactionType
instance GHC.Read.Read HsDev.Database.SQLite.Transaction.TransactionType
instance GHC.Classes.Ord HsDev.Database.SQLite.Transaction.TransactionType
instance GHC.Classes.Eq HsDev.Database.SQLite.Transaction.TransactionType
instance Data.Default.Class.Default HsDev.Database.SQLite.Transaction.Retries

module HsDev.Database.SQLite

-- | Initialize database
initialize :: String -> IO Connection
purge :: SessionMonad m => m ()

-- | Private memory for db
privateMemory :: String

-- | Shared db in memory
sharedMemory :: String
query :: (ToRow q, FromRow r, SessionMonad m) => Query -> q -> m [r]
query_ :: (FromRow r, SessionMonad m) => Query -> m [r]
queryNamed :: (FromRow r, SessionMonad m) => Query -> [NamedParam] -> m [r]
execute :: (ToRow q, SessionMonad m) => Query -> q -> m ()
execute_ :: SessionMonad m => Query -> m ()
executeMany :: (ToRow q, SessionMonad m) => Query -> [q] -> m ()
executeNamed :: SessionMonad m => Query -> [NamedParam] -> m ()
withTemporaryTable :: SessionMonad m => String -> [String] -> m a -> m a
updatePackageDb :: SessionMonad m => PackageDb -> [ModulePackage] -> m ()
removePackageDb :: SessionMonad m => PackageDb -> m ()
insertPackageDb :: SessionMonad m => PackageDb -> [ModulePackage] -> m ()
updateProject :: SessionMonad m => Project -> m ()
removeProject :: SessionMonad m => Project -> m ()
insertProject :: SessionMonad m => Project -> m ()
insertBuildInfo :: SessionMonad m => Info -> m Int
updateModule :: SessionMonad m => InspectedModule -> m ()
removeModuleContents :: SessionMonad m => Int -> m ()
removeModule :: SessionMonad m => Int -> m ()
insertModuleSymbols :: SessionMonad m => InspectedModule -> m ()
upsertModule :: SessionMonad m => InspectedModule -> m Int
lookupModuleLocation :: SessionMonad m => ModuleLocation -> m (Maybe Int)
lookupModule :: SessionMonad m => ModuleId -> m (Maybe Int)
lookupSymbol :: SessionMonad m => Int -> SymbolId -> m (Maybe Int)
lastRow :: SessionMonad m => m Int
loadModule :: SessionMonad m => Int -> m Module
loadModules :: (SessionMonad m, ToRow q) => String -> q -> m [Module]
loadProject :: SessionMonad m => Path -> m Project

-- | Update a bunch of modules
updateModules :: SessionMonad m => [InspectedModule] -> m ()
lookupId :: SessionMonad m => ModuleLocation -> m Int
escapeLike :: Text -> Text

module HsDev.Inspect.Resolve

-- | Load environment from sql
loadEnvironment :: SessionMonad m => Maybe Path -> m Environment

-- | Load fixities from sql
loadFixities :: SessionMonad m => Maybe Path -> m FixitiesTable

-- | Run with temporary table for environment
withEnv :: SessionMonad m => Maybe Path -> m a -> m a

-- | Try resolve module symbols
resolveModule :: MonadThrow m => Environment -> FixitiesTable -> Preloaded -> InspectM ModuleLocation ModuleTag m Resolved

-- | Resolve just preloaded part of module, this will give imports and
--   scope
resolvePreloaded :: MonadThrow m => Environment -> Preloaded -> InspectM ModuleLocation ModuleTag m Resolved

-- | Resolve parsed module
resolve :: Environment -> Module SrcSpanInfo -> Resolved

-- | Save results in sql, also updates temporary environment table
updateResolved :: SessionMonad m => InspectedResolved -> m ()

-- | Save results in sql, updated temporary env table
updateResolveds :: SessionMonad m => Maybe Path -> [InspectedResolved] -> m ()

module HsDev.Inspect

-- | Preload module - load head and imports to get actual extensions and
--   dependencies
preload :: (MonadIO m, MonadCatch m) => Text -> [(String, String)] -> [String] -> Maybe Text -> InspectM ModuleLocation ModuleTag m Preloaded
data AnalyzeEnv
AnalyzeEnv :: Environment -> Map Name Fixity -> RefineTable -> AnalyzeEnv
[_analyzeEnv] :: AnalyzeEnv -> Environment
[_analyzeFixities] :: AnalyzeEnv -> Map Name Fixity
[_analyzeRefine] :: AnalyzeEnv -> RefineTable
analyzeEnv :: Lens' AnalyzeEnv Environment
analyzeFixities :: Lens' AnalyzeEnv (Map Name Fixity)
analyzeRefine :: Lens' AnalyzeEnv RefineTable
moduleAnalyzeEnv :: Module -> AnalyzeEnv

-- | Resolve module imports<i>exports</i>scope
analyzeResolve :: AnalyzeEnv -> Module -> Module

-- | Inspect preloaded module
analyzePreloaded :: AnalyzeEnv -> Preloaded -> Either String Module

-- | Extract file docs and set them to module declarations
inspectDocs :: [String] -> Module -> GhcM Module

-- | Like <tt>inspectDocs</tt>, but in <tt>Ghc</tt> monad
inspectDocsGhc :: [String] -> Module -> GhcM Module

-- | Inspect contents
inspectContents :: Text -> [(String, String)] -> [String] -> Text -> IO InspectedModule
contentsInspection :: Text -> [String] -> IO Inspection

-- | Inspect file
inspectFile :: [(String, String)] -> [String] -> Path -> Maybe Project -> Maybe Text -> IO InspectedModule

-- | Source inspection data, differs whether there are contents provided
sourceInspection :: Path -> Maybe Text -> [String] -> IO Inspection

-- | File inspection data
fileInspection :: Path -> [String] -> IO Inspection

-- | File contents inspection data
fileContentsInspection :: [String] -> IO Inspection

-- | File contents inspection data
fileContentsInspection_ :: [String] -> POSIXTime -> Inspection

-- | Installed module inspection data, just opts
installedInspection :: [String] -> IO Inspection

-- | Inspection by module location
moduleInspection :: ModuleLocation -> [String] -> IO Inspection

-- | Enumerate project dirs
projectDirs :: Project -> IO [Extensions Path]

-- | Enumerate project source files
projectSources :: Project -> IO [Extensions Path]

-- | Get actual defines
getDefines :: IO [(String, String)]
preprocess :: [(String, String)] -> Path -> Text -> IO Text
preprocess_ :: [(String, String)] -> [String] -> Path -> Text -> IO Text
instance GHC.Base.Monoid HsDev.Inspect.AnalyzeEnv

module HsDev.Scan

-- | Compile flags
type CompileFlag = String

-- | Module with flags ready to scan
type ModuleToScan = (ModuleLocation, [CompileFlag], Maybe Text)

-- | Project ready to scan
type ProjectToScan = (Project, [ModuleToScan])

-- | Package-db sandbox to scan (top of stack)
type PackageDbToScan = PackageDbStack

-- | Scan info
data ScanContents
ScanContents :: [ModuleToScan] -> [ProjectToScan] -> [PackageDbStack] -> ScanContents
[modulesToScan] :: ScanContents -> [ModuleToScan]
[projectsToScan] :: ScanContents -> [ProjectToScan]
[sandboxesToScan] :: ScanContents -> [PackageDbStack]
class EnumContents a
enumContents :: (EnumContents a, CommandMonad m) => a -> m ScanContents

-- | Enum rescannable (i.e. already scanned) file
enumRescan :: CommandMonad m => FilePath -> m ScanContents

-- | Enum file dependent
enumDependent :: CommandMonad m => FilePath -> m ScanContents

-- | Enum project sources
enumProject :: CommandMonad m => Project -> m ScanContents

-- | Enum sandbox
enumSandbox :: CommandMonad m => Sandbox -> m ScanContents

-- | Enum directory modules
enumDirectory :: CommandMonad m => FilePath -> m ScanContents

-- | Scan project file
scanProjectFile :: CommandMonad m => [String] -> Path -> m Project

-- | Scan additional info and modify scanned module
scanModify :: CommandMonad m => ([String] -> Module -> m Module) -> InspectedModule -> m InspectedModule

-- | Is inspected module up to date?
upToDate :: SessionMonad m => ModuleLocation -> [String] -> Inspection -> m Bool

-- | Returns new (to scan) and changed (to rescan) modules
changedModules :: SessionMonad m => Map ModuleLocation Inspection -> [String] -> [ModuleToScan] -> m [ModuleToScan]

-- | Returns file contents if it was set and still actual
getFileContents :: SessionMonad m => Path -> m (Maybe (POSIXTime, Text))
instance HsDev.Scan.EnumContents HsDev.Symbols.Location.ModuleLocation
instance HsDev.Scan.EnumContents (HsDev.Project.Types.Extensions HsDev.Symbols.Location.ModuleLocation)
instance HsDev.Scan.EnumContents HsDev.Project.Types.Project
instance HsDev.Scan.EnumContents HsDev.PackageDb.Types.PackageDbStack
instance HsDev.Scan.EnumContents HsDev.Sandbox.Sandbox
instance HsDev.Scan.EnumContents a => HsDev.Scan.EnumContents [a]
instance HsDev.Scan.EnumContents GHC.IO.FilePath
instance HsDev.Scan.EnumContents System.Directory.Paths.Path
instance HsDev.Scan.EnumContents HsDev.Server.Types.FileSource
instance Control.DeepSeq.NFData HsDev.Scan.ScanContents
instance GHC.Base.Monoid HsDev.Scan.ScanContents
instance Text.Format.Formattable HsDev.Scan.ScanContents

module HsDev.Inspect.Order

-- | Order source files so that dependencies goes first and we are able to
--   resolve symbols and set fixities
orderBy :: (a -> Maybe Preloaded) -> [a] -> Either (DepsError Path) [a]
order :: [Preloaded] -> Either (DepsError Path) [Preloaded]

module HsDev.Watcher

-- | Watch for project sources changes
watchProject :: Watcher -> Project -> [String] -> IO ()

-- | Watch for standalone source
watchModule :: Watcher -> ModuleLocation -> IO ()

-- | Watch for top of package-db stack
watchPackageDb :: Watcher -> PackageDbStack -> [String] -> IO ()

-- | Watch for package-db stack
watchPackageDbStack :: Watcher -> PackageDbStack -> [String] -> IO ()
unwatchProject :: Watcher -> Project -> IO ()
unwatchModule :: Watcher -> ModuleLocation -> IO ()

-- | Unwatch package-db
unwatchPackageDb :: Watcher -> PackageDb -> IO ()
isSource :: Event -> Bool
isCabal :: Event -> Bool
isConf :: Event -> Bool

module HsDev.Database.Update
data Status
StatusWorking :: Status
StatusOk :: Status
StatusError :: HsDevError -> Status
data Progress
Progress :: Int -> Int -> Progress
[progressCurrent] :: Progress -> Int
[progressTotal] :: Progress -> Int
data Task
Task :: String -> Status -> String -> String -> Maybe Progress -> Task
[_taskName] :: Task -> String
[_taskStatus] :: Task -> Status
[_taskSubjectType] :: Task -> String
[_taskSubjectName] :: Task -> String
[_taskProgress] :: Task -> Maybe Progress
data UpdateOptions
UpdateOptions :: [Task] -> [String] -> Bool -> Bool -> UpdateOptions
[_updateTasks] :: UpdateOptions -> [Task]
[_updateGhcOpts] :: UpdateOptions -> [String]
[_updateDocs] :: UpdateOptions -> Bool
[_updateInfer] :: UpdateOptions -> Bool
newtype UpdateM m a
UpdateM :: ReaderT UpdateState (WriterT [ModuleLocation] (ClientM m)) a -> UpdateM m a
[runUpdateM] :: UpdateM m a -> ReaderT UpdateState (WriterT [ModuleLocation] (ClientM m)) a
runUpdate :: ServerMonadBase m => UpdateOptions -> UpdateM m a -> ClientM m a

-- | Post status
postStatus :: UpdateMonad m => Task -> m ()

-- | Mark module as updated
updater :: UpdateMonad m => [ModuleLocation] -> m ()

-- | Run one task
runTask :: (Display t, UpdateMonad m, NFData a) => String -> t -> m a -> m a

-- | Run many tasks with numeration
runTasks :: UpdateMonad m => [m a] -> m [a]

-- | Run many tasks with numeration
runTasks_ :: UpdateMonad m => [m ()] -> m ()

-- | Scan modules
scanModules :: UpdateMonad m => [String] -> [ModuleToScan] -> m ()

-- | Scan source file, resolve dependent modules
scanFile :: UpdateMonad m => [String] -> Path -> m ()

-- | Scan source files, resolving dependent modules
scanFiles :: UpdateMonad m => [(FileSource, [String])] -> m ()

-- | Scan source file with contents and resolve dependent modules
scanFileContents :: UpdateMonad m => [String] -> Path -> Maybe Text -> m ()

-- | Scan cabal modules, doesn't rescan if already scanned
scanCabal :: UpdateMonad m => [String] -> m ()

-- | Prepare sandbox for scanning. This is used for stack project to build
--   &amp; configure.
prepareSandbox :: UpdateMonad m => Sandbox -> m ()

-- | Scan sandbox modules, doesn't rescan if already scanned
scanSandbox :: UpdateMonad m => [String] -> Sandbox -> m ()

-- | Scan top of package-db stack, usable for rescan
scanPackageDb :: UpdateMonad m => [String] -> PackageDbStack -> m ()

-- | Scan project file
scanProjectFile :: UpdateMonad m => [String] -> Path -> m Project

-- | Scan project and related package-db stack
scanProjectStack :: UpdateMonad m => [String] -> Path -> m ()

-- | Scan project
scanProject :: UpdateMonad m => [String] -> Path -> m ()

-- | Scan directory for source files and projects
scanDirectory :: UpdateMonad m => [String] -> Path -> m ()
scanContents :: UpdateMonad m => [String] -> ScanContents -> m ()

-- | Scan installed docs
scanPackageDbStackDocs :: UpdateMonad m => [String] -> PackageDbStack -> m ()

-- | Scan docs for inspected modules
scanDocs :: UpdateMonad m => [Module] -> m ()

-- | Set inferred types for module
setModTypes :: UpdateMonad m => ModuleId -> [Note TypedExpr] -> m ()

-- | Infer types for modules
inferModTypes :: UpdateMonad m => [Module] -> m ()

-- | Generic scan function. Removed obsolete modules and calls callback on
--   changed modules.
scan :: UpdateMonad m => m [(Only Int) :. (ModuleLocation :. Inspection)] -> [ModuleToScan] -> [String] -> ([ModuleToScan] -> m ()) -> m ()
processEvents :: ([(Watched, Event)] -> IO ()) -> MVar (Async ()) -> MVar [(Watched, Event)] -> [(Watched, Event)] -> ClientM IO ()
updateEvents :: ServerMonadBase m => [(Watched, Event)] -> UpdateM m ()
applyUpdates :: UpdateOptions -> [(Watched, Event)] -> ClientM IO ()
cacheGhcWarnings :: Session -> [ModuleLocation] -> GhcM a -> GhcM a

-- | Get cached warnings
cachedWarnings :: SessionMonad m => [ModuleLocation] -> m [Note OutputMessage]
instance Control.DeepSeq.NFData HsDev.Database.Update.PreloadFailure

module HsDev.Client.Commands
runClient :: (ToJSON a, ServerMonadBase m) => CommandOptions -> ClientM m a -> ServerM m Result
runCommand :: ServerMonadBase m => Command -> ClientM m Value
instance Data.Aeson.Types.ToJSON.ToJSON System.Log.Simple.Base.Message
instance Data.Aeson.Types.FromJSON.FromJSON System.Log.Simple.Base.Message

module HsDev.Server.Base

-- | Inits log chan and returns functions (print message, wait channel)
initLog :: ServerOpts -> IO SessionLog

-- | Run server
runServer :: ServerOpts -> ServerM IO () -> IO ()
type Server = Worker (ServerM IO)

-- | Start listening for incoming connections
setupServer :: ServerOpts -> ServerM IO ()

-- | Shutdown server
shutdownServer :: ServerOpts -> ServerM IO ()
startServer :: ServerOpts -> IO Server
startServer_ :: ServerOpts -> IO Server
stopServer :: Server -> IO ()
withServer :: ServerOpts -> (Server -> IO a) -> IO a
withServer_ :: ServerOpts -> (Server -> IO a) -> IO a
inServer :: Server -> ServerM IO a -> IO a
clientCommand :: CommandOptions -> Command -> ServerM IO Result
parseCommand :: [String] -> Either String Command
readCommand :: [String] -> Command
sendServer :: Server -> CommandOptions -> [String] -> IO Result
sendServer_ :: Server -> [String] -> IO Result
findPath :: MonadIO m => CommandOptions -> FilePath -> m FilePath

-- | Process request, notifications can be sent during processing
processRequest :: SessionMonad m => CommandOptions -> Command -> m Result

-- | Process client, listen for requests and process them
processClient :: SessionMonad m => String -> Chan ByteString -> (ByteString -> IO ()) -> m ()

-- | Process client by socket
processClientSocket :: SessionMonad m => String -> Socket -> m ()

-- | If response points to mmap, get its contents and parse
unMmap :: Response -> IO Response
makeSocket :: ConnectionPort -> IO Socket
sockAddr :: ConnectionPort -> HostAddress -> SockAddr

module HsDev.Server.Commands

-- | Server control command
data ServerCommand
Version :: ServerCommand
Start :: ServerOpts -> ServerCommand
Run :: ServerOpts -> ServerCommand
Stop :: ClientOpts -> ServerCommand
Connect :: ClientOpts -> ServerCommand
Remote :: ClientOpts -> Bool -> Command -> ServerCommand

-- | Server options
data ServerOpts
ServerOpts :: ConnectionPort -> Int -> Maybe FilePath -> String -> Maybe FilePath -> Bool -> ServerOpts
[serverPort] :: ServerOpts -> ConnectionPort
[serverTimeout] :: ServerOpts -> Int
[serverLog] :: ServerOpts -> Maybe FilePath
[serverLogLevel] :: ServerOpts -> String
[serverDbFile] :: ServerOpts -> Maybe FilePath
[serverSilent] :: ServerOpts -> Bool

-- | Client options
data ClientOpts
ClientOpts :: ConnectionPort -> Bool -> Bool -> Int -> Bool -> ClientOpts
[clientPort] :: ClientOpts -> ConnectionPort
[clientPretty] :: ClientOpts -> Bool
[clientStdin] :: ClientOpts -> Bool
[clientTimeout] :: ClientOpts -> Int
[clientSilent] :: ClientOpts -> Bool
data Request
Request :: Command -> FilePath -> Bool -> Int -> Bool -> Request
[requestCommand] :: Request -> Command
[requestDirectory] :: Request -> FilePath
[requestNoFile] :: Request -> Bool
[requestTimeout] :: Request -> Int
[requestSilent] :: Request -> Bool
type Msg a = (Bool, a)
isLisp :: Lens' (Msg a) Bool
msg :: Lens (Msg a) (Msg b) a b
jsonMsg :: a -> Msg a
lispMsg :: a -> Msg a
encodeMessage :: ToJSON a => Msg (Message a) -> ByteString

-- | Decode lisp or json request
decodeMessage :: FromJSON a => ByteString -> Either (Msg String) (Msg (Message a))
sendCommand :: ClientOpts -> Bool -> Command -> (Notification -> IO a) -> IO Result
runServerCommand :: ServerCommand -> IO ()
findPath :: MonadIO m => CommandOptions -> FilePath -> m FilePath

-- | Process request, notifications can be sent during processing
processRequest :: SessionMonad m => CommandOptions -> Command -> m Result

-- | Process client, listen for requests and process them
processClient :: SessionMonad m => String -> Chan ByteString -> (ByteString -> IO ()) -> m ()

-- | Process client by socket
processClientSocket :: SessionMonad m => String -> Socket -> m ()

module HsDev