security/hs-entropy: import hs-entropy-0.4.1.7

A mostly platform independent method to obtain cryptographically strong
entropy (RDRAND, urandom, CryptAPI, and patches welcome).

(pho)

security/Makefile: + hs-cryptohash-md5

(pho)

doc: Added security/hs-cryptohash-md5 version 0.11.101.0

(pho)

security/hs-cryptohash-md5: import hs-cryptohash-md5-0.11.101.0

A practical incremental and one-pass, pure API to the MD5 hash algorithm
(including HMAC support) with performance close to the fastest
implementations available in other languages.

The implementation is made in C with a haskell FFI wrapper that hides the C
implementation.

(pho)

devel/Makefile: + hs-sorted-list

(pho)

doc: Added devel/hs-sorted-list version 0.2.1.0

(pho)

devel/hs-sorted-list: import hs-sorted-list-0.2.1.0

Type-enforced sorted lists and related functions.

These are useful for:
* Constraining the argument of a function to be a sorted list by stating in
  your type that the input list is a sorted list.
* Avoiding sorting a list twice.
* Creating a list that is sorted from the moment of its construction, so it
  doesn't have to be sorted later.
* Performing list operations keeping the input list sorted.
* Improving those list operations that can be benefited from the ordering
  of its elements.
* Creating infinite lists that are sorted!
* And more!

(pho)

devel/Makefile: + hs-lsp-types

(pho)

doc: Added devel/hs-lsp-types version 1.4.0.1

(pho)

devel/hs-lsp-types: import hs-lsp-types-1.4.0.1

An implementation of the types to allow language implementors to support
the Language Server Protocol for their specific language.

(pho)

textproc/Makefile: + hs-rope-utf16-splay

(pho)

doc: Added textproc/hs-rope-utf16-splay version 0.3.2.0

(pho)

textproc/hs-rope-utf16-splay: import hs-rope-utf16-splay-0.3.2.0

Ropes optimised for updating using UTF-16 code units and row/column
pairs. This implementation uses splay trees instead of the usual finger
trees. According to my benchmarks, splay trees are faster in most
situations.

(pho)

math/Makefile: + hs-mod

(pho)

doc: Added math/hs-mod version 0.1.2.2

(pho)

math/hs-mod: import hs-mod-0.1.2.2

Modular arithmetic, promoting moduli to the type level, with an emphasis on
performance. Originally a part of arithmoi package.

(pho)

math/Makefile: + hs-semirings

(pho)

doc: Added math/hs-semirings version 0.6

(pho)

math/hs-semirings: import hs-semirings-0.6

Haskellers are usually familiar with monoids and semigroups. A monoid has
an appending operation <> (or mappend), and an identity element, mempty. A
semigroup has an appending <> operation, but does not require a mempty
element.

A Semiring has two appending operations, plus and times, and two respective
identity elements, zero and one.

More formally, a Semiring R is a set equipped with two binary relations +
and *, such that:
- (R,+) is a commutative monoid with identity element 0,
- (R,*) is a monoid with identity element 1,
- (*) left and right distributes over addition, and multiplication by '0'
  annihilates R.

(pho)

converters/Makefile: + hs-lens-aeson

(pho)

doc: Added converters/hs-lens-aeson version 1.1.3

(pho)

converters/hs-lens-aeson: import hs-lens-aeson-1.1.3

The goal of lens-aeson is to provide traversals and prisms for the Aeson
library's Value type, while obeying the Traversal/Prism laws.

(pho)

devel/Makefile: + hs-lens

(pho)

doc: Added devel/hs-lens version 5.1

(pho)

devel/hs-lens: import hs-lens-5.1

This package provides families of lenses, isomorphisms, folds, traversals,
getters and setters.

(pho)

devel/Makefile: + hs-parallel

(pho)

doc: Added devel/hs-parallel version 3.2.2.0

(pho)

devel/hs-parallel: import hs-parallel-3.2.2.0

This package provides a library for parallel programming in Haskell.

(pho)

math/Makefile: + hs-kan-extensions

(pho)

doc: Added math/hs-kan-extensions version 5.2.3

(pho)

math/hs-kan-extensions: import hs-kan-extensions-5.2.3

This package provides tools for working with various Kan extensions and Kan
lifts in Haskell.

