Metadata revisions for ghc-instances-0.1.0.0

Package maintainers and Hackage trustees are allowed to edit certain bits of package metadata after a release, without uploading a new tarball. Note that the tarball itself is never changed, just the metadata that is stored separately. For more information about metadata revisions, please refer to the Hackage Metadata Revisions FAQ.

No. Time User Changes
-r2 Wed Jan 17 14:12:44 UTC 2018 clinton
  • Changed homepage

    https://github.com/clintonmead/ghc-instances#readme

  • Changed description from

    This package simply has a number of modules which import all the modules
    from each package that is distributed with GHC.
    
    There's also a module "Control.Instances.GHC_Packages", that imports all of the
    above modules, essentially importing every module distributed with GHC.
    
    Why would you want to do this?
    
    Lets say I've got a data type \"D a\". And a class \"C\".
    
    Further, lets say I can define \"C (D a)\" if "a" is of class \"C1\".
    I can also \"C (D a)\" if "a" is of class \"C2\"
    
    Lets try:
    
    instance C1 a => C (D a) where ...
    
    instance C2 a => C (D a) where ...
    
    These are going to be overlapping. We can't do this.
    
    But instead, we import "Control.Instances.GHC_Packages". And then we can use
    [reify](https://hackage.haskell.org/package/template-haskell-2.12.0.0/docs/Language-Haskell-TH.html#v:reify)
    from [Template Haskell](https://hackage.haskell.org/package/template-haskell-2.12.0.0)
    to bring every \"C1\" and \"C2\" instance in to scope that's defined anywhere in "base"
    or any GHC module.
    
    We can then use Template Haskell to define all our instances. We can explicitly define what happens
    when both \"C1\" and \"C2\" instances are defined, perhaps prefering one over the other.
    
    As we've got the full power of Haskell in Template Haskell, we can do these manipulations.
    
    The package [static-closure](https://hackage.haskell.org/package/static-closure)
    is an example of using these instances to generate it's own instances for it's data type.
    
    This package will need to be updated with each release of GHC but currently the
    cabal file and modules should contain appropriate pre-processor directives that
    this package should work from least from GHC 7.8 to GHC 8.2.homepage:            https://github.com/clintonmead/ghc-instances#readme
    to
    This package simply has a number of modules which import all the modules
    from each package that is distributed with GHC.
    
    There's also a module "Control.Instances.GHC_Packages", that imports all of the
    above modules, essentially importing every module distributed with GHC.
    
    Why would you want to do this?
    
    Lets say I've got a data type \"D a\". And a class \"C\".
    
    Further, lets say I can define \"C (D a)\" if "a" is of class \"C1\".
    I can also \"C (D a)\" if "a" is of class \"C2\"
    
    Lets try:
    
    instance C1 a => C (D a) where ...
    
    instance C2 a => C (D a) where ...
    
    These are going to be overlapping. We can't do this.
    
    But instead, we import "Control.Instances.GHC_Packages". And then we can use
    [reify](https://hackage.haskell.org/package/template-haskell-2.12.0.0/docs/Language-Haskell-TH.html#v:reify)
    from [Template Haskell](https://hackage.haskell.org/package/template-haskell-2.12.0.0)
    to bring every \"C1\" and \"C2\" instance in to scope that's defined anywhere in "base"
    or any GHC module.
    
    We can then use Template Haskell to define all our instances. We can explicitly define what happens
    when both \"C1\" and \"C2\" instances are defined, perhaps prefering one over the other.
    
    As we've got the full power of Haskell in Template Haskell, we can do these manipulations.
    
    The package [static-closure](https://hackage.haskell.org/package/static-closure)
    is an example of using these instances to generate it's own instances for it's data type.
    
    This package will need to be updated with each release of GHC but currently the
    cabal file and modules should contain appropriate pre-processor directives that
    this package should work from least from GHC 7.8 to GHC 8.2.

-r1 Wed Jan 17 14:12:08 UTC 2018 clinton
  • Changed homepage

    https://github.com/clintonmead/ghc-instances#readme

  • Changed description from

    This package simply has a number of modules which import all the modules
    from each package that is distributed with GHC.
    There's also a module "Control.Instances.GHC_Packages", that imports all of the
    above modules, essentially importing every module distributed with GHC.
    Why would you want to do this?
    Lets say I've got a data type \"D a\". And a class \"C\".
    Further, lets say I can define \"C (D a)\" if "a" is of class \"C1\".
    I can also \"C (D a)\" if "a" is of class \"C2\"
    Lets try:
    instance C1 a => C (D a) where ...
    instance C2 a => C (D a) where ...
    These are going to be overlapping. We can't do this.
    But instead, we import "Control.Instances.GHC_Packages". And then we can use
    [reify](https://hackage.haskell.org/package/template-haskell-2.12.0.0/docs/Language-Haskell-TH.html#v:reify)
    from [Template Haskell](https://hackage.haskell.org/package/template-haskell-2.12.0.0)
    to bring every \"C1\" and \"C2\" instance in to scope that's defined anywhere in "base"
    or any GHC module.
    We can then use Template Haskell to define all our instances. We can explicitly define what happens
    when both \"C1\" and \"C2\" instances are defined, perhaps prefering one over the other.
    As we've got the full power of Haskell in Template Haskell, we can do these manipulations.
    The package [static-closure](https://hackage.haskell.org/package/static-closure)
    is an example of using these instances to generate it's own instances for it's data type.
    This package will need to be updated with each release of GHC but currently the
    cabal file and modules should contain appropriate pre-processor directives that
    this package should work from least from GHC 7.8 to GHC 8.2.
    to
    This package simply has a number of modules which import all the modules
    from each package that is distributed with GHC.
    
    There's also a module "Control.Instances.GHC_Packages", that imports all of the
    above modules, essentially importing every module distributed with GHC.
    
    Why would you want to do this?
    
    Lets say I've got a data type \"D a\". And a class \"C\".
    
    Further, lets say I can define \"C (D a)\" if "a" is of class \"C1\".
    I can also \"C (D a)\" if "a" is of class \"C2\"
    
    Lets try:
    
    instance C1 a => C (D a) where ...
    
    instance C2 a => C (D a) where ...
    
    These are going to be overlapping. We can't do this.
    
    But instead, we import "Control.Instances.GHC_Packages". And then we can use
    [reify](https://hackage.haskell.org/package/template-haskell-2.12.0.0/docs/Language-Haskell-TH.html#v:reify)
    from [Template Haskell](https://hackage.haskell.org/package/template-haskell-2.12.0.0)
    to bring every \"C1\" and \"C2\" instance in to scope that's defined anywhere in "base"
    or any GHC module.
    
    We can then use Template Haskell to define all our instances. We can explicitly define what happens
    when both \"C1\" and \"C2\" instances are defined, perhaps prefering one over the other.
    
    As we've got the full power of Haskell in Template Haskell, we can do these manipulations.
    
    The package [static-closure](https://hackage.haskell.org/package/static-closure)
    is an example of using these instances to generate it's own instances for it's data type.
    
    This package will need to be updated with each release of GHC but currently the
    cabal file and modules should contain appropriate pre-processor directives that
    this package should work from least from GHC 7.8 to GHC 8.2.homepage:            https://github.com/clintonmead/ghc-instances#readme

-r0 Wed Jan 17 14:10:47 UTC 2018 clinton