doc: Added math/hs-indexed-profunctors version 0.1.1

(pho)

math/hs-indexed-profunctors: import hs-indexed-profunctors-0.1.1

This package contains basic definitions related to indexed
profunctors. These are primarily intended as internal utilities to support
the optics and generic-lens package families.

(pho)

lang/Makefile: + dhall

(pho)

doc: Added lang/dhall version 1.40.2

(pho)

lang/dhall: import dhall-1.40.2

Dhall is an explicitly typed configuration language that is not Turing
complete. Despite being Turing incomplete, Dhall is a real programming
language with a type-checker and evaluator.

Use this library to parse, type-check, evaluate, and pretty-print the Dhall
configuration language. This package also includes an executable which
type-checks a Dhall file and reduces the file to a fully evaluated normal
form.

(pho)

net/Makefile: + hs-uri-encode

(pho)

doc: Added net/hs-uri-encode version 1.5.0.7

(pho)

net/hs-uri-encode: import hs-uri-encode-1.5.0.7

This package allows you to uri encode and uri decode Strings, Texts and
ByteString values.

(pho)

textproc/Makefile: + hs-text-manipulate

(pho)

doc: Added textproc/hs-text-manipulate version 0.3.0.0

(pho)

textproc/hs-text-manipulate: import hs-text-manipulate-0.3.0.0

Manipulate identifiers and structurally non-complex pieces of text by
delimiting word boundaries via a combination of whitespace,
control-characters, and case-sensitivity.

Has support for common idioms like casing of programmatic variable names,
taking, dropping, and splitting by word, and modifying the first character
of a piece of text.

(pho)

devel/Makefile: + hs-repline

(pho)

doc: Added devel/hs-repline version 0.4.0.0

(pho)

devel/hs-repline: import hs-repline-0.4.0.0

Haskeline wrapper for GHCi-like REPL interfaces. Composable with normal mtl
transformers.

(pho)

textproc/Makefile: + hs-parsers

(pho)

doc: Added textproc/hs-parsers version 0.12.10

(pho)

textproc/hs-parsers: import hs-parsers-0.12.10

This library provides convenient combinators for working with and building
parsing combinator libraries.

Given a few simple instances, e.g. for the class
Text.Parser.Combinators.Parsing in Text.Parser.Combinators.Parsing you get
access to a large number of canned definitions. Instances exist for the
parsers provided by parsec, attoparsec and base's Text.Read.

(pho)

textproc/Makefile: + hs-charset

(pho)

doc: Added textproc/hs-charset version 0.3.9

(pho)

textproc/hs-charset: import hs-charset-0.3.9

Fast utf-8 character sets for Haskell represented as complemented PATRICIA
tries.

(pho)

devel/Makefile: + hs-lens-family-core

(pho)

doc: Added devel/hs-lens-family-core version 2.1.0

(pho)

devel/hs-lens-family-core: import hs-lens-family-core-2.1.0

This package provides first class functional references in Van Laarhoven
style supporting the following optics:

* Lenses (view, over)
* Traversals (toListOf, matching, over)
* Setters (over)
* Grates (zipWithOf, under, review)
* Resetters (under)
* Adapters (view, review)
* Grids (toListOf, over / under, review)
* Prisms (matching, over / under, review)
* Getters (view)
* Folders (toListOf)
* Reviewers (review)

(pho)

graphics/Makefile: + hs-dotgen

(pho)

doc: Added graphics/hs-dotgen version 0.4.3

(pho)

graphics/hs-dotgen: import hs-dotgen-0.4.3

This package provides a simple interface for building .dot graph files, for
input into the dot and graphviz tools. It includes a monadic interface for
building graphs.

(pho)

converters/Makefile: + hs-cborg-json

(pho)

doc: Added converters/hs-cborg-json version 0.2.3.0

(pho)

converters/hs-cborg-json: import hs-cborg-json-0.2.3.0

This package implements the bijection between JSON and CBOR defined in the
CBOR specification, RFC 7049.

(pho)

devel/Makefile: + hs-atomic-write

(pho)

doc: Added devel/hs-atomic-write version 0.2.0.7

(pho)

devel/hs-atomic-write: import hs-atomic-write-0.2.0.7

Atomically write to a file on POSIX-compliant systems while preserving
permissions.