Among the interesting bits included are:
* Right and left Kan extensions (Ran and Lan)
* Right and left Kan lifts (Rift and Lift)
* Multiple forms of the Yoneda lemma (Yoneda)
* The Codensity monad, which can be used to improve the asymptotic
  complexity of code over free monads (Codensity, Density)
* A "comonad to monad-transformer transformer" that is a special case of a
  right Kan lift. (CoT, Co)

(pho)

math/Makefile: + hs-invariant

(pho)

doc: Added math/hs-invariant version 0.5.5

(pho)

math/hs-invariant: import hs-invariant-0.5.5

Haskell98 invariant functors (also known as exponential functors).

(pho)

math/Makefile: + hs-adjunctions

(pho)

doc: Added math/hs-adjunctions version 4.4

(pho)

math/hs-adjunctions: import hs-adjunctions-4.4

This package provides adjunctions for Haskell.

(pho)

devel/Makefile: + hs-hls-graph

(pho)

doc: Added devel/hs-hls-graph version 1.6.0.0

(pho)

devel/hs-hls-graph: import hs-hls-graph-1.6.0.0

ghcide was originally built on top of Shake, a Haskell build
system. Nowadays Shake has been replaced by a special purpose
implementation of a build graph called hls-graph, which drops all the
persistency features in exchange for simplicity and performance.

(pho)

devel/Makefile: + hs-stm-containers

(pho)

doc: Added devel/hs-stm-containers version 1.2

(pho)

devel/hs-stm-containers: import hs-stm-containers-1.2

This library is based on an STM-specialized implementation of Hash Array
Mapped Trie. It provides efficient implementations of Map, Set and other
data structures, which starting from version 1 perform even better than
their counterparts from "unordered-containers", but also scale well on
concurrent access patterns.

(pho)

devel/Makefile: + hs-stm-hamt

(pho)

doc: Added devel/hs-stm-hamt version 1.2.0.7

(pho)

devel/hs-stm-hamt: import hs-stm-hamt-1.2.0.7

A low-level data-structure, which can be used to implement higher-level
interfaces like hash-map and hash-set. Such implementations are presented
by the "stm-containers" library.

(pho)

devel/Makefile: + hs-primitive-extras

(pho)

doc: Added devel/hs-primitive-extras version 0.10.1.4

(pho)

devel/hs-primitive-extras: import hs-primitive-extras-0.10.1.4

Extras for the "primitive" library

(pho)

devel/Makefile: + hs-primitive-unlifted

(pho)

doc: Added devel/hs-primitive-unlifted version 0.1.3.1

(pho)

devel/hs-primitive-unlifted: import hs-primitive-unlifted-0.1.3.1

Primitive GHC types with unlifted types inside. There used to be a module
named Data.Primitive.UnliftedArray in the primitive library. However, it
turns out that it is impossible to write such an API safely in versions of
GHC before 8.10.1, thanks to some nasty interactions between unsafe
coercions and the foreign function interface. This package also uses a
somewhat different, and more flexible, approach than that module did.

(pho)

devel/Makefile: + hs-deferred-folds

(pho)

doc: Added devel/hs-deferred-folds version 0.9.18.1

(pho)

devel/hs-deferred-folds: import hs-deferred-folds-0.9.18.1

This library provides sbstractions over deferred folds.

(pho)

devel/Makefile: + hs-list-t

(pho)

doc: Added devel/hs-list-t version 1.0.5.1

(pho)

devel/hs-list-t: import hs-list-t-1.0.5.1

A correct implementation of the list monad-transformer. Useful for basic
streaming.

(pho)

devel/Makefile: + hs-logict

(pho)

doc: Added devel/hs-logict version 0.7.1.0

(pho)

devel/hs-logict: import hs-logict-0.7.1.0

Adapted from the paper "Backtracking, Interleaving, and Terminating Monad
Transformers" by Oleg Kiselyov, Chung-chieh Shan, Daniel P. Friedman, Amr
Sabry.

(pho)

devel/Makefile: + hs-foldl

(pho)

doc: Added devel/hs-foldl version 1.4.12

(pho)

devel/hs-foldl: import hs-foldl-1.4.12

This library provides strict left folds that stream in constant memory, and
you can combine folds using Applicative style to derive new folds. Derived
folds still traverse the container just once and are often as efficient as
hand-written folds.

