| Safe Haskell | None |
|---|---|
| Language | Haskell98 |
Language.Haskell.HLint2
Description
WARNING: This module represents the evolving second version of the HLint API. It will be deleted in favour of Language.Haskell.HLint3 in the next major version.
This module provides a way to apply HLint hints. As an example of approximating the hlint experience:
(flags, classify, hint) <-autoSettingsRight m <-parseModuleExflags "MyFile.hs" Nothing print $applyHintsclassify hint [m]
- applyHints :: [Classify] -> Hint -> [(Module SrcSpanInfo, [Comment])] -> [Idea]
- data Idea = Idea {
- ideaModule :: String
- ideaDecl :: String
- ideaSeverity :: Severity
- ideaHint :: String
- ideaSpan :: SrcSpan
- ideaFrom :: String
- ideaTo :: Maybe String
- ideaNote :: [Note]
- ideaRefactoring :: [Refactoring SrcSpan]
- data Severity
- = Ignore
- | Suggestion
- | Warning
- | Error
- data Note
- data Classify = Classify {}
- getHLintDataDir :: IO FilePath
- autoSettings :: IO (ParseFlags, [Classify], Hint)
- autoSettings' :: FilePath -> IO (ParseFlags, [Classify], Hint)
- findSettings :: FilePath -> FilePath -> Maybe String -> IO ([String], [Module SrcSpanInfo])
- readSettings :: Module SrcSpanInfo -> ([Classify], [HintRule])
- data Hint = Hint {
- hintModules :: [(Scope, Module SrcSpanInfo)] -> [Idea]
- hintModule :: Scope -> Module SrcSpanInfo -> [Idea]
- hintDecl :: Scope -> Module SrcSpanInfo -> Decl SrcSpanInfo -> [Idea]
- hintComment :: Comment -> [Idea]
- builtinHints :: [(String, Hint)]
- data HintRule = HintRule {}
- hintRules :: [HintRule] -> Hint
- data Scope
- scopeCreate :: Module SrcSpanInfo -> Scope
- scopeMatch :: (Scope, QName SrcSpanInfo) -> (Scope, QName SrcSpanInfo) -> Bool
- scopeMove :: (Scope, QName SrcSpanInfo) -> Scope -> QName SrcSpanInfo
- parseModuleEx :: ParseFlags -> FilePath -> Maybe String -> IO (Either ParseError (Module SrcSpanInfo, [Comment]))
- defaultParseFlags :: ParseFlags
- data ParseError = ParseError {}
- data ParseFlags = ParseFlags {}
- data CppFlags
- type Encoding = TextEncoding
- defaultEncoding :: Encoding
- readEncoding :: String -> IO Encoding
- useEncoding :: Handle -> Encoding -> IO ()
Documentation
applyHints :: [Classify] -> Hint -> [(Module SrcSpanInfo, [Comment])] -> [Idea]
Given a way of classifying results, and a Hint, apply to a set of modules generating a list of Ideas.
The Idea values will be ordered within a file.
Given a set of modules, it may be faster pass each to applyHints in a singleton list.
When given multiple modules at once this function attempts to find hints between modules,
which is slower and often pointless (by default HLint passes modules singularly, using
--cross to pass all modules together).
Idea data type
data Idea
An idea suggest by a Hint.
Constructors
| Idea | |
Fields
| |
data Severity
How severe an issue is.
Constructors
| Ignore | The issue has been explicitly ignored and will usually be hidden (pass |
| Suggestion | Suggestions are things that some people may consider improvements, but some may not. |
| Warning | Warnings are suggestions that are nearly always a good idea to apply. |
| Error | Available as a setting for the user. |
data Note
A note describing the impact of the replacement.
Constructors
| IncreasesLaziness | The replacement is increases laziness, for example replacing |
| DecreasesLaziness | The replacement is decreases laziness, for example replacing |
| RemovesError String | The replacement removes errors, for example replacing |
| ValidInstance String String | The replacement assumes standard type class lemmas, a hint with the note |
| Note String | An arbitrary note. |
Settings
data Classify
How to classify an Idea. If any matching field is "" then it matches everything.
Constructors
| Classify | |
Fields
| |
getHLintDataDir :: IO FilePath
Get the Cabal configured data directory of HLint
autoSettings :: IO (ParseFlags, [Classify], Hint)
The function produces a tuple containg ParseFlags (for parseModuleEx), and Classify and Hint for applyHints.
It approximates the normal HLint configuration steps, roughly:
- Use
findSettingsto find and load the HLint settings files. - Use
readSettingsto interpret the settings files, producingHintRulevalues (LHS ==> RHSreplacements) andClassifyvalues to assignSeverityratings to hints. - Use
builtinHintsandhintRulesto generate aHintvalue. - Take all fixities from the
findSettingsmodules and put them in theParseFlags.
autoSettings' :: FilePath -> IO (ParseFlags, [Classify], Hint)
findSettings :: FilePath -> FilePath -> Maybe String -> IO ([String], [Module SrcSpanInfo])
Given the data directory (where the hlint data files reside, see getHLintDataDir),
and a filename to read, and optionally that file's contents, produce a pair containing:
- Builtin hints to use, e.g.
List, which should be resolved usingbuiltinHints. - A list of modules containing hints, suitable for processing with
readSettings.
Any parse failures will result in an exception.
readSettings :: Module SrcSpanInfo -> ([Classify], [HintRule])
Hints
data Hint
Functions to generate hints, combined using the Monoid instance.
Constructors
| Hint | |
Fields
| |
builtinHints :: [(String, Hint)]
A list of builtin hints, currently including entries such as "List" and "Bracket".
data HintRule
A LHS ==> RHS style hint rule.
Constructors
| HintRule | |
Fields
| |
Scopes
data Scope
Data type representing the modules in scope within a module.
Created with scopeCreate and queried with scopeMatch and scopeMove.
Note that the mempty Scope is not equivalent to scopeCreate on an empty module,
due to the implicit import of Prelude.
scopeCreate :: Module SrcSpanInfo -> Scope
Create a Scope value from a module, based on the modules imports.
scopeMatch :: (Scope, QName SrcSpanInfo) -> (Scope, QName SrcSpanInfo) -> Bool
Given a two names in scopes, could they possibly refer to the same thing. This property is reflexive.
scopeMove :: (Scope, QName SrcSpanInfo) -> Scope -> QName SrcSpanInfo
Given a name in a scope, and a new scope, create a name for the new scope that will refer to the same thing. If the resulting name is ambiguous, it picks a plausible candidate.
Haskell-src-exts
parseModuleEx :: ParseFlags -> FilePath -> Maybe String -> IO (Either ParseError (Module SrcSpanInfo, [Comment]))
Parse a Haskell module. Applies the C pre processor, and uses best-guess fixity resolution if there are ambiguities.
The filename - is treated as stdin. Requires some flags (often defaultParseFlags), the filename, and optionally the contents of that file.
defaultParseFlags :: ParseFlags
Default value for ParseFlags.
data ParseError
A parse error from parseModuleEx.
Constructors
| ParseError | |
Fields
| |
data CppFlags
What C pre processor should be used.
Constructors
| NoCpp | No pre processing is done. |
| CppSimple | Lines prefixed with |
| Cpphs CpphsOptions | The |
File encodings
type Encoding = TextEncoding
An Encoding represents how characters are stored in a file. Created with
defaultEncoding or readEncoding and used with useEncoding.
The system default encoding.
readEncoding :: String -> IO Encoding
Create an encoding from a string, or throw an error if the encoding is not known.
Accepts many encodings including locale, utf-8 and all those supported by the
GHC mkTextEncoding function.
useEncoding :: Handle -> Encoding -> IO ()
Apply an encoding to a Handle.