name:           reflection
version:        1.5.2
x-revision: 1
license:        BSD3
license-file:   LICENSE
author:         Edward A. Kmett, Elliott Hird, Oleg Kiselyov and Chung-chieh Shan
maintainer:     Edward A. Kmett <ekmett@gmail.com>
stability:      experimental
homepage:       http://github.com/ekmett/reflection
bug-reports:    http://github.com/ekmett/reflection/issues
category:       Data, Reflection, Dependent Types
synopsis:       Reifies arbitrary terms into types that can be reflected back into terms
copyright:      2009-2013 Edward A. Kmett,
                2012 Elliott Hird,
                2004 Oleg Kiselyov and Chung-chieh Shan
build-type:     Simple
cabal-version:  >= 1.10
description:
  This package addresses the /configuration problem/ which is
  propogating configurations that are available at run-time, allowing
  multible configurations to coexist without resorting to mutable
  global variables or 'System.IO.Unsafe.unsafePerformIO'.
  .
  An example is modular arithmetic where the modulus itself can be
  supplied at run-time:
  .
  @
    foo :: Modular s => Modulus s
    foo = 1000 * 1000 * 5 + 2000
  @ 
  >>> withModulus 1280 foo
  1040
  .
  given the following setup:
  .
  @
    &#123;-# LANGUAGE ScopedTypeVariables, RankNTypes, ConstraintKinds, FlexibleContexts, UndecidableInstances #-&#125;
  .
    import Data.Proxy      (Proxy(Proxy))
    import Data.Reflection (Reifies, reflect, reify)
  @
  .
  and definitions:
  .
  @
    data Modulus s = M &#123; getModulus :: Integer &#125;
    type Modular s = 'Data.Reflection.Reifies' s Integer
  .
    normalize :: forall s. Modular s => Integer -> Modulus s
    normalize n = M (mod n modulus) where
    &#x20;  modulus = 'Data.Reflection.reflect' ('Data.Proxy.Proxy' :: 'Data.Proxy.Proxy' s)
  .
    instance Modular s => Num (Modulus s) where
    &#x20;  M a + M b = normalize (a + b)
    &#x20;  M a * M b = normalize (a * b)
  .
    withModulus :: Integer -> (forall s. Modular s => Modulus s) -> Integer
    withModulus m v = 'Data.Reflection.reify' m (getModulus . asProxyOf v)
    &#x20;  where
    &#x20;  asProxyOf :: f s -> Proxy s -> f s
    &#x20;  asProxyOf = const
  @
  .
  That package is an implementation of the ideas presented in the
  paper \"Functional Pearl: Implicit Configurations\" by Oleg Kiselyov
  and Chung-chieh Shan (<http://okmij.org/ftp/Haskell/tr-15-04.pdf original paper>). However, the API has been streamlined to improve
  performance.
  .
  Austin Seipp's tutorial <https://www.fpcomplete.com/user/thoughtpolice/using-reflection Reflecting values to types and back> provides a summary of the
  approach taken by this library, along with more motivating
  examples.

extra-source-files:
  examples/Monoid.hs
  examples/FromJSON.hs
  examples/Constraints.hs
  examples/Benchmark.hs
  CHANGELOG.markdown
  README.markdown
  slow/Data/Reflection.hs
  fast/Data/Reflection.hs
  .travis.yml

flag slow
  description:
    If you enable this flag, we use a more portable much much slower implementation. Moreover, the 'Given' API is broken, so this is currently an unsupported configuration. If you feel the need to turn on this flag for any reason, please email the maintainer!
  default: False
  manual: False

flag template-haskell
  description:
    You can disable the use of the `template-haskell` package using `-f-template-haskell`.
    .
    Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.
  default: True
  manual: True

source-repository head
  type: git
  location: git://github.com/ekmett/reflection.git

library
  -- Breaks due TypeFamilies => NoStarIsType
  build-depends: base <4.12

  ghc-options: -Wall

  if impl(ghc >= 7.2)
    default-extensions: Trustworthy

  build-depends:
    base >= 2 && < 5

  if impl(ghc < 7.8)
    build-depends:
      tagged >= 0.4.4 && < 1

  default-language: Haskell98

  if flag(template-haskell) && impl(ghc)
    build-depends: template-haskell

  if !flag(slow) && (impl(ghc) || impl(hugs))
    hs-source-dirs: fast
  else
    other-extensions: ScopedTypeVariables, FlexibleInstances
    hs-source-dirs: slow

  other-extensions:
    MultiParamTypeClasses,
    FunctionalDependencies,
    Rank2Types,
    CPP

  exposed-modules: Data.Reflection