# 0.2.5.0 (2017-04-21)

* GHC 8.2 compatibility.

* Make `:.:` an instance of `Applicative`, `Foldable` and
  `Traversable`.

* Add functions `apInjs'_NP` and `apInjs'_POP`. These are
  variants of `apInjs_NP` and `apInjs'_POP` that return their
  result as an n-ary product, rather than collapsing it into
  a list.

* Add `hexpand` (and `expand_NS` and `expand_SOP`). These
  functions expand sums into products, given a default value
  to fill the other slots.

* Add utility functions such as `mapII` or `mapIK` that lift
  functions into different combinations of identity and
  constant functors.

* Add `NFData` (and lifted variants) instances for basic functors,
  products and sums.

# 0.2.4.0 (2017-02-02)

* Add `hindex` (and `index_NS` and `index_SOP`).

* Add `hapInjs` as a generalization of `apInjs_NP` and `apInjs_POP`.

* Make basic functors instances of lifted classes (such as `Eq1` etc).

# 0.2.3.0 (2016-12-04)

* Add various metadata getters

* Add `hdicts`.

* Add catamorphisms and anamorphisms for `NP` and `NS`.

* TH compatibility changes for GHC 8.1 (master).

# 0.2.2.0 (2016-07-10)

* Introduced `unZ` to destruct a unary sum.

* Add Haddock `@since` annotations for various functions.

# 0.2.1.0 (2016-02-08)

* Now includes a CHANGELOG.

* Should now work with ghc-8.0.1-rc1 and -rc2 (thanks to
  Oleg Grenrus).

* Introduced `hd` and `tl` to project out of a product, and
  `Projection` and `projections` as duals of `Injection` and
  `injections`.

# 0.2.0.0 (2015-10-23)

* Now tested with ghc-7.10

* Introduced names `hmap`, `hcmap`, `hzipWith`, `hczipWith` for
  `hliftA`, `hcliftA`, `hliftA2`, `hcliftA2`, respectively.
  Similarly for the specialized versions of these functions.

* The constraint transformers `All` and `All2` are now defined
  as type classes, not type families. As a consequence, the
  partial applications `All c` and `All2 c` are now possible.

* Because of the redefinition of `All` and `All2`, some special
  cases are no longer necessary. For example, `cpure_POP` can
  now be implemented as a nested application of `pure_NP`.

* Because of the redefinition of `All` and `All2`, the functions
  `hcliftA'` and variants (with prime!) are now deprecated.
  One can easily use the normal versions instead.
  For example, the definition of `hcliftA'` is now simply

      hcliftA' p = hcliftA (allP p)
        where
	      allP :: proxy c -> Proxy (All c)
		  allP _ = Proxy

* Because `All` and `All2` are now type classes, they now have
  superclass constraints implying that the type-level lists they
  are ranging over must have singletons.

      class (SListI xs,  ...) => All c xs
      class (SListI xss, ...) => All2 c xss

  Some type signatures can be simplified due to this.

* The `SingI` typeclass and `Sing` datatypes are now deprecated.
  The replacements are called `SListI` and `SList`.
  The `sing` method is now called `sList`. The difference
  is that the new versions reveal only the spine of the list, and
  contain no singleton representation for the elements anymore.

  For one-dimensional type-level lists, replace

      SingI xs => ... 

  by

      SListI xs => ...

  For two-dimensional type-level lists, replace

      SingI xss => ...

  by

      All SListI xss => ...

  Because All itself implies `SListI xss` (see above), this
  constraint is equivalent to the old `Sing xss`.

  The old names are provided for (limited) backward
  compatibility. They map to the new constructs. This will
  work in some, but not all scenarios.

  The function `lengthSing` has also been renamed to
  `lengthSList` for consistency, and the old name is
  deprecated.

* All `Proxy c` arguments have been replaced by `proxy c`
  flexible arguments, so that other type constructors can be
  used as proxies.

* Class-level composition (`Compose`), pairing (`And`), and
  a trivial constraint (`Top`) have been added. Type-level map
  (`Map`) has been removed. Occurrences such as

      All c (Map f xs)

  should now be replaced with

      All (c `Compose` f) xs

* There is a new module called `Generics.SOP.Dict` that contains
  functions for manipulating dictionaries explicitly. These can
  be used to prove theorems about non-trivial class constraints
  such as the ones that get built using `All` and `All2`. Some
  such theorems are provided.

* There is a new TH function `deriveGenericFunctions` that
  derives the code of a datatype and conversion functions, but
  does not create a class instance. (Contributed by Oleg Grenrus.)

* There is a new TH function `deriveMetadataValue` that
  derives a `DatatypeInfo` value for a datatype, but does
  not create an instance of `HasDatatypeInfo`. (Contributed by
  Oleg Grenrus.)

* There is a very simple example file. (Contributed by Oleg
  Grenrus.)

* The function `hcollapse` for `NS` now results in an `a` rather
  than an `I a`, matching the specialized version `collapse_NS`.
  (Suggested by Roman Cheplyaka.)

# 0.1.1.2 (2015-03-27)

* Updated version bounds for ghc-prim (for ghc-7.10).

# 0.1.1.1 (2015-03-20)

* Preparations for ghc-7.10.

* Documentation fix. (Contributed by Roman Cheplyaka.)

# 0.1.1 (2015-01-06)

* Documentation fixes.

* Add superclass constraint (TODO).

* Now derive tuple instance for tuples up to 30 components.
  (Contributed by Michael Orlitzky.)