Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/kowainik/extensions
👅 Parse Haskell Language Extensions
https://github.com/kowainik/extensions
extensions hacktoberfest haskel2010 haskell haskell-extensions language-pragmas
Last synced: 3 months ago
JSON representation
👅 Parse Haskell Language Extensions
- Host: GitHub
- URL: https://github.com/kowainik/extensions
- Owner: kowainik
- License: mpl-2.0
- Created: 2020-04-25T16:16:31.000Z (over 4 years ago)
- Default Branch: main
- Last Pushed: 2024-07-09T07:02:54.000Z (4 months ago)
- Last Synced: 2024-07-10T09:23:35.344Z (4 months ago)
- Topics: extensions, hacktoberfest, haskel2010, haskell, haskell-extensions, language-pragmas
- Language: Haskell
- Homepage:
- Size: 113 KB
- Stars: 47
- Watchers: 5
- Forks: 9
- Open Issues: 7
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
- Codeowners: .github/CODEOWNERS
Awesome Lists containing this project
README
# extensions
[](https://github.com/kowainik/extensions/actions)
[](https://hackage.haskell.org/package/extensions)
[](LICENSE)
Library and CLI tool to parse Haskell `{-# LANGUAGE #-}` extensions in
source files, extract `default-extensions` from `.cabal` files and
combine together `default-extensions` and per-module extensions.
## Goals
The `extensions` library provides a lightweight way to get Haskell
LANGUAGE pragmas for Haskell modules. It has the following goals:
1. Be **lightweight**. Dependency footprint is extremely small,
and using `extensions` either as a library or as a tool is
straightforward.
2. Support both `default-extensions` in **Cabal** and `{-# LANGUAGE #-}`
pragmas in **Haskell** modules.
3. Should work on common and real cases. `extensions` strives to
support as many valid syntactic constructions as possible, but it
may not work on every possible combination of CPP, comments and
pragmas, where GHC would work. We encouragle you to
[open issue](https://github.com/kowainik/extensions/issues/new) if
you encounter any failures when using `extensions`.
## How to use
You can use `extensions` either as a library or as a CLI tool.
### Library
#### Usage with Cabal
`extensions` is compatible with the latest GHC compiler
versions starting from `8.8.3`.
In order to start using `extensions` in your project, you
will need to set it up with the three easy steps:
1. Add the dependency on `extensions` in your project's
`.cabal` file. For this, you should modify the `build-depends`
section by adding the name of this library. After the adjustment,
this section could look like this:
```haskell
build-depends: base ^>= 4.14
, extensions ^>= 0.0
```
2. In the module where you wish to extract extensions, you
should add the import:
```haskell
import Extensions (getPackageExtensions)
```
3. Now you can use the types and functions from the library:
```haskell
main :: IO ()
main = getPackageExtensions "extensions.cabal" >>= print
```
#### Usage with Stack
If `extensions` is not available on your current Stackage
resolver yet, fear not! You can still use it from Hackage by adding
the following to the `extra-deps` section of your `stack.yaml` file:
```yaml
extra-deps:
- extensions-0.0.0.0
```
### CLI tool
To use `extensions` as a CLI tool, you need to install it either with Cabal
```
cabal install extensions
```
Stack
```
stack install extensions
```
or the nix package manager which allows you to use it ad-hoc via `nix-shell -p haskellPackages.extensions --run extensions` or to install via
```
nix-env -iA nixpkgs.haskellPackages.extensions
```
The tool can be used to inspect language extensions in your Haskell
project. Some common usages of the tool:
1. Get all extensions in all modules, combined with
`default-extensions` from the `.cabal` file.
2. Get all extensions for a specific module, combined with Cabal
extensions.
3. Get extensions defined only in a module.
## Alternatives
Alternatively, you can extract Haskell Language extensions using the
following ways:
1. Using `ghc` as a library. This approach ties you to a specific GHC
version and requires more effort to support multiple GHCs. Also,
GHC API is more complicated than `extensions` API (especially if
you want to handle `CPP`). And even with `CPP` handling from `ghc`
you won't be able to get all extensions defined in a
module. However, this approach allows you to fully reproduce GHC
behaviour.
2. Using `ghc-lib-parser`. Same as the previous approach, but does not
tie you to a specific GHC version. However, `ghc-lib-parser` is
rather big dependency.
3. Using the `haskell-src-exts` library. This library parses Haskell
source files, but it's not actively maintained anymore and doesn't
support `CPP`.