(pho)

www/Makefile: + hs-js-dgtable

(pho)

doc: Added www/hs-js-dgtable version 0.5.2

(pho)

www/hs-js-dgtable: import hs-js-dgtable-0.5.2

This package bundles the minified jquery.dgtable code into a Haskell
package, so it can be depended upon by Cabal packages. The first three
components of the version number match the upstream jquery.dgtable
version. The package is designed to meet the redistribution requirements of
downstream users (e.g. Debian).

(pho)

devel/Makefile: + hs-hiedb

(pho)

doc: Added devel/hs-hiedb version 0.4.1.0

(pho)

devel/hs-hiedb: import hs-hiedb-0.4.1.0

Tool and library to index and query a collection of ".hie" files.

(pho)

databases/Makefile: + hs-sqlite-simple

(pho)

doc: Added databases/hs-sqlite-simple version 0.4.18.0

(pho)

databases/hs-sqlite-simple: import hs-sqlite-simple-0.4.18.0

This library is a mid-level Haskell binding to the SQLite database.

Sqlite-simple provides a convenient API to sqlite that does some level of
automatic data conversion between the database and Haskell types. The API
has been modeled directly after postgresql-simple which in turn borrows
from mysql-simple.

(pho)

databases/Makefile: + hs-direct-sqlite

(pho)

doc: Added databases/hs-direct-sqlite version 2.3.26

(pho)

databases/hs-direct-sqlite: import hs-direct-sqlite-2.3.26

This package is not very different from the other SQLite3 bindings out
there, but it fixes a few deficiencies I was finding. As compared to
bindings-sqlite3, it is slightly higher-level, in that it supports
marshalling of data values to and from the database. In particular, it
supports strings encoded as UTF8, and BLOBs represented as ByteStrings.

(pho)

devel/Makefile: + hs-blaze-textual

(pho)

doc: Added devel/hs-blaze-textual version 0.2.2.1

(pho)

devel/hs-blaze-textual: import hs-blaze-textual-0.2.2.1

blaze-textual is a fast Haskell library for rendering common Haskell
datatypes in text form using the blaze-builder library.

(pho)

math/Makefile: + hs-algebraic-graphs

(pho)

doc: Added math/hs-algebraic-graphs version 0.6

(pho)

math/hs-algebraic-graphs: import hs-algebraic-graphs-0.6

A library for algebraic construction and manipulation of graphs in Haskell.

(pho)

devel/Makefile: + hs-hie-compat

(pho)

doc: Added devel/hs-hie-compat version 0.2.1.1

(pho)

devel/hs-hie-compat: import hs-hie-compat-0.2.1.1

Backports for HIE files to GHC 8.6, along with a few other backports of HIE
file related fixes for ghcide. THIS DOES NOT LET YOU READ HIE FILES WITH
MISMATCHED VERSIONS OF GHC.

(pho)

devel/Makefile: + hs-hie-bios

(pho)

doc: Added devel/hs-hie-bios version 0.8.1

(pho)

devel/hs-hie-bios: import hs-hie-bios-0.8.1

hie-bios is the way to specify how haskell-language-server and ghcide set
up a GHC API session.

Given a Haskell project that is managed by Stack, Cabal, or other package
tools, haskell-language-server needs to know the full set of flags to pass
to GHC in order to build the project. These flags might contain some
compilation options like -O2, but a lot of the time they are package
dependencies such as -package-id directory-1.3.6.0, which also need to be
built beforehand. hie-bios satisfies both these needs.

(pho)

sysutils/Makefile: + hs-hslogger

(pho)

doc: Added sysutils/hs-hslogger version 1.3.1.0

(pho)

sysutils/hs-hslogger: import hs-hslogger-1.3.1.0

hslogger is a logging framework for Haskell, roughly similar to Python's
logging module.

hslogger lets each log message have a priority and source be associated
with it. The programmer can then define global handlers that route or
filter messages based on the priority and source. hslogger also has a
Syslog handler built in.

(pho)

net/Makefile: + hs-network-bsd

(pho)

doc: Added net/hs-network-bsd version 2.8.1.0

(pho)

net/hs-network-bsd: import hs-network-bsd-2.8.1.0

This package provides Haskell bindings to the the POSIX network database
(netdb.h) API.

(pho)

