name:                haxl
version:             2.1.2.0
synopsis:            A Haskell library for efficient, concurrent,
                     and concise data access.
homepage:            https://github.com/facebook/Haxl
bug-reports:         https://github.com/facebook/Haxl/issues
license:             BSD3
license-files:       LICENSE
author:              Facebook, Inc.
maintainer:          The Haxl Team <haxl-team@fb.com>
copyright:           Copyright (c) 2014-present, Facebook, Inc.
category:            Concurrency
build-type:          Simple
stability:           alpha
cabal-version:       >= 1.10
tested-with:
  GHC==7.8.4,
  GHC==7.10.3,
  GHC==8.0.2,
  GHC==8.2.2,
  GHC==8.4.3

description:
  Haxl is a library and EDSL for efficient scheduling of concurrent data
  accesses with a concise applicative API.
  .
  To use Haxl, you need to implement one or more /data sources/, which
  provide the means for accessing remote data or other I/O that you
  want to perform using Haxl.
  .
  Haxl provides two top-level modules:
  .
  * /Data-source implementations/ import "Haxl.Core",
  .
  * /Client code/ import your data sources and "Haxl.Prelude", or some
   other client-level API that you provide.

extra-source-files:
  readme.md
  tests/LoadCache.txt
  changelog.md

library

  build-depends:
    aeson >= 0.6 && < 1.5,
    base >= 4.7 && < 5,
    binary >= 0.7 && < 0.10,
    bytestring >= 0.9 && < 0.11,
    containers >= 0.5 && < 0.7,
    deepseq,
    exceptions >=0.8 && <0.11,
    filepath >= 1.3 && < 1.5,
    ghc-prim,
    hashable == 1.2.*,
    pretty == 1.1.*,
    -- text 1.2.1.0 required for instance Binary Text
    text >= 1.2.1.0 && < 1.3,
    time >= 1.4 && < 1.9,
    stm >= 2.4 && < 2.6,
    transformers,
    unordered-containers == 0.2.*,
    vector >= 0.10 && <0.13

  if !impl(ghc >= 8.0)
    build-depends:
      semigroups >= 0.18.3 && <0.19

  exposed-modules:
    Haxl.Core,
    Haxl.Core.CallGraph,
    Haxl.Core.DataCache,
    Haxl.Core.DataSource,
    Haxl.Core.Exception,
    Haxl.Core.Flags,
    Haxl.Core.Memo,
    Haxl.Core.Monad,
    Haxl.Core.Fetch,
    Haxl.Core.Parallel,
    Haxl.Core.Profile,
    Haxl.Core.Run,
    Haxl.Core.RequestStore,
    Haxl.Core.ShowP,
    Haxl.Core.StateStore,
    Haxl.Core.Stats,
    Haxl.Prelude
    Haxl.DataSource.ConcurrentIO

  other-modules:
    Haxl.Core.Util

  default-language: Haskell2010

  ghc-options:
    -O2 -fprof-auto
    -Wall

  if impl(ghc >= 8.0)
     ghc-options: -Wno-name-shadowing
  else
     ghc-options: -fno-warn-name-shadowing

test-suite test

  build-depends:
    aeson,
    HUnit >= 1.2 && < 1.7,
    base >= 4.7 && < 5,
    binary,
    bytestring,
    containers,
    deepseq,
    filepath,
    hashable,
    haxl,
    test-framework,
    test-framework-hunit,
    text,
    time,
    unordered-containers

  ghc-options:
    -Wall
    -fno-warn-name-shadowing
    -fno-warn-missing-signatures

  hs-source-dirs:
    tests

  main-is:
    TestMain.hs

  if impl(ghc >= 8.0)
    other-modules:
      AdoTests
      OutgoneFetchesTests

  other-modules:
    AllTests
    BadDataSource
    BatchTests
    CoreTests
    DataCacheTest
    ExampleDataSource
    FullyAsyncTest
    LoadCache
    MemoizationTests
    MockTAO
    ProfileTests
    SleepDataSource
    TestBadDataSource
    TestExampleDataSource
    TestTypes
    TestUtils
    WorkDataSource
    WriteTests

  type:
    exitcode-stdio-1.0

  default-language: Haskell2010

flag bench
  default: False

executable monadbench
  if !flag(bench)
    buildable: False
  default-language:
    Haskell2010
  hs-source-dirs:
    tests
  build-depends:
    base,
    haxl,
    hashable,
    time
  main-is:
    MonadBench.hs
  other-modules:
    ExampleDataSource
  ghc-options:
    -O2 -main-is MonadBench -rtsopts

executable cachebench
  if !flag(bench)
    buildable: False
  default-language:
    Haskell2010
  hs-source-dirs:
    tests
  build-depends:
    base,
    haxl,
    hashable,
    time
  main-is:
    Bench.hs
  ghc-options:
    -O2 -main-is Bench -rtsopts