Cabal-version:        2.2
Name:                 clash-prelude
Version:              1.4.2
Synopsis:             Clash: a functional hardware description language - Prelude library
Description:
  Clash is a functional hardware description language that borrows both its
  syntax and semantics from the functional programming language Haskell. The
  Clash compiler transforms these high-level descriptions to low-level
  synthesizable VHDL, Verilog, or SystemVerilog.
  .
  Features of Clash:
  .
  * Strongly typed, but with a very high degree of type inference, enabling both
    safe and fast prototyping using concise descriptions.
  .
  * Interactive REPL: load your designs in an interpreter and easily test all
    your component without needing to setup a test bench.
  .
  * Higher-order functions, with type inference, result in designs that are
    fully parametric by default.
  .
  * Synchronous sequential circuit design based on streams of values, called
    @Signal@s, lead to natural descriptions of feedback loops.
  .
  * Support for multiple clock domains, with type safe clock domain crossing.
  .
  .
  This package provides:
  .
  * Prelude library containing datatypes and functions for circuit design
  .
  To use the library:
  .
  * Import "Clash.Prelude"
  .
  * Alternatively, if you want to explicitly route clock and reset ports,
    for more straightforward multi-clock designs, you can import the
    "Clash.Explicit.Prelude" module. Note that you should not import
    "Clash.Prelude" and "Clash.Explicit.Prelude" at the same time as they
    have overlapping definitions.
  .
  A preliminary version of a tutorial can be found in "Clash.Tutorial", for a
  general overview of the library you should however check out "Clash.Prelude".
  Some circuit examples can be found in "Clash.Examples".
Homepage:             https://clash-lang.org/
bug-reports:          https://github.com/clash-lang/clash-compiler/issues
License:              BSD-2-Clause
License-file:         LICENSE
Author:               The Clash Authors
Maintainer:           QBayLogic B.V. <devops@qbaylogic.com>
Copyright:            Copyright © 2013-2016, University of Twente,
                                  2016-2017, Myrtle Software Ltd,
                                  2017-2019, QBayLogic B.V., Google Inc.
Category:             Hardware
Build-type:           Custom

Extra-source-files:   README.md
                      CHANGELOG.md
                      AUTHORS.md