devel/Makefile: + hs-ghc-trace-events

(pho)

doc: Added devel/hs-ghc-trace-events version 0.1.2.4

(pho)

devel/hs-ghc-trace-events: import hs-ghc-trace-events-0.1.2.4

ghc-trace-events provides faster traceEvent and traceMarker as well as
arbitrary binary object logging for the eventlog framework. Unlike the
eventlog tracing functions in base, all the tracing functions in this
library don't evaluate the input if user event logging (the -lu flag) is
disabled, which can give a significant boost in performance.

(pho)

devel/Makefile: + hs-ghc-exactprint

(pho)

doc: Added devel/hs-ghc-exactprint version 1.5.0

(pho)

devel/hs-ghc-exactprint: import hs-ghc-exactprint-1.5.0

Using the API Annotations available from GHC 9.2.1, this library provides a
means to round trip any code that can be compiled by GHC, currently
excluding lhs files.

(pho)

devel/hs-ordered-containers: import hs-ordered-containers-0.2.2

This library provides Set- and Map-like types that remember the order
elements were inserted.

(pho)

devel/Makefile: + hs-ordered-containers

(pho)

doc: Added devel/hs-ordered-containers version 0.2.2

(pho)

math/Makefile: + hs-free

(pho)

doc: Added math/hs-free version 5.1.7

(pho)

math/hs-free: import hs-free-5.1.7

Free monads are useful for many tree-like structures and domain specific
languages.

If f is a Functor then the free Monad on f is the type of trees whose nodes
are labeled with the constructors of f. The word "free" is used in the
sense of "unrestricted" rather than "zero-cost": Free f makes no
constraining assumptions beyond those given by f and the definition of
Monad. As used here it is a standard term from the mathematical theory of
adjoint functors.

Cofree comonads are dual to free monads. They provide convenient ways to
talk about branching streams and rose-trees, and can be used to annotate
syntax trees. The cofree comonad can be seen as a stream parameterized by a
Functor that controls its branching factor.

(pho)

devel/Makefile: + hs-ghc-check

(pho)

doc: Added devel/hs-ghc-check version 0.5.0.6

(pho)

devel/hs-ghc-check: import hs-ghc-check-0.5.0.6

A library to detect mismatches between compile-time and run-time versions
of the GHC API.

(pho)

devel/Makefile: + hs-safe-exceptions

(pho)

doc: Added devel/hs-safe-exceptions version 0.1.7.2

(pho)

devel/hs-safe-exceptions: import hs-safe-exceptions-0.1.7.2

This package provides additional safety and simplicity versus
Control.Exception by having its functions recognize the difference between
synchronous and asynchronous exceptions. As described below, synchronous
exceptions are treated as recoverable, allowing you to catch and handle
them as well as clean up after them, whereas asynchronous exceptions can
only be cleaned up after. In particular, this library prevents you from
making the following mistakes:

* Catching and swallowing an asynchronous exception
* Throwing an asynchronous exception synchronously
* Throwing a synchronous exception asynchronously
* Swallowing asynchronous exceptions via failing cleanup handlers

(pho)

textproc/Makefile: + hs-fuzzy

(pho)

doc: Added textproc/hs-fuzzy version 0.1.0.1

(pho)

textproc/hs-fuzzy: import hs-fuzzy-0.1.0.1

Fuzzy string search in Haskell. Uses TextualMonoid to be able to run on
different types of strings.

(pho)

math/Makefile: + hs-monoid-subclasses

(pho)

doc: Added math/hs-monoid-subclasses version 1.1.3

(pho)

math/hs-monoid-subclasses: import hs-monoid-subclasses-1.1.3

A hierarchy of subclasses of Monoid together with their instances for all
data structures from base, containers, and text packages.

(pho)

math/Makefile: + hs-primes

(pho)

doc: Added math/hs-primes version 0.2.1.0

(pho)

math/hs-primes: import hs-primes-0.2.1.0

This Haskell library provides an efficient lazy wheel sieve for prime
generation inspired by "Lazy wheel sieves and spirals of primes" by Colin
Runciman and "The Genuine Sieve of Eratosthenes" by Melissa O'Neil.

(pho)

devel/Makefile: + hs-focus

(pho)

doc: Added devel/hs-focus version 1.0.3

(pho)

devel/hs-focus: import hs-focus-1.0.3

An API for construction of free-form strategies of access and manipulation
of elements of arbitrary data structures. It allows to implement efficient
composite patterns, e.g., a simultaneous update and lookup of an element,
and even more complex things.

Strategies are meant to be interpreted by the host data structure
libraries. Thus they allow to implement all access and modification
patterns of a data structure with just a single function, which interprets
strategies.

This library provides pure and monadic interfaces, so it supports both
immutable and mutable data structures.

(pho)

devel/Makefile: + hs-dependent-map

(pho)

doc: Added devel/hs-dependent-map version 0.4.0.0

(pho)

devel/hs-dependent-map: import hs-dependent-map-0.4.0.0

Provides a type called DMap which generalizes Data.Map.Map, allowing keys
to specify the type of value that can be associated with them.

(pho)

devel/Makefile: + hs-dependent-sum

(pho)

doc: Added devel/hs-dependent-sum version 0.7.1.0

(pho)

devel/hs-dependent-sum: import hs-dependent-sum-0.7.1.0

A dependent sum is a generalization of a particular way of thinking about
the Either type. Either a b can be thought of as a 2-tuple (tag, value),
where the value of the tag determines the type of the value. In particular,
either tag = Left and value :: a or tag = Right and value :: b.

This package allows you to define your own dependent sum types by using
your own "tag" types.

(pho)

devel/Makefile: + hs-some

(pho)

doc: Added devel/hs-some version 1.0.3

(pho)

devel/hs-some: import hs-some-1.0.3

This library defines an existential type Some.

data Some f where
    Some :: f a -> Some f

in few variants, and utilities to work with it.

If you are unsure which variant to use, use the one in Data.Some module.

(pho)

+hs-constraints-extras

(pho)

doc: Added devel/hs-constraints-extras version 0.3.2.1

(pho)

devel/hs-constraints-extras: import hs-constraints-extras-0.3.2.1

Convenience functions and TH for working with constraints.

(pho)

+hs-cryptohash-sha1

(pho)

doc: Added security/hs-cryptohash-sha1 version 0.11.101.0

(pho)

security/hs-cryptohash-sha1: import hs-cryptohash-sha1-0.11.101.0

A practical incremental and one-pass, pure API to the SHA-1 hash algorithm
(including HMAC support) with performance close to the fastest
implementations available in other languages.

The implementation is made in C with a haskell FFI wrapper that hides the C
implementation.

(pho)

doc: Updated devel/darcs to 2.16.4

(pho)

Update to darcs-2.16.4

The list of changes since 2.0.2 is too long to paste here:
https://hackage.haskell.org/package/darcs-2.16.4/changelog

(pho)

+hs-regex-compat-tdfa

(pho)

doc: Added textproc/hs-regex-compat-tdfa version 0.95.1.4

(pho)

textproc/hs-regex-compat-tdfa: import hs-regex-compat-tdfa-0.95.1.4

This package provide a fork of the regex-compat package which supports
Unicode.

(pho)

+hs-regex-applicative

(pho)

doc: Added textproc/hs-regex-applicative version 0.3.4

(pho)

textproc/hs-regex-applicative: import hs-regex-applicative-0.3.4

regex-applicative is a Haskell library for parsing using regular
expressions. Parsers can be built using Applicative interface.

(pho)

+hs-filtrable

(pho)

doc: Added devel/hs-filtrable version 0.1.6.0

(pho)

devel/hs-filtrable: import hs-filtrable-0.1.6.0

Class of filtrable containers, i.e. containers we can map over while
selectively dropping elements.

(pho)

+hs-data-ordlist

(pho)

doc: Added devel/hs-data-ordlist version 0.4.7.0

(pho)

devel/hs-data-ordlist: import hs-data-ordlist-0.4.7.0

This module provides set and multiset operations on ordered lists.

(pho)

+hs-constraints

(pho)

doc: Added devel/hs-constraints version 0.13.3

(pho)

devel/hs-constraints: import hs-constraints-0.13.3

GHC 7.4 gave us the ability to talk about ConstraintKinds. They stopped
crashing the compiler in GHC 7.6.

This package provides a vocabulary for working with them.

(pho)

+hs-type-equality

(pho)

doc: Added devel/hs-type-equality version 1

(pho)

