hsdev- Haskell development library and tool with support of autocompletion, symbol info, go to declaration, find references etc.

Safe HaskellNone




databaseIntersection :: Database -> Database -> Database Source

Database intersection, prefers first database data

nullDatabase :: Database -> Bool Source

Check if database is empty

databaseLocals :: Database -> Database Source

Bring all locals to scope

databasePackageDbs :: Database -> [PackageDb] Source

All scanned sandboxes

allModules :: Database -> [Module] Source

All modules

fromModule :: InspectedModule -> Database Source

Make database from module

fromProject :: Project -> Database Source

Make database from project

filterDB :: (ModuleId -> Bool) -> (Project -> Bool) -> Database -> Database Source

Filter database by predicate

projectDB :: Project -> Database -> Database Source

Project database

packageDbDB :: PackageDb -> Database -> Database Source

Package-db database

standaloneDB :: Database -> Database Source

Standalone database

selectModules :: (Module -> Bool) -> Database -> [Module] Source

Select module by predicate

selectDeclarations :: (ModuleDeclaration -> Bool) -> Database -> [ModuleDeclaration] Source

Select declaration by predicate

lookupModule :: ModuleLocation -> Database -> Maybe Module Source

Lookup module by its location and name

lookupFile :: FilePath -> Database -> Maybe Module Source

Lookup module by its source file

getInspected :: Database -> Module -> InspectedModule Source

Get inspected module

append :: Database -> Database -> Database Source

Append database

remove :: Database -> Database -> Database Source

Remove database

data Map k a :: * -> * -> *

A Map from keys k to values a.


MonadState ResolvedTree ResolveM 
Ord k => TraverseMin k (Map k) 
Ord k => TraverseMax k (Map k) 
Functor (Map k) 
Foldable (Map k) 
Traversable (Map k) 
Ord k => TrieMap (Map k) 
Ord k => IsList (Map k v) 
(Eq k, Eq a) => Eq (Map k a) 
(Data k, Data a, Ord k) => Data (Map k a) 
(Ord k, Ord v) => Ord (Map k v) 
(Ord k, Read k, Read e) => Read (Map k e) 
(Show k, Show a) => Show (Map k a) 
Ord k => Monoid (Map k v) 
(NFData k, NFData a) => NFData (Map k a) 
(Outputable key, Outputable elt) => Outputable (Map key elt) 
Ord k => Semigroup (Map k v) 
Ord k => Ixed (Map k a) 
Ord k => At (Map k a) 
Ord k => Wrapped (Map k a) 
(Ord k, Group a) => Group (Map k a) Source 
((~) * t (Map k' a'), Ord k) => Rewrapped (Map k a) t

Use wrapping fromList. unwrapping returns a sorted list.

(~) * c d => Each (Map c a) (Map d b) a b
each :: Traversal (Map c a) (Map c b) a b
type Key (Map k) = k 
type Item (Map k v) = (k, v) 
type Index (Map k a) = k 
type IxValue (Map k a) = a 
type Unwrapped (Map k a) = [(k, a)]