extra-doc-files:      doc/*.svg

source-repository head
  type: git
  location: https://github.com/clash-lang/clash-compiler.git
  subdir: clash-prelude

flag large-tuples
  description:
    Generate instances for classes such as `NFDataX` and `BitPack` for tuples
    up to and including 62 elements - the GHC imposed maximum. This greatly
    increases compile times for `clash-prelude`.
  default: False
  manual: True

flag super-strict
  description:
    Use `deepseqX` (instead of `seqX`) in register-like constructs. This can
    help to eliminate space leaks when using lazy data structures in
    registers-like constructs. This potentially slows down Clash hardware
    simulation.
  default: False
  manual: True

flag strict-mapSignal
  description:
    Use `seqX` in 'mapSignal#'. This can help to eliminate space leaks in long
    running simulations.
  default: False
  manual: True

flag multiple-hidden
  description:
    Allow multiple hidden clocks, resets, and enables to be used. This is an
    experimental feature, possibly triggering confusing error messages. By
    default, it is enabled on development versions of Clash and disabled on
    releases.
  default: False
  manual: True

flag doctests
  description:
    You can disable testing with doctests using `-f-doctests`.
  default: True
  manual: True

flag unittests
  description:
    You can disable testing with unittests using `-f-unittests`.
  default: True
  manual: True

flag benchmarks
  description:
    You can disable testing with benchmarks using `-f-benchmarks`.
  default: True
  manual: True

common common-options
  default-language:   Haskell2010
  default-extensions: BangPatterns
                      BinaryLiterals
                      DataKinds
                      DefaultSignatures
                      DeriveDataTypeable
                      DeriveFoldable
                      DeriveFunctor
                      DeriveGeneric
                      DeriveLift
                      DeriveTraversable
                      DerivingStrategies
                      InstanceSigs
                      KindSignatures
                      MagicHash
                      ScopedTypeVariables
                      StandaloneDeriving
                      TupleSections
                      TypeApplications
                      TypeOperators
                      ViewPatterns

  if impl(ghc >= 8.6)
      default-extensions: NoStarIsType

custom-setup
  setup-depends:
    base          >= 4.9 && <5,
    Cabal         >= 1.10,
    cabal-doctest >= 1.0.1 && <1.1

Library
  import:             common-options
  HS-Source-Dirs:     src

  ghc-options:        -Wall -Wcompat -fexpose-all-unfoldings -fno-worker-wrapper
  CPP-Options:        -DCABAL

  if flag(large-tuples)
    CPP-Options: -DLARGE_TUPLES

  if flag(super-strict)
    CPP-Options: -DCLASH_SUPER_STRICT

  if flag(strict-mapSignal)
    CPP-Options: -DCLASH_STRICT_MAPSIGNAL

  if flag(multiple-hidden)
    CPP-Options: -DCLASH_MULTIPLE_HIDDEN

  if flag(multiple-hidden)
    Exposed-modules:  Clash.Prelude.Synchronizer

  Autogen-Modules:    Paths_clash_prelude

  Exposed-modules:    Clash.Annotations.TopEntity
                      Clash.Annotations.Primitive
                      Clash.Annotations.BitRepresentation
                      Clash.Annotations.BitRepresentation.Deriving
                      Clash.Annotations.BitRepresentation.Internal
                      Clash.Annotations.BitRepresentation.Util
                      Clash.Annotations.SynthesisAttributes
                      Clash.Annotations.TH

                      Clash.Class.AutoReg
                      Clash.Class.BitPack
                      Clash.Class.Exp
                      Clash.Class.HasDomain
                      Clash.Class.HasDomain.HasSingleDomain
                      Clash.Class.HasDomain.HasSpecificDomain
                      Clash.Class.HasDomain.CodeGen
                      Clash.Class.HasDomain.Common
                      Clash.Class.Num
                      Clash.Class.Parity
                      Clash.Class.Resize

                      Clash.Clocks
                      Clash.Clocks.Deriving

                      Clash.Explicit.BlockRam
                      Clash.Explicit.BlockRam.File
                      Clash.Explicit.DDR
                      Clash.Explicit.Mealy
                      Clash.Explicit.Moore
                      Clash.Explicit.RAM
                      Clash.Explicit.ROM
                      Clash.Explicit.ROM.File
                      Clash.Explicit.Prelude
                      Clash.Explicit.Prelude.Safe
                      Clash.Explicit.Reset
                      Clash.Explicit.SimIO
                      Clash.Explicit.Signal
                      Clash.Explicit.Signal.Delayed
                      Clash.Explicit.Synchronizer
                      Clash.Explicit.Testbench
                      Clash.Explicit.Verification

                      Clash.HaskellPrelude

                      Clash.Hidden

                      Clash.Intel.ClockGen
                      Clash.Intel.DDR

                      Clash.Magic

                      Clash.NamedTypes

                      Clash.Prelude
                      Clash.Prelude.BitIndex
                      Clash.Prelude.BitReduction
                      Clash.Prelude.BlockRam
                      Clash.Prelude.BlockRam.File
                      Clash.Prelude.DataFlow
                      Clash.Prelude.Mealy
                      Clash.Prelude.Moore
                      Clash.Prelude.RAM
                      Clash.Prelude.ROM
                      Clash.Prelude.ROM.File
                      Clash.Prelude.Safe
                      Clash.Prelude.Testbench

                      Clash.Promoted.Nat
                      Clash.Promoted.Nat.Literals
                      Clash.Promoted.Nat.TH
                      Clash.Promoted.Nat.Unsafe
                      Clash.Promoted.Symbol

                      Clash.Signal
                      Clash.Signal.Bundle
                      Clash.Signal.BiSignal
                      Clash.Signal.Delayed
                      Clash.Signal.Delayed.Internal
                      Clash.Signal.Delayed.Bundle
                      Clash.Signal.Internal
                      Clash.Signal.Internal.Ambiguous
                      Clash.Signal.Trace

                      Clash.Sized.BitVector
                      Clash.Sized.Fixed
                      Clash.Sized.Index
                      Clash.Sized.RTree
                      Clash.Sized.Signed
                      Clash.Sized.Unsigned
                      Clash.Sized.Vector

                      Clash.Sized.Internal.BitVector
                      Clash.Sized.Internal.Index
                      Clash.Sized.Internal.Mod
                      Clash.Sized.Internal.Signed
                      Clash.Sized.Internal.Unsigned

                      Clash.Verification
                      Clash.Verification.DSL
                      Clash.Verification.PrettyPrinters
                      Clash.Verification.Internal

                      Clash.XException
                      Clash.XException.Internal
                      Clash.XException.TH

                      Clash.Xilinx.ClockGen
                      Clash.Xilinx.DDR

                      Clash.Tutorial
                      Clash.Examples

  other-modules:
                      Clash.Class.AutoReg.Instances
                      Clash.Class.AutoReg.Internal
                      Clash.Class.BitPack.Internal
                      Clash.CPP
                      Clash.Examples.Internal
                      Clash.Signal.Bundle.Internal
                      Language.Haskell.TH.Compat
                      Paths_clash_prelude

  other-extensions:   CPP
                      ConstraintKinds
                      FlexibleContexts
                      FlexibleInstances
                      GADTs
                      GeneralizedNewtypeDeriving
                      MultiParamTypeClasses
                      PatternSynonyms
                      RankNTypes
                      TemplateHaskell
                      TypeFamilies
                      UndecidableInstances

  Build-depends:      array                     >= 0.5.1.0 && < 0.6,
                      arrows                    >= 0.4     && < 0.5,
                      base                      >= 4.11    && < 5,
                      bifunctors                >= 5.4.0   && < 6.0,
                      binary                    >= 0.8.5   && < 0.11,
                      bytestring                >= 0.10.8  && < 0.12,
                      constraints               >= 0.9     && < 1.0,
                      containers                >= 0.4.0   && < 0.7,
                      data-binary-ieee754       >= 0.4.4   && < 0.6,
                      data-default-class        >= 0.1.2   && < 0.2,
                      deepseq                   >= 1.4.1.0 && < 1.5,
                      ghc-prim                  >= 0.5.1.0 && < 0.8,
                      ghc-typelits-extra        >= 0.4     && < 0.5,
                      ghc-typelits-knownnat     >= 0.7.2   && < 0.8,
                      ghc-typelits-natnormalise >= 0.7.2   && < 0.8,
                      hashable                  >= 1.2.1.0  && < 1.4,
                      half                      >= 0.2.2.3 && < 1.0,
                      interpolate               >= 0.2     && < 0.3,
                      lens                      >= 4.10    && < 5.1.0,
                      recursion-schemes         >= 5.1     && < 5.3,
                      QuickCheck                >= 2.7     && < 2.15,
                      reflection                >= 2       && < 2.2,
                      singletons                >= 2.0     && < 3.1,
                      template-haskell          >= 2.12.0.0 && < 2.18,
                      th-abstraction            >= 0.2.10 && < 0.5.0,
                      th-lift                   >= 0.7.0    && < 0.9,
                      th-orphans                >= 0.13.1   && < 1.0,
                      text                      >= 0.11.3.1 && < 1.3,
                      text-show                 >= 3.7     && < 3.10,
                      time                      >= 1.8     && < 1.12,
                      transformers              >= 0.5.2.0 && < 0.6,
                      type-errors               >= 0.2.0.0 && < 0.3,
                      uniplate                  >= 1.6.12  && < 1.7,
                      vector                    >= 0.11    && < 1.0

  if impl(ghc >= 9.0.0)
    Build-Depends:    ghc-bignum                >= 1.0      && < 1.1
  else
    Build-Depends:    integer-gmp               >= 1.0.1.0  && < 2.0
  if flag(large-tuples)
    Build-Depends:    ghc

test-suite doctests
  type:             exitcode-stdio-1.0
  default-language: Haskell2010
  main-is:          doctests.hs
  ghc-options:      -Wall -Wcompat -threaded
  hs-source-dirs:   tests

  x-doctest-options: -fobject-code

  if !flag(doctests)
    buildable: False
  else
    build-depends:
      base,
      doctest >= 0.9.1 && < 0.19,
      clash-prelude
  if impl(ghc >= 8.6)
    build-depends:
      doctest >= 0.16.1

test-suite unittests
  import:           common-options
  type:             exitcode-stdio-1.0
  main-is:          unittests.hs
  ghc-options:      -Wall -Wcompat -threaded -with-rtsopts=-N
  hs-source-dirs:   tests

  if !flag(unittests)
    buildable: False
  else
    build-depends:
      clash-prelude,

      ghc-typelits-knownnat,
      ghc-typelits-natnormalise,
      ghc-typelits-extra,

      base,
      deepseq,
      hedgehog      >= 1.0.3    && < 1.1,
      hint          >= 0.7      && < 0.10,
      quickcheck-classes-base >= 0.6 && < 1.0,
      tasty         >= 1.2      && < 1.5,
      tasty-hedgehog,
      tasty-hunit,
      tasty-th,
      tasty-quickcheck,
      template-haskell

  Other-Modules:
                 Clash.Tests.AutoReg
                 Clash.Tests.BitPack
                 Clash.Tests.BitVector
                 Clash.Tests.DerivingDataRepr
                 Clash.Tests.DerivingDataReprTypes
                 Clash.Tests.Fixed
                 Clash.Tests.FixedExhaustive
                 Clash.Tests.NFDataX
                 Clash.Tests.Reset
                 Clash.Tests.Resize
                 Clash.Tests.Signal
                 Clash.Tests.Signed
                 Clash.Tests.SizedNum
                 Clash.Tests.TopEntityGeneration
                 Clash.Tests.Unsigned
                 Clash.Tests.Vector

                 Clash.Tests.Laws.Enum
                 Clash.Tests.Laws.SaturatingNum

                 Hedgehog.Extra

                 Test.Tasty.HUnit.Extra
                 Test.QuickCheck.Extra

benchmark benchmark-clash-prelude
  type:             exitcode-stdio-1.0
  default-language: Haskell2010
  main-is:          benchmark-main.hs
  ghc-options:      -O2 -Wall
  hs-source-dirs:   benchmarks

  if !flag(benchmarks)
    buildable: False
  else
    build-depends:
      base,
      clash-prelude,
      criterion         >= 1.3.0.0 && < 1.6,
      deepseq,
      template-haskell

  Other-Modules:    BenchBitVector
                    BenchCommon
                    BenchFixed
                    BenchRAM
                    BenchSigned
                    BenchUnsigned
                    BenchVector