On most Unix systems, mv is an atomic operation. This makes it simple to
write to a file atomically just by using the mv operation. However, this
will destroy the permissions on the original file. This library does the
following to preserve permissions while atomically writing to a file:

* If an original file exists, take those permissions and apply them to the
  temp file before mving the file into place.

* If the original file does not exist, create a following with default
  permissions (based on the currently-active umask).

This way, when the file is mv'ed into place, the permissions will be the
ones held by the original file.

(pho)

devel/Makefile: + hs-async-pool

(pho)

doc: Added devel/hs-async-pool version 0.9.1

(pho)

devel/hs-async-pool: import hs-async-pool-0.9.1

This library modifies the async package to allow for task pooling and
many-to-many dependencies between tasks.

(pho)

lang/Makefile: + purescript

(pho)

doc: Added lang/purescript version 0.14.5

(pho)

lang/purescript: import purescript-0.14.5

A small strongly typed programming language with expressive types that
compiles to JavaScript, written in and inspired by Haskell.

(pho)

www/Makefile: + hs-wai-websockets

(pho)

doc: Added www/hs-wai-websockets version 3.0.1.2

(pho)

www/hs-wai-websockets: import hs-wai-websockets-3.0.1.2

Use websockets with WAI applications, primarily those hosted via Warp.

(pho)

www/Makefile: + hs-websockets

(pho)

doc: Added www/hs-websockets version 0.12.7.3

(pho)

www/hs-websockets: import hs-websockets-0.12.7.3

This library allows you to write WebSocket-capable servers.

An example server:
https://github.com/jaspervdj/websockets/blob/master/example/server.lhs

An example client:
https://github.com/jaspervdj/websockets/blob/master/example/client.hs

See also:
* The specification of the WebSocket protocol:
  http://www.whatwg.org/specs/web-socket-protocol/
* The JavaScript API for dealing with WebSockets:
  http://www.w3.org/TR/websockets/

(pho)

lang/Makefile: + hs-sourcemap

(pho)

doc: Added lang/hs-sourcemap version 0.1.7

(pho)

lang/hs-sourcemap: import hs-sourcemap-0.1.7