devel/hs-type-equality: import hs-type-equality-1

This library defines a propositional equality data type, shims
Data.Type.Equality as well as possible for older GHCs (< 7.8).

(pho)

Mark the package as not supporting MKPIE

Not sure if it really doesn't support PIE, but it's an obsolete compiler
anyway.

(pho)

Fix a broken CVS tag

(pho)

revbump after changing the default Haskell compiler

(pho)

mk/haskell.mk: Switch the default Haskell compiler to lang/ghc92

(pho)

Import unicode-data-0.3.0

unicode-data provides Haskell APIs to efficiently access the Unicode
character database. Performance is the primary goal in the design of this
package.

The Haskell data structures are generated programmatically from the Unicode
character database (UCD) files.

(pho)

Add a comment

(pho)

Remove a workaround for old haddock

(pho)

Added missing PLIST

(pho)

doc: Updated net/hoogle to 5.0.18.3

(pho)

Update to hoogle-5.0.18.3

5.0.18.3, released 2021-12-24
    Compatibility with aeson-2.0
5.0.18.2, released 2021-09-01
    Compatibility with extra-1.7.10
    #370, add --jsonl to produce JSON on separate lines

(pho)

doc: Updated converters/pandoc to 2.17.1.1

(pho)

Update to pandoc-2.17.1.1

The list of changes since 2.13 is too long to paste here:
https://hackage.haskell.org/package/pandoc-2.17.1.1/changelog

(pho)

+hs-pandoc-lua-marshal

(pho)

doc: Added devel/hs-pandoc-lua-marshal version 0.1.4

(pho)

devel/hs-pandoc-lua-marshal: import hs-pandoc-lua-marshal-0.1.4

This package provides functions to marshal and unmarshal pandoc document
types to and from Lua.

The values of most types are pushed to pandoc as "userdata" objects that
wrap a stable pointer to the Haskell value; these objects come with methods
to access and modify their properties.

Sequences are pushed as normal Lua tables, but are augmented with
convenience functions.

(pho)

+hs-lpeg

(pho)

doc: Added devel/hs-lpeg version 1.0.2

(pho)

devel/hs-lpeg: import hs-lpeg-1.0.2

This package contains the C sources of LPeg, as well as some tiny Haskell
helper to load the package.

(pho)

+hslua-module-version

(pho)

doc: Added devel/hs-hslua-module-version version 1.0.1

(pho)

devel/hs-hslua-module-version: import hs-hslua-module-version-1.0.1

Wrapper for the Data.Version.Version Haskell type.

(pho)

+hs-hslua-aeson

(pho)

doc: Added converters/hs-hslua-aeson version 2.1.0

(pho)

converters/hs-hslua-aeson: import hs-hslua-aeson-2.1.0

This package provides instances to push and receive any datatype encodable
as JSON to and from the Lua stack.

(pho)

doc: Updated textproc/hs-citeproc to 0.6.0.1

(pho)

Update to citeproc-0.6.0.1

