name:                   category-extras
category:               Control, Monads, Comonads
version:                0.52.0
x-revision: 1
license:                BSD3
cabal-version:          >= 1.2
license-file:           LICENSE
author:                 Edward A. Kmett, Dave Menendez
maintainer:             Edward A. Kmett <ekmett@gmail.com>
stability:              experimental
homepage:               http://comonad.com/reader/
synopsis:               Various modules and constructs inspired by category theory
copyright:              Copyright (C) 2008 Edward A. Kmett
                        Copyright (C) 2004--2008 Dave Menendez
                        Copyright (C) 2007 Iavor Diatchki
description:            A vastly expanded collection of modules implementing various
                        ideas from category theory. Notable bits include: comonads,
                        adjunctions, functor fixedpoints and various recursion
                        operaters ala /Functional Programming with Bananas, Lenses,
                        Envelopes and Barbed Wire/.
build-type:             Simple

flag ArrowSubclassesCategory
        description:    Indicates Control.Category is available and that the standard library has
                        its arrows subclass Control.Category.Category
        default:        True

flag TypeFamilies
        description:    Support for Type Families is available to us

flag Optimize
        description:    Enable optimizations
        default:        False

library
        build-depends:  mtl >= 1.1 && < 2, base < 4.3
        extensions:
                CPP,
                EmptyDataDecls,
                FlexibleContexts,
                FlexibleInstances,
                FunctionalDependencies,
                MultiParamTypeClasses,
                TypeOperators,
                TypeSynonymInstances
                UndecidableInstances,
                ExistentialQuantification,
                Rank2Types

        exposed-modules:
                Control.Category.Monoidal,
                Control.Category.Cartesian,
                Control.Category.Cartesian.Closed,
                Control.Applicative.Parameterized,
                Control.Arrow.BiKleisli,
                Control.Arrow.CoKleisli,
                Control.Category.Associative,
                Control.Category.Braided,
                Control.Category.Distributive,
                Control.Category.Dual,
                Control.Category.Hask,
                Control.Category.Object,
                Control.Comonad,
                Control.Comonad.Cofree,
                Control.Comonad.Context,
                Control.Comonad.Coideal,
                Control.Comonad.Density,
                Control.Comonad.Fix,
                Control.Comonad.Indexed,
                Control.Comonad.HigherOrder,
                Control.Comonad.Parameterized,
                Control.Comonad.Pointer,
                Control.Comonad.Reader,
                Control.Comonad.Supply
                Control.Comonad.Trans,
                Control.Functor,
                Control.Functor.Adjunction,
                Control.Functor.Adjunction.HigherOrder,
                Control.Functor.Algebra,
                Control.Functor.Algebra.Elgot,
                Control.Functor.Categorical,
                Control.Functor.Composition,
                Control.Functor.Combinators.Const,
                Control.Functor.Combinators.Lift,
                Control.Functor.Combinators.Join,
                Control.Functor.Combinators.Biff,
                Control.Functor.Combinators.Flip,
                Control.Functor.Combinators.Of,
                Control.Functor.Contra,
                Control.Functor.Extras,
                Control.Functor.Exponential,
                Control.Functor.Fix,
                Control.Functor.Full,
                Control.Functor.HigherOrder,
                Control.Functor.HigherOrder.Composition,
                Control.Functor.Indexed,
                Control.Functor.KanExtension,
                Control.Functor.KanExtension.Interpreter,
                Control.Functor.Lambek,
                Control.Functor.Limit,
                Control.Functor.Pointed,
                Control.Functor.Pointed.Composition,
                Control.Functor.Representable,
                Control.Functor.Strong,
                Control.Functor.Yoneda,
                Control.Functor.Zip,
                Control.Functor.Zap,
                Control.Monad.Categorical,
                Control.Monad.Codensity,
                Control.Monad.Free,
                Control.Monad.HigherOrder,
                Control.Monad.Ideal,
                Control.Monad.Indexed,
                Control.Monad.Indexed.Cont,
                Control.Monad.Indexed.Fix,
                Control.Monad.Indexed.State,
                Control.Monad.Indexed.Trans,
                Control.Monad.Parameterized,
                Control.Monad.Hyper,
                Control.Monad.Either,
                Control.Morphism.Ana,
                Control.Morphism.Apo,
                Control.Morphism.Build,
                Control.Morphism.Cata,
                Control.Morphism.Chrono,
                Control.Morphism.Destroy,
                Control.Morphism.Dyna,
                Control.Morphism.Futu,
                Control.Morphism.Histo,
                Control.Morphism.Hylo,
                Control.Morphism.Meta,
                Control.Morphism.Para,
                Control.Morphism.Span,
                Control.Morphism.Universal,
                Control.Morphism.Zygo,
                Data.Void

        hs-source-dirs:         src
        ghc-options:            -Wall 

        if flag(ArrowSubclassesCategory)
                build-depends: ghc >= 6.9, base > 3, array
                cpp-options: -D__ARROW_SUBCLASSES_CATEGORY__=1
        else
                build-depends: ghc < 6.9, base, array 
                hs-source-dirs: pre-6.9
                exposed-modules: Control.Category

        if flag(TypeFamilies)
                extensions: TypeFamilies
                cpp-options: -D__TYPE_FAMILIES__=1

        if flag(Optimize)
                ghc-options: -funbox-strict-fields -O2