Implementation of source maps, revision 3, proposed by Google
(https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit)
and Mozilla (https://wiki.mozilla.org/DevTools/Features/SourceMap).

(pho)

lang/Makefile: + hs-purescript-cst

(pho)

doc: Added lang/hs-purescript-cst version 0.4.0.0

(pho)

lang/hs-purescript-cst: import hs-purescript-cst-0.4.0.0

The parser for the PureScript programming language.

(pho)

devel/Makefile: + hs-serialise

(pho)

doc: Added devel/hs-serialise version 0.2.4.0

(pho)

devel/hs-serialise: import hs-serialise-0.2.4.0

This package (formerly binary-serialise-cbor) provides pure, efficient
serialization of Haskell values directly into ByteStrings for storage or
transmission purposes. By providing a set of type class instances, you can
also serialise any custom data type you have as well.

The underlying binary format used is the 'Concise Binary Object
Representation', or CBOR, specified in RFC 7049. As a result, serialised
Haskell values have implicit structure outside of the Haskell program
itself, meaning they can be inspected or analyzed without custom tools.

(pho)

devel/Makefile: + hs-protolude

(pho)

doc: Added devel/hs-protolude version 0.3.0

(pho)

devel/hs-protolude: import hs-protolude-0.3.0

A sensible starting Prelude for building custom Preludes.

Design points:

* Banishes String.
* Banishes partial functions.
* Compiler warning on bottoms.
* Polymorphic string IO functions.
* Polymorphic show.
* Automatic string conversions.
* Types for common data structures in scope.
* Types for all common string types (Text/ByteString) in scope.
* Banishes impure exception throwing outside of IO.
* StateT/ReaderT/ExceptT transformers in scope by default.
* Foldable / Traversable functions in scope by default.
* Unsafe functions are prefixed with "unsafe" in separate module.
* Compiler agnostic, GHC internal modules are abstracted out into Base.
* sum and product are strict by default.
* Includes Semiring for GHC >= 7.6.
* Includes Bifunctor for GHC >= 7.6.
* Includes Semigroup for GHC >= 7.6.

(pho)

devel/Makefile: + hs-mtl-compat

(pho)

doc: Added devel/hs-mtl-compat version 0.2.2

(pho)

devel/hs-mtl-compat: import hs-mtl-compat-0.2.2

This package backports the Control.Monad.Except module from mtl (if using
mtl-2.2.0.1 or earlier), which reexports the ExceptT monad transformer and
the MonadError class.

This package should only be used if there is a need to use the
Control.Monad.Except module specifically. If you just want the mtl class
instances for ExceptT, use transformers-compat instead, since mtl-compat
does nothing but reexport the instances from that package.

Note that unlike how mtl-2.2 or later works, the Control.Monad.Except
module defined in this package exports all of ExceptT's monad class
instances. Therefore, you may have to declare import Control.Monad.Except
() at the top of your file to get all of the ExceptT instances in scope.

(pho)

devel/Makefile: + hs-pattern-arrows

(pho)

doc: Added devel/hs-pattern-arrows version 0.0.2

(pho)

devel/hs-pattern-arrows: import hs-pattern-arrows-0.0.2

A library for generating concise pretty printers based on precedence rules.

(pho)

devel/Makefile: + hs-monad-logger

(pho)

doc: Added devel/hs-monad-logger version 0.3.36

(pho)

devel/hs-monad-logger: import hs-monad-logger-0.3.36

A monad transformer approach for logging.

This package provides Template Haskell functions for determining source
code locations of messages.

(pho)

devel/Makefile: + hs-monad-loops

(pho)

doc: Added devel/hs-monad-loops version 0.4.3

(pho)

devel/hs-monad-loops: import hs-monad-loops-0.4.3

Some useful control operators for looping.

(pho)

devel/Makefile: + hs-stm-chans

(pho)

doc: Added devel/hs-stm-chans version 3.0.0.6

(pho)

devel/hs-stm-chans: import hs-stm-chans-3.0.0.6

This package offers a collection of channel types, similar to
Control.Concurrent.STM.{TChan,TQueue} but with additional features. In
particular we offer the following data types:

Control.Concurrent.STM.TBChan:
    Bounded FIFO channels. When the channel is full, writers will
    block/retry. This ensures that the writers do not get too far ahead of
    the readers, which helps to make sure that memory and cpu resources are
    used responsibly.

Control.Concurrent.STM.TMChan:
    Closeable FIFO channels.

Control.Concurrent.STM.TMQueue:
    Closeable FIFO queues. Like TChan (Maybe a) but with a monotonicity
    guarantee that once Nothing is returned all future reads will be
    Nothing as well.

Control.Concurrent.STM.TBMChan:
    Bounded Closeable FIFO channels.

Control.Concurrent.STM.TBMQueue:
    Bounded Closeable FIFO queues. Combines the capabilities of TBChan and
    TMChan.

(pho)

devel/Makefile: + hs-microlens-platform

(pho)

doc: Added devel/hs-microlens-platform version 0.4.2.1

(pho)

devel/hs-microlens-platform: import hs-microlens-platform-0.4.2.1

This package exports a module which is the recommended starting point for
using microlens if you aren't trying to keep your dependencies minimal. By
importing Lens.Micro.Platform you get all functions and instances from
microlens, microlens-th, microlens-mtl, microlens-ghc, as well as instances
for Vector, Text, and HashMap.

(pho)

devel/Makefile: + hs-microlens-mtl

(pho)

doc: Added devel/hs-microlens-mtl version 0.2.0.1

(pho)

devel/hs-microlens-mtl: import hs-microlens-mtl-0.2.0.1

This package contains functions (like view or +=) which work on
MonadReader, MonadWriter, and MonadState from the mtl package.

(pho)

devel/Makefile: + hs-microlens-ghc

(pho)

doc: Added devel/hs-microlens-ghc version 0.4.13.1

(pho)

devel/hs-microlens-ghc: import hs-microlens-ghc-0.4.13.1

Use this package instead of microlens if you don't mind depending on all
dependencies here -- Lens.Micro.GHC reexports everything from Lens.Micro
and additionally provides orphan instances of microlens classes for
packages coming with GHC (array, bytestring, containers, transformers).

(pho)

devel/Makefile: + hs-lifted-async

(pho)

doc: Added devel/hs-lifted-async version 0.10.2.2

(pho)

devel/hs-lifted-async: import hs-lifted-async-0.10.2.2

This package provides IO operations from async package lifted to any
instance of MonadBase or MonadBaseControl from monad-control package.

(pho)

lang/Makefile: + hs-language-javascript

(pho)

doc: Added lang/hs-language-javascript version 0.7.1.0

(pho)

lang/hs-language-javascript: import hs-language-javascript-0.7.1.0

Parses Javascript into an Abstract Syntax Tree (AST).

(pho)

devel/Makefile: + hs-cborg

(pho)

doc: Added devel/hs-cborg version 0.2.6.0

(pho)

devel/hs-cborg: import hs-cborg-0.2.6.0

This package provides an efficient implementation of the Concise Binary
Object Representation (CBOR), as specified by RFC 7049
(https:/tools.ietf.orghtml/rfc7049).

(pho)

devel/Makefile: + hs-half

(pho)

doc: Added devel/hs-half version 0.3.1

(pho)

devel/hs-half: import hs-half-0.3.1

This package supplies half-precision floating point values w/ 1 bit of
sign, 5 bits of exponent, 11 bits of mantissa trailing a leading 1 bit with
proper underflow.

These arise commonly in GPU applications.

(pho)

textproc/Makefile: + hs-boxes

(pho)

doc: Added textproc/hs-boxes version 0.1.5

(pho)

textproc/hs-boxes: import hs-boxes-0.1.5

A pretty-printing library for laying out text in two dimensions, using a
simple box model.

(pho)

www/Makefile: + hs-bower-json

(pho)

doc: Added www/hs-bower-json version 1.0.0.1

(pho)

www/hs-bower-json: import hs-bower-json-1.0.0.1

Bower is a package manager for the web (see http://bower.io). This package
provides a data type and ToJSON/FromJSON instances for Bower's package
manifest file, bower.json.

(pho)

converters/Makefile: + hs-aeson-better-errors

(pho)

doc: Added converters/hs-aeson-better-errors version 0.9.1.0

(pho)

converters/hs-aeson-better-errors: import hs-aeson-better-errors-0.9.1.0

A small package which gives you the tools to build parsers to decode JSON
values, and gives good error messages when parsing fails. See also
http://harry.garrood.me/blog/aeson-better-errors/

(pho)

devel/hs-optparse-applicative: Add a mk fragment application.mk

optparse-applicative has a really nice feature that enables any tools
parsing command-line arguments with the library to automatically generate
bash, fish, and zsh completion scripts via hidden options, by hidden it
means they aren't shown in the "--help" message.

Packages that install executables using optparse-applicative can now
include this file to automatically generate and install such scripts.

(pho)

mk/haskell.mk: Add a package-settable variable HASKELL_ENABLE_DYNAMIC_EXECUTABLE

Prior to this change, packages that install both libraries and executables
were both linked dynamically when HASKELL_ENABLE_SHARED_LIBRARY is set to
yes. This turned out to be problematic when the executables end up
depending on hundreds of shared objects (which occurs rather frequently for
tools written in Haskell): the dynamic linker spends several seconds upon
loading the executables to resolve all the symbols.

Now we can selectively opt out from dynamic linkage by setting
HASKELL_ENABLE_DYNAMIC_EXECUTABLE to no. This should be done carefully,
because linking executables with static Haskell libraries means that those
executables will also use static RTS. This causes problems if they use GHC
API to interpret Haskell code at run time: static RTS would violate PaX
MPROTECT and suffer from ASLR while loading static objects.

(pho)

shells/zsh: Improve completions of pkg_* on Darwin

(pho)

Fix build on Darwin

(pho)

lang/ghc92/patches: Add a tech-kern thread URL

(pho)

Correct wrong checksums for the Darwin/x86_64 bootkit

(pho)

Correct wrong checksums for the Darwin/x86_64 bootkit

(pho)

lang/ghc92: Work around an issue where GHCi sometimes crashes on NetBSD

(pho)

devel/hdevtools: Suggest migrating to haskell-language-server in the BROKEN message

It's now considered to have been superseded by HLS. The package may be
removed some time.

(pho)

devel/Makefile: + haskell-language-server

(pho)

doc: Added devel/haskell-language-server version 1.6.1.1

(pho)

devel/haskell-language-server: import haskell-language-server-1.6.1.1

The haskell-language-server (HLS) project is an implementation of a server
(a "language server") for the Language Server Protocol (LSP). A language
server talks to a client (typically an editor), which can ask the server to
perform various operations, such as reporting errors or providing code
completions. The advantage of this system is that clients and servers can
interoperate more easily so long as they all speak the LSP protocol. In the
case of HLS, that means that it can be used with many different editors,
since editor support for the LSP protocol is now widespread.

(pho)

devel/Makefile: + hs-hls-oumolu-plugin

(pho)

doc: Added devel/hs-hls-oumolu-plugin version 1.0.2.0

(pho)

devel/hs-hls-oumolu-plugin: import hs-hls-ormolu-plugin-1.0.2.0

Integration with the Ormolu code formatter

(pho)

devel/Makefile: + ormolu

(pho)

doc: Added devel/ormolu version 0.4.0.0

(pho)

devel/ormolu: import ormolu-0.4.0.0

Ormolu is a formatter for Haskell source code. The project was created with
the following goals in mind:

* Using GHC's own parser to avoid parsing problems caused by
  haskell-src-exts.
* Let some whitespace be programmable. The layout of the input influences
  the layout choices in the output. This means that the choices between
  single-line/multi-line layouts in certain situations are made by the
  user, not by an algorithm. This makes the implementation simpler and
  leaves some control to the user while still guaranteeing that the
  formatted code is stylistically consistent.
* Writing code in such a way so it's easy to modify and maintain.
* Implementing one "true" formatting style which admits no configuration.
* The formatting style aims to result in minimal diffs.
* Choose a style compatible with modern dialects of Haskell. As new Haskell
  extensions enter broad use, we may change the style to accommodate them.
* Idempotence: formatting already formatted code doesn't change it.
* Be well-tested and robust so that the formatter can be used in large
  projects.

(pho)

devel/Makefile: + hs-hls-fourmolu-plugin

(pho)

doc: Added devel/hs-hls-fourmolu-plugin version 1.0.2.0

(pho)

devel/hs-hls-fourmolu-plugin: import hs-hls-fourmolu-plugin-1.0.2.0

Integration with the Fourmolu code formatter

(pho)

devel/Makefile: + fourmolu

(pho)

doc: Added devel/fourmolu version 0.5.0.1

(pho)

devel/fourmolu: import fourmolu-0.5.0.1

Fourmolu is a formatter for Haskell source code. It is a fork of Ormolu,
with the intention to continue to merge upstream improvements.

We share all bar one of Ormolu's goals:

* Using GHC's own parser to avoid parsing problems caused by
  haskell-src-exts.
* Let some whitespace be programmable. The layout of the input influences
  the layout choices in the output. This means that the choices between
  single-line/multi-line layouts in certain situations are made by the
  user, not by an algorithm. This makes the implementation simpler and
  leaves some control to the user while still guaranteeing that the
  formatted code is stylistically consistent.
* Writing code in such a way so it's easy to modify and maintain.
* That formatting style aims to result in minimal diffs.
* Choose a style compatible with modern dialects of Haskell. As new Haskell
  extensions enter broad use, we may change the style to accommodate them.
* Idempotence: formatting already formatted code doesn't change it.
* Be well-tested and robust so that the formatter can be used in large
  projects.
* We allow configuration of various parameters, via CLI options or config
  files. We encourage any contributions which add further flexibility.

(pho)

textproc/Makefile: + hs-HsYAML-aeson

(pho)

doc: Added textproc/hs-HsYAML-aeson version 0.2.0.1

(pho)

textproc/hs-HsYAML-aeson: import hs-HsYAML-aeson-0.2.0.1

The YAML 1.2 format provides a much richer data-model and feature-set than
the JavaScript Object Notation (JSON) format. However, sometimes it's
desirable to ignore the extra capabilities and treat YAML as if it was
merely a more convenient markup format for humans to write JSON data. To
this end this module provides a compatibility layer atop HsYAML which
allows decoding YAML documents in the more limited JSON data-model while
also providing convenience by reusing aeson's FromJSON instances for
decoding the YAML data into native Haskell data types.

(pho)

devel/Makefile: + hs-ghc-lib-parser

(pho)

doc: Added devel/hs-ghc-lib-parser version 9.2.1.20220109

(pho)

devel/hs-ghc-lib-parser: import hs-ghc-lib-parser-9.2.1.20220109

A package equivalent to the ghc package, but which can be loaded on many
compiler versions.

(pho)

devel/Makefile: + hs-hls-floskell-plugin

(pho)

doc: Added devel/hs-hls-floskell-plugin version 1.0.1.0

(pho)

devel/hs-hls-floskell-plugin: import hs-hls-floskell-plugin-1.0.1.0

Integration with the Floskell code formatter

(pho)

devel/Makefile: + floskell

(pho)

doc: Added devel/floskell version 0.10.6

(pho)

devel/floskell: import floskell-0.10.6

Floskell started as a fork of version 4 of Chris Done's hindent. The
formatting styles present in hindent 4 have been preserved in spirit, but
generally will not produce exactly the same output.

(pho)

devel/Makefile: + hs-monad-dijkstra

(pho)

doc: Added devel/hs-monad-dijkstra version 0.1.1.3

(pho)

devel/hs-monad-dijkstra: import hs-monad-dijkstra-0.1.1.3

A monad transformer for weighted graph searches using Dijkstra's or A*
algorithm.

(pho)

devel/Makefile: + hs-hls-selection-range-plugin

(pho)

doc: Added devel/hs-hls-selection-range-plugin version 1.0.0.0

(pho)

devel/hs-hls-selection-range-plugin: import hs-hls-selection-range-plugin-1.0.0.0

HLS Plugin to support smart selection range

(pho)

devel/Makefile: + hs-hls-qualify-imported-names-plugin

(pho)

doc: Added devel/hs-hls-qualify-imported-names-plugin version 1.0.1.0

(pho)

devel/hs-hls-qualify-imported-names-plugin: import hs-hls-qualify-imported-names-plugin-1.0.1.0

You've imported a number of modules, and have written a lot of code with
unqualified names. You want to import a new module but you know there will
be a number name clashes so you want to switch your current usage of names
to be qualified. It would be nice if you could change

  import Blah

to

  import Blah as Bloo

then magically qualify all the previous names imported from Blah with
Bloo. After doing that you could then change

  import Blah as Bloo

to

  import qualified Blah as Bloo

and import your the new module using names from it without worry. Well, now
you can...

(pho)

devel/Makefile: + hs-hls-alternate-number-format-plugin

(pho)

doc: Added devel/hs-hls-alternate-number-format-plugin version 1.0.1.0

(pho)

devel/hs-hls-alternate-number-format-plugin: import hs-hls-alternate-number-format-plugin-1.0.1.0

The alternate number format plugin provides alternative formatting for
Numeric Literals in source code. These can be any numeric literal such as
123, 0x45 or any of the other numeric formats. The plugin is context aware
and will provide suggestions based on currently active GHC extensions.

(pho)

devel/Makefile: + hs-hls-pragmas-plugin

(pho)

doc: Added devel/hs-hls-pragmas-plugin version 1.0.2.0

(pho)

devel/hs-hls-pragmas-plugin: import hs-hls-pragmas-plugin-1.0.2.0

Pragmas plugin for Haskell Language Server

(pho)

devel/Makefile: + hs-hls-module-name-plugin

(pho)

doc: Added devel/hs-hls-module-name-plugin version 1.0.1.0

(pho)

devel/hs-hls-module-name-plugin: import hs-hls-module-name-plugin-1.0.1.0

Module name plugin for Haskell Language Server

(pho)

devel/Makefile: + hs-hls-refine-imports-plugin

(pho)

doc: Added devel/hs-hls-refine-imports-plugin version 1.0.1.0

(pho)

devel/hs-hls-refine-imports-plugin: import hs-hls-refine-imports-plugin-1.0.1.0

Refine imports plugin for Haskell Language Server

(pho)

devel/Makefile: + hs-hls-explicit-imports-plugin

(pho)

doc: Added devel/hs-hls-explicit-imports-plugin version 1.0.2.0

(pho)

devel/hs-hls-explicit-imports-plugin: import hs-hls-explicit-imports-plugin-1.0.2.0

Explicit imports plugin for Haskell Language Server

(pho)

devel/Makefile: + hs-hls-call-hierarchy-plugin

(pho)

doc: Added devel/hs-hls-call-hierarchy-plugin version 1.0.2.0

(pho)

devel/hs-hls-call-hierarchy-plugin: import hs-hls-call-hierarchy-plugin-1.0.2.0

The call hierarchy plugin can review the code to determine where functions
are called and how they relate to other functions.

This plugin is useful when debugging and refactoring code because it allows
you to see how different parts of the code are related. And it is more
conducive for users to quickly understand their macro architecture in the
face of strange code.

(pho)

devel/Makefile: + hs-optparse-simple

(pho)

doc: Added devel/hs-optparse-simple version 0.1.1.4

(pho)

devel/hs-optparse-simple: import hs-optparse-simple-0.1.1.4

Simple interface to optparse-applicative.

(pho)

devel/Makefile: + hs-ghcide

(pho)

doc: Added devel/hs-ghcide version 1.6.0.0

(pho)

devel/hs-ghcide: import hs-ghcide-1.6.0.0

A library for building Haskell IDE's on top of the GHC API.

(pho)

devel/Makefile: + hs-heapsize

(pho)

doc: Added devel/hs-heapsize version 0.3.0.1

(pho)

devel/hs-heapsize: import hs-heapsize-0.3.0.1

heapsize is a tool to determine the size data structures. Determining the
size of recursive data structures is supported. All sizes are in Bytes.

(pho)

devel/Makefile: + hs-gitrev

(pho)

doc: Added devel/hs-gitrev version 1.3.1

(pho)

devel/hs-gitrev: import hs-gitrev-1.3.1

Some handy Template Haskell splices for including the current git hash and
branch in the code of your project. Useful for including in panic messages,
--version output, or diagnostic info for more informative bug reports.

(pho)

devel/Makefile: + retrie

(pho)

doc: Added devel/retrie version 1.2.0.1

(pho)

devel/retrie: import retrie-1.2.0.1

Retrie is a tool for codemodding Haskell. Key goals include:

* Speed: Efficiently rewrite in large (>1 million line) codebases.
* Safety: Avoids large classes of codemod-related errors.
* Ease-of-use: Haskell syntax instead of regular expressions. No
  hand-rolled AST traversals.

This package provides a command-line tool (retrie) and a library (Retrie)
for making equational edits to Haskell code.

(pho)

devel/Makefile: + hs-random-shuffle

(pho)

doc: Added devel/hs-random-shuffle version 0.0.4

(pho)

devel/hs-random-shuffle: import hs-random-shuffle-0.0.4

Random shuffle implementation, on immutable lists. Based on "perfect
shuffle" implementation by Oleg Kiselyov, available on
http://okmij.org/ftp/Haskell/perfect-shuffle.txt

(pho)

devel/Makefile: + hs-implicit-hie-cradle

(pho)

doc: Added devel/hs-implicit-hie-cradle version 0.5.0.0

(pho)

devel/hs-implicit-hie-cradle: import hs-implicit-hie-cradle-0.5.0.0

Auto generate a stack or cabal multi component cradles.

(pho)

devel/Makefile: + hs-implicit-hie

(pho)

doc: Added devel/hs-implicit-hie version 0.1.2.6

(pho)

devel/hs-implicit-hie: import hs-implicit-hie-0.1.2.6

Auto generate a stack or cabal multi component hie.yaml file.

(pho)

devel/Makefile: + hs-hls-plugin-api

(pho)

doc: Added devel/hs-hls-plugin-api version 1.3.0.0

(pho)

devel/hs-hls-plugin-api: import hs-hls-plugin-api-1.3.0.0

Haskell Language Server API for plugin communication

(pho)

sysutils/Makefile: + hs-opentelemetry

(pho)

doc: Added sysutils/hs-opentelemetry version 0.7.0

(pho)

sysutils/hs-opentelemetry: import hs-opentelemetry-0.7.0

The OpenTelemetry Haskell Client. See https://opentelemetry.io

(pho)

devel/Makefile: + hs-lsp

(pho)

doc: Added devel/hs-lsp version 1.4.0.0

(pho)

devel/hs-lsp: import hs-lsp-1.4.0.0

An implementation of the types, and basic message server to allow language
implementors to support the Language Server Protocol for their specific
language.

(pho)

devel/Makefile: + hs-uuid

(pho)

doc: Added devel/hs-uuid version 1.3.15

(pho)

devel/hs-uuid: import hs-uuid-1.3.15

This library is useful for creating, comparing, parsing and printing
Universally Unique Identifiers.

See http://en.wikipedia.org/wiki/UUID for the general idea.

(pho)