0.6.0.1
* Ensure that position evaluates false inside bibliography (#99).

0.6
* Add Term parameter to TagTerm [API change].
* Add TagPrefix, TagSuffix constructors to Tag [API change].
* Make sure that extracted AuthorOnly names have the correct formatting
  (#55).
* Do case-insensitive sorting, like Zotero (#91).
* Ignore "ibid" entries in computing ambiguities.
* Improved disambiguation for author-in-text citations.
* In disambiguating, convert author-in-text to normal citations. Otherwise
  we disambiguate incorrectly.
* Fix title disambiguation with note style (#90). Previously we'd been
  calculating ambiguities by generating renderings for citation items
  independently of context. This meant that we didn't detect ambiguities in
  "subsequent" citations (which might e.g. just have an author).
* Ensure we don't do collapsing of items across a prefix or suffix
  (#89). If we have [@doe99; for contrasting views see @smith33; @doe00],
  we don't want to get collapsing to (Doe 1999, 2000; for contrasting
  views, see Smith 1933). This isn't strictly by the spec, but it gives
  better results.
* Allow collapsing after an initial prefix.

0.5
* Add linkBibliography field to CiteprocOptions [API change]. When this is
  set to True, we hyperlink bibliography entries according to the draft of
  the CSL v1.02 spec (Appendix VI). When an entry has a DOI, PMCID, PMID,
  or URL available but none of these are rendered by the style, add a link
  to the title (or, if no title is present, the whole entry), using the URL
  for the DOI, PMCID, PMID, or URL (in that order of priority). (Benjamin
  Bray, #88.)
* In generating citation labels, only use issued date. Not, for example,
  accessed (#80).
* Citeproc.Locale: export lookupQuotes. [API change]
* Citeproc.Types: Add localizeQuotes method to CiteprocOutput class [API
  change].
* Citeproc.CslJson, Citeproc.Pandoc: Implement localizeQuotes.
* Citeproc: apply localizeQuotes after rendering. This ensures that quotes
  are properly localized and flipflopped. Previously this was done in
  renderCslJson (for CSL JSON) and in pandoc (for Pandoc Inlines). It is
  more consistent to do this as part of the rendering pipeline, in citeproc
  itself.
* Citeproc.CslJson: Drop the Locale parameter from the signature of
  renderCslJson [breaking API change]. It was only needed for quote
  localization, which now occurs outside of this function.
* Citeproc.Pandoc: use a Span with class csl-quoted for quotes, rather than
  a Quoted inline. This way we can leave Quoted elements passed in by
  pandoc alone, and we won't get strange effects like the one described in
  #87 (where " behaves differently when in a citation suffix).
* Default to Shifted with icu flag (#83). This makes the library behave
  similarly whether compiled with icu or with the default unicode-collation
  and prevents test failures with icu.
* Require recent text-icu with icu flag. Older versions don't build with
  newer versions of icu4c.
* Support links in CslJson (Benjamin Bray). Currently they are only
  supported in rendering, not parsing (in support of #88).
* Allow test cases to specify CiteprocOptions (Benjamin Bray).
* Update locales from upstream.
* Add new CSL tests to repository.

0.4.1
* Change Pandoc inNote so it creates a Span with class csl-note rather than
  a Note. This should make it easier to integrate citations with ordinary
  notes in pandoc.
* Do not hyperlink author-only citations (#77). If we do this we get two
  consecutive hyperlinks for author-in-text forms.
* movePunctuationInsideQuotes: only move , and ., not ? and !, as per the
  CSL spec.

0.4.0.1
* Fix bug introduced by the fix to #61 (#74). In certain circumstances, we
  could get doubled "et al.".
* Depend on unicode-collation unconditionally (#71). It is necessary even
  when text-icu is used, because of Text.Collate.Lang.
* Rename tests in extra/ so they fall into categories.

0.4
* We now use Lang from unicode-collation rather than defining our own. The
  type constructor has changed, as has the signature of parseLang.
* Use unicode-collation by default for more accurate sorting.
  * text-icu will still be used if the icu flag is set. This may give
    better performance, at the cost of depending on a large C library.
  * Change type of SortKeyValue so it doesn't embed Lang. [API change]
    Instead, we now store a language-specific collator in the Eval Context.
  * Move compSortKeyValues from Types to Eval.
  * Add curly open quote to word splitters in normalizeSortKey.
  * Improve date sorting: use the format YYYY0000 if no month, day, and
    YYYYMM00 if no day when generating sort keys.
  * Special treatment of literal "others" as last name in a list
    (#61). When we convert bibtex/biblatex bibliographies, the form "and
    others" yields a last name with nameLiteral = "others". We detect this
    and generate a localized "and others" (et al).
  * Make abbreviations case-insensitive (#45).

(pho)

+hs-unicode-collation

(pho)

doc: Added textproc/hs-unicode-collation version 0.1.3.1

(pho)

textproc/hs-unicode-collation: import hs-unicode-collation-0.1.3.1

This library provides a pure Haskell implementation of the Unicode
Collation Algorithm described at http://www.unicode.org/reports/tr10/. It
is not as fully-featured or as performant as text-icu, but it avoids a
dependency on a large C library. Locale-specific tailorings are also
provided.

(pho)

+hs-th-lift-instances

(pho)

doc: Added devel/hs-th-lift-instances version 0.1.19

(pho)

devel/hs-th-lift-instances: import hs-th-lift-instances-0.1.19

Most data types in the haskell platform do not have Lift instances. This
package provides orphan instances for containers, text, bytestring and
vector. It also provides compat instances for older versions of
template-haskell.

(pho)

doc: Updated textproc/hs-texmath to 0.12.4

(pho)

Update to texmath-0.12.4

texmath (0.12.4)

  * TeX reader: handle hyperref better (#186).  We don't parse it as a link,
    but we pass its contents through rather than failing.

  * Update scripts and data in `lib/` directory. These are not build
    dependencies, but they were used to produce some of the large
    tables in the source code.  Fixed the scripts and Makefile to work
    with recent texmath and cabal.  Removed two very large unicode data
    files that can be downloaded when needed.  (This reduces the size of
    the source tarball considerably.) Remove `lib/toascii` (no longer used).

  * Update MMLDict using latest unicode.xml.

  * TeX reader: support siunitx `\qty`, `\qtyrange`, `\unit` (#185).

  * Remove Text.TeXMath.Compat.  We can now safely require mtl >= 2.2.1.

  * Use symbolMap from ToTeX to shorten the long hardcoded symbols list.
    Now we only hard-code items that differ what what is in symbolMap.
    This reduces the code size by thousands of lines.

  * Unicode.ToTeX: export `symbolMap` [API change].  This uses the data in
  `records` to create a backwards mapping from TeX commands to Exps (ESymbol
      elements).  This can replace most of the hardcoded list in the current
  TeX reader.

  * Split out TeXMath.Readers.TeX.Commands internal module.
    This makes the TeX reader shorter and should help compile times.

  * OMML reader: better handling of m:t nodes (#151).
    Previously we parsed an m:t element as an EIdentifier if it contains a
    single letter, but an EText TextNormal if it contains more than one.  This
    gave bad results in some cases.  It is better to reserve EText for the
    case where the m:nor property is specified for "normal text."

  * Require base >= 4.11.

  * Remove `network-uri` flag from stack.yaml.

texmath (0.12.3.3)

  * OMML writer: use nary only for operators supported by LibreOffice
    (Albert Krewinkel).  LibreOffice (and possibly Word, too) can handle
    only a small set of operators in an `nary` element.

  * TeX writer: use `\xleftarrow`, `\xrightarrow` where sensible
    (Albert Krewinkel).  The commands are generated for expressions over `���`
    or `���`. Besides being more idiomatic, this change also prevents the
    generation of invalid LaTeX, as `\leftarrow` and `\rightarrow` are not
    math operators and hence may not be followed by `\limit`.
    Both commands are part of amsmath.sty.

  * TeX reader:

    + Improve angled-bracket support (Albert Krewinkel).
      The amsmath package allows `\left<` and `\right>` as alternatives to
      `\left\langle` and `\right\rangle`, respectively.
    + Ignore stared version of `\tag` (Albert Krewinkel).
    + Support \dots{c,b,m,i,o} from amsmath (#179).
    + Change symbol returned for \dots{b,i,m} from `���` to `���`
      (Albert Krewinkel).

texmath (0.12.3.2)

  * OMML writer: remove m:nor element in math operators (#178).
    This caused the document's main font, rather than the math
    font, to be used in formatting operators, which is undesirable.

texmath (0.12.3.1)

  * MathML reader: don't allow mfenced attributes to inherit (#177).
    When open and close attributes aren't given on an mfenced,
    we should use defaults rather than inheriting these from a
    parent mfenced.

texmath (0.12.3)

  * TeX reader: implement logic to convert a Bin symbol to
    an Op to Op when it occurs at the beginning of a group,
    or after an Open, Pun, or Op symbol. This will give much
    better results for unary `-` (#176).

  * OMML writer: fixed rendering of EDelimited (#173).
    We now properly render "middles" (separators).

(pho)

doc: Updated www/hs-http-client-tls to 0.3.6

(pho)

Update to http-client-tls-0.3.6.1

0.3.6.1
    #482: Raise lower bound on http-client to fix build.

0.3.6
    Allow making requests to raw IPv6 hosts #477

(pho)

doc: Updated finance/hledger to 1.24.1

(pho)

Update to hledger-1.24.1

The list of changes since 1.21 is too long to paste here:
https://hackage.haskell.org/package/hledger-1.24.1/changelog

(pho)

+hs-githash

(pho)

doc: Added devel/hs-githash version 0.1.6.2

(pho)

devel/hs-githash: import hs-githash-0.1.6.2

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)