diff --git a/.travis.yml b/.travis.yml new file mode 100644 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,25 @@ +sudo: false +language: generic + +cache: + directories: + - $HOME/.stack + - $TRAVIS_BUILD_DIR/.stack-work/install + +addons: + apt: + packages: + - libgmp-dev + +before_install: + - mkdir -p ~/.local/bin + - export PATH=$HOME/.local/bin:$PATH + - travis_retry curl -L https://get.haskellstack.org/stable/linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C ~/.local/bin '*/stack' + +install: + - stack --no-terminal setup + - stack --no-terminal build --fast --only-dependencies + +script: + - stack --no-terminal build --fast --bench --no-run-benchmarks + - curl -sL https://raw.github.com/ndmitchell/weeder/master/misc/travis.sh | sh -s . diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,11 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](http://keepachangelog.com/) +and this project adheres to the [Haskell Package Versioning Policy](https://pvp.haskell.org/). + +## [0.0.0] - 2018-09-20 + +### Added +- Initial release diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,11 @@ +Copyright 2018 Mitchell Rosen + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,39 @@ +### Summary + +`planet-mitchell` is my very own Haskell package planet. + +It contains no new code, only re-exports from `base` and various well-known +packages, similar to [https://hackage.haskell.org/package/rebase](rebase). + +- `Control.`, `Data.`, `Foreign.`, etc. module prefixes are stripped. The idea + here is that, if a name such as `Applicative` is sufficiently unambiguous in + the Haskell ecosystem, it deserves as short a module name as possible. + + See the [elm standard library](http://package.elm-lang.org/packages/elm-lang/core/latest) + for inspiration. + +- The module hierarchy is not faithful to the underlying packages. Many modules + contain related re-exports from multiple packages, and I've invented a few new + sin-bin modules such as `Concurrency`, `Parallelism`, `Eval`, and `Debug`. + +- To reduce API surface area and encourage a consistent vocabulary, redundant + functions like `sequence` and `mapM` are not re-exported. + +- Odd, uncommon, and deprecated types and functions (like `WrappedApplicative`) + are not re-exported. + +- Partial functions are discouraged and mostly live in `.Partial` modules. (This + is a work-in-progress). + +- Unsafe functions are discouraged and mostly live in `.Unsafe` modules. (This + is a work-in-progress). + +- `String` is heavily discouraged, and many `String` IO functions are not + re-exported; `Text` and/or `ByteString` versions are re-exported instead. + +- Generalizations like `MonadIO` / `MonadUnliftIO` are used where possible. + +### Stability + +Alpha quality, massive breaking changes should be expected and no changelog will +be kept for some time. Don't use this package. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/planet-mitchell.cabal b/planet-mitchell.cabal new file mode 100644 --- /dev/null +++ b/planet-mitchell.cabal @@ -0,0 +1,402 @@ +cabal-version: 2.0 + +author: Mitchell Rosen +build-type: Simple +category: Prelude +description: + Planet Mitchell. + . + This package provides a curated, highly unstable collection of reorganized + re-exports. Mostly for personal use at the moment, me but please poke around + and see README.md for a bit more information ;) +license-file: LICENSE +license: BSD3 +maintainer: Mitchell Rosen +name: planet-mitchell +synopsis: Planet Mitchell +tested-with: GHC == 8.4.3 +version: 0.0.0 +homepage: https://github.com/mitchellwrosen/planet-mitchell +bug-reports: https://github.com/mitchellwrosen/planet-mitchell/issues +copyright: (c) 2018, Mitchell Rosen + +extra-source-files: + .travis.yml + CHANGELOG.md + README.md + +source-repository head + type: git + location: git://github.com/mitchellwrosen/planet-mitchell.git + +library + hs-source-dirs: src + ghc-options: + -Weverything + -fno-warn-safe + -fno-warn-unsafe + -- TODO re-enable + -fno-warn-missing-import-lists + default-extensions: NoImplicitPrelude + default-language: Haskell2010 + + build-depends: + aeson ^>= 1.3.1 || ^>= 1.4.0 + , base ^>= 4.10 || ^>= 4.11 + , base-orphans ^>= 0.8 + , aeson-pretty ^>= 0.8.7 + , aeson-qq ^>= 0.8.2 + , ansi-terminal ^>= 0.8.0 + , approximate ^>= 0.3.1 + , array ^>= 0.5.2 + , async ^>= 2.2.1 + , atomic-primops ^>= 0.8 + , base16-bytestring ^>= 0.1.1 + , bits ^>= 0.5.0 + , bytestring ^>= 0.10.8 + , bytestring-lexing ^>= 0.5.0 + , case-insensitive ^>= 1.2.0 + , cborg ^>= 0.2.0 + , comonad ^>= 5.0 + , compact ^>= 0.1.0 + , constraints ^>= 0.10 + , containers ^>= 0.5.11 + , contravariant ^>= 1.4.1 + , contravariant-extras ^>= 0.3.4 + , deepseq ^>= 1.4.3 + , distributive ^>= 0.5.3 + , dlist ^>= 0.8.0 + , double-conversion ^>= 2.0.2.0 + , Earley ^>= 0.12.0 + , envparse ^>= 0.4 + , erf ^>= 2.0.0 + , exceptions ^>= 0.10.0 + , extra ^>= 1.6.9 || ^>= 1.6.10 || ^>= 1.6.11 + , fgl ^>= 5.6.0 + , filepath ^>= 1.4.2 + , foldl ^>= 1.4.0 + , free ^>= 5.1 + , gauge ^>= 0.2.1 + , generic-aeson ^>= 0.2.0.9 + , half ^>= 0.3 + , hashable ^>= 1.2.7 + , heaps ^>= 0.3.0 + , hedgehog ^>= 0.5.3 || ^>= 0.6 + , integer-logarithms ^>= 1.0.2 + , lens ^>= 4.16.1 + , lens-aeson ^>= 1.0.2 + , list-transformer ^>= 1.0.4 + , logict ^>= 0.6.0 + , managed ^>= 1.0.6 + , megaparsec ^>= 6.5.0 + , mmorph ^>= 1.1.2 + , monad-ste ^>= 0.1.0 + , mtl ^>= 2.2.2 + , multiset ^>= 0.3.4 + , mwc-random ^>= 0.13.6 + , network ^>= 2.7.0 + , network-info ^>= 0.2.0 + , network-uri ^>= 2.6.1 + , nf ^>= 1.0.1 + , optparse-applicative ^>= 0.14.2 + , parallel ^>= 3.2.1 + , parser-combinators ^>= 1.0.0 + , pointed ^>= 5.0.1 + , prettyprinter ^>= 1.2.0 + , prettyprinter-ansi-terminal ^>= 1.1.1 + , primitive ^>= 0.6.4 + , profunctors ^>= 5.2 || ^>= 5.3 + , psqueues ^>= 0.2.7 + , reactive-banana ^>= 1.2.0 + , reflection ^>= 2.1 + , regex-applicative ^>= 0.3.3 + , scientific ^>= 0.3.6 + , semigroupoids ^>= 5.3.1 + , semigroups ^>= 0.18.4 + , semilattices ^>= 0.0.0 + , serialise ^>= 0.2.0 + , split ^>= 0.2.3.3 + , stm ^>= 2.4.5 + , stm-chans ^>= 3.0.0 + , stm-containers ^>= 0.2.16 + , tagged ^>= 0.8.5 + , text ^>= 1.2.3 + , text-short ^>= 0.1.2 + , time ^>= 1.8 || ^>= 1.9.1 + , transformers ^>= 0.5.5 + , transformers-base ^>= 0.4.5 + , transformers-compat ^>= 0.6.2 + , typed-process ^>= 0.2.2 + , unagi-chan ^>= 0.4.1 + , unix ^>= 2.7.2 + , unliftio ^>= 0.2.7.0 + , unordered-containers ^>= 0.2.9 + , utf8-string ^>= 1.0.1.1 + , uuid ^>= 1.3.13 + , uuid-types ^>= 1.0.3 + , vault ^>= 0.3.1 + , vector ^>= 0.12.0 + , vector-builder ^>= 0.3.6 + , weigh ^>= 0.0.12 + , writer-cps-mtl ^>= 0.1.1 + + exposed-modules: + Ala.Compose + Ala.Const + Ala.Identity + Ala.Product + Ala.Sum + Applicative + Array + Array.Partial + Benchmark + Bifoldable + Bifoldable.Partial + Bifunctor + Bitraversable + Bits + Bool + Bounded + ByteString + ByteString.Base16 + ByteString.Latin1 + ByteString.Latin1.Partial + ByteString.Lazy + ByteString.Lazy.Base16 + ByteString.Lazy.Latin1 + ByteString.Lazy.Utf8 + ByteString.Partial + ByteString.Short + ByteString.Short.Partial + ByteString.Utf8 + CaseInsensitive + Category + Char + Char.Partial + Clock + Coerce + Coerce.Unsafe + Comonad + CompactRegion + Concurrency + Concurrency.Chan + Concurrency.Counter + Concurrency.IORef + Concurrency.MVar + Concurrency.QSem + Concurrency.TBChan + Concurrency.TBMChan + Concurrency.TBMQueue + Concurrency.TBQueue + Concurrency.TBimap + Concurrency.TChan + Concurrency.TMChan + Concurrency.TMQueue + Concurrency.TMVar + Concurrency.TMap + Concurrency.TMultimap + Concurrency.TSem + Concurrency.TSet + Concurrency.TVar + Constraint + Cont + Contravariant + Copointed + Data + Debug + Decidable + Distributive + Divisible + Dynamic + Either + Enum + Environment + Equality + Error + Eval + Except + Exception + FRP + Field + File + File.Binary + File.Text + Foldable + Foldable.Partial + Foldl + Function + Functor + Generic + Graph.Adjacency + Graph.Inductive + Groupoid + Hashable + Heap + IO + IO.Unsafe + Ix + Json + Json.Decode + Json.Encode + Label + List + List.Builder + List.Builder.Partial + List.Partial + List1 + List1.Partial + ListT + Logic + Managed + Map + Map.Hash + Map.Int + Map.Int.Lazy + Map.Lazy + Maybe + Maybe.Partial + MaybeT + Mitchell.Prelude + Monad + Monad.Base + Monad.Fail + Monad.Fix + Monad.Plus + Monad.Trans + Monad.Zip + Monoid + MultiSet + MultiSet.Int + Numeric.Approximate + Numeric.Complex + Numeric.Double + Numeric.Erf + Numeric.Fast + Numeric.Float + Numeric.Floating + Numeric.Fractional + Numeric.Half + Numeric.Int + Numeric.Integer + Numeric.Integral + Numeric.InvErf + Numeric.Nat + Numeric.Natural + Numeric.Num + Numeric.Product + Numeric.Ratio + Numeric.Real + Numeric.RealFloat + Numeric.RealFrac + Numeric.Scientific + Numeric.Sum + Numeric.Word + Optic.Fold + Optic.Getter + Optic.Getting + Optic.Iso + Optic.Iso.Reversing + Optic.Iso.Strict + Optic.Lens + Optic.Lens.At + Optic.Lens.Contains + Optic.Prism + Optic.Prism.Cons + Optic.Prism.Empty + Optic.Prism.Snoc + Optic.Review + Optic.Setter + Optic.Traversal + Optic.Traversal.Each + Optic.Traversal.Ixed + Ord + Parallelism + Parser.Binary + Parser.Cli + Parser.Earley + Parser.Env + Parser.Text + Pointed + Posix + Predicate + Pretty + Prim + Printf + Process + Profunctor + Proxy + Ptr + Ptr.Foreign + Ptr.Fun + Ptr.Stable + Ptr.Static + Ptr.Weak + Queue.Prio.Hash + Queue.Prio.Int + Queue.Prio.Ord + Random + Read + Read.Partial + Reader + Reflection + Regex + RuntimeSystem + ST + Semigroup + Semigroupoid + Semilattice + Sequence + Serialise + Set + Set.Hash + Set.Int + Show + Socket + StableName + State + Storable + Symbol + System + Tagged + Terminal + Test + Test.Gen + Test.Range + Text + Text.Lazy + Text.Lazy.Builder + Text.Partial + Text.Short + Text.Short.Partial + Text.Short.Unsafe + Time + Traversable + Tree + Tuple + Type + Typeable + URI + UUID + Unique + Vault + Vault.Lazy + Vector + Vector.Builder + Vector.Generic + Vector.Generic.Mutable + Vector.Mutable + Vector.Primitive + Vector.Storable + Vector.Unboxed + Void + Weigh + Writer + +-- benchmark semaphore +-- hs-source-dirs: bench +-- main-is: Semaphore.hs +-- ghc-options: -Wall +-- type: exitcode-stdio-1.0 +-- ghc-options: -O -rtsopts -threaded "-with-rtsopts=-N4 -qg" +-- build-depends: planet-mitchell +-- default-language: Haskell2010 diff --git a/src/Ala/Compose.hs b/src/Ala/Compose.hs new file mode 100644 --- /dev/null +++ b/src/Ala/Compose.hs @@ -0,0 +1,5 @@ +module Ala.Compose + ( Compose(..) + ) where + +import Data.Functor.Compose (Compose(Compose, getCompose)) diff --git a/src/Ala/Const.hs b/src/Ala/Const.hs new file mode 100644 --- /dev/null +++ b/src/Ala/Const.hs @@ -0,0 +1,5 @@ +module Ala.Const + ( Const(..) + ) where + +import Data.Functor.Const (Const(Const, getConst)) diff --git a/src/Ala/Identity.hs b/src/Ala/Identity.hs new file mode 100644 --- /dev/null +++ b/src/Ala/Identity.hs @@ -0,0 +1,11 @@ +module Ala.Identity + ( Identity(..) + , IdentityT(..) + , mapIdentityT + , generalize + ) where + +import Control.Monad.Morph (generalize) +import Control.Monad.Trans.Identity (IdentityT(IdentityT, runIdentityT), + mapIdentityT) +import Data.Functor.Identity (Identity(Identity, runIdentity)) diff --git a/src/Ala/Product.hs b/src/Ala/Product.hs new file mode 100644 --- /dev/null +++ b/src/Ala/Product.hs @@ -0,0 +1,5 @@ +module Ala.Product + ( Product(..) + ) where + +import Data.Functor.Product (Product(Pair)) diff --git a/src/Ala/Sum.hs b/src/Ala/Sum.hs new file mode 100644 --- /dev/null +++ b/src/Ala/Sum.hs @@ -0,0 +1,5 @@ +module Ala.Sum + ( Sum(..) + ) where + +import Data.Functor.Sum (Sum(InL, InR)) diff --git a/src/Applicative.hs b/src/Applicative.hs new file mode 100644 --- /dev/null +++ b/src/Applicative.hs @@ -0,0 +1,61 @@ +module Applicative + ( -- * Applicative + Applicative(..) + , between + , filterM + , forever + , liftA3 + , replicateM + , replicateM_ + , unless + , when + , zipWithM + , zipWithM_ + -- * Alternative + , Alternative((<|>), empty, many) + , endBy + , endBy1 + , guard + , manyTill + , optional + , sepBy + , sepEndBy + , sepBy1 + , sepEndBy1 + , skipMany + , skipManyTill + , skipSome + , skipSomeTill + , some1 + , someTill + -- ** Newtypes + , Alt(..) + -- * Free applicative + , Ap(..) + , runAp + , runAp_ + , liftAp + , iterAp + , hoistAp + , retractAp + ) where + +import Control.Applicative (Alternative(empty, many, (<|>)), + Applicative(liftA2, pure, (*>), (<*), (<*>), (<*>)), + liftA3) +import Control.Applicative.Combinators (between, endBy, manyTill, + sepBy, sepEndBy, skipMany, + skipManyTill, skipSome, + skipSomeTill) +import Control.Applicative.Combinators.NonEmpty (endBy1, sepBy1, sepEndBy1, + someTill) +import Control.Applicative.Free (Ap(Ap, Pure), hoistAp, iterAp, + liftAp, retractAp, runAp, + runAp_) +import Control.Monad (filterM, forever, guard, + replicateM, replicateM_, + unless, when, zipWithM, + zipWithM_) +import Data.Functor.Alt (optional) +import Data.List.NonEmpty (some1) +import Data.Monoid (Alt(Alt, getAlt)) diff --git a/src/Array.hs b/src/Array.hs new file mode 100644 --- /dev/null +++ b/src/Array.hs @@ -0,0 +1,12 @@ +module Array + ( Array + , array + , bounds + , indices + , assocs + , (//) + , accum + , ixmap + ) where + +import Data.Array diff --git a/src/Array/Partial.hs b/src/Array/Partial.hs new file mode 100644 --- /dev/null +++ b/src/Array/Partial.hs @@ -0,0 +1,5 @@ +module Array.Partial + ( (!) + ) where + +import Data.Array diff --git a/src/Benchmark.hs b/src/Benchmark.hs new file mode 100644 --- /dev/null +++ b/src/Benchmark.hs @@ -0,0 +1,23 @@ +module Benchmark + ( -- * Running benchmarks + defaultMain + -- * Constructing benchmarks + -- ** Benchmark + , Benchmark + , bench + , bgroup + , env + , envWithCleanup + -- ** Benchmarkable + , Benchmarkable + , nfIO + , whnfIO + , nf + , whnf + , perBatchEnv + , perBatchEnvWithCleanup + , perRunEnv + , perRunEnvWithCleanup + ) where + +import Gauge diff --git a/src/Bifoldable.hs b/src/Bifoldable.hs new file mode 100644 --- /dev/null +++ b/src/Bifoldable.hs @@ -0,0 +1,34 @@ +module Bifoldable + ( -- * Bifoldable + Bifoldable(bifold, bifoldMap, bifoldr) + , bifoldr' + , bifoldrM + , bifoldl' + , bifoldlM + , bitraverse_ + , bifor_ + , bisequence_ + , biasum + , biList + , binull + , bilength + , bielem + , bisum + , biproduct + , biconcatMap + , biand + , bior + , biany + , biall + , binotElem + , bifind + -- * Bifoldable1 + , Bifoldable1(..) + , bitraverse1_ + , bifor1_ + , bisequenceA1_ + ) where + +import Data.Bifoldable +import Data.Semigroup.Bifoldable (Bifoldable1(bifold1, bifoldMap1), bifor1_, + bisequenceA1_, bitraverse1_) diff --git a/src/Bifoldable/Partial.hs b/src/Bifoldable/Partial.hs new file mode 100644 --- /dev/null +++ b/src/Bifoldable/Partial.hs @@ -0,0 +1,10 @@ +module Bifoldable.Partial + ( bifoldl1 + , bifoldr1 + , bimaximum + , bimaximumBy + , biminimum + , biminimumBy + ) where + +import Data.Bifoldable diff --git a/src/Bifunctor.hs b/src/Bifunctor.hs new file mode 100644 --- /dev/null +++ b/src/Bifunctor.hs @@ -0,0 +1,11 @@ +module Bifunctor + ( -- * Bifunctor + Bifunctor(..) + , Swapped(..) + -- * Biapply + , Biapply(..) + ) where + +import Control.Lens.Iso (Swapped(swapped)) +import Data.Bifunctor +import Data.Bifunctor.Apply (Biapply((<<.>>), (.>>), (<<.))) diff --git a/src/Bitraversable.hs b/src/Bitraversable.hs new file mode 100644 --- /dev/null +++ b/src/Bitraversable.hs @@ -0,0 +1,22 @@ +module Bitraversable + ( -- * Bitraversable + Bitraversable(..) + , bisequence + , bifor + , bimapAccumL + , bimapAccumR + -- ** Default @Bifunctor@ implementation + , bimapDefault + -- ** Default @Bifoldable@ implementation + , bifoldMapDefault + -- * Bitraversable1 + , Bitraversable1(..) + -- ** Default @Bifoldable1@ implementation + , bifoldMap1Default + ) where + +import Data.Bitraversable (Bitraversable(bitraverse), + bifoldMapDefault, bifor, bimapAccumL, + bimapAccumR, bimapDefault, bisequence) +import Data.Semigroup.Bitraversable (Bitraversable1(bisequence1, bitraverse1), + bifoldMap1Default) diff --git a/src/Bits.hs b/src/Bits.hs new file mode 100644 --- /dev/null +++ b/src/Bits.hs @@ -0,0 +1,16 @@ +module Bits + ( -- * Bits + Bits(..) + , srl + , toIntegralSized + , FiniteBits(..) + , Ranked(..) + , msb + -- * Default @Bits@ implementations + , bitDefault + , testBitDefault + , popCountDefault + ) where + +import Data.Bits +import Data.Bits.Extras diff --git a/src/Bool.hs b/src/Bool.hs new file mode 100644 --- /dev/null +++ b/src/Bool.hs @@ -0,0 +1,23 @@ +{-# LANGUAGE ExplicitNamespaces #-} + +module Bool + ( -- * Boolean + Bool(..) + , (&&) + , (||) + , not + , otherwise + , bool + -- ** Newtypes + , All(..) + , Any(..) + -- * Boolean type functions + , If + , type (&&) + , type (||) + , Not + ) where + +import Data.Bool +import Data.Monoid +import Data.Type.Bool diff --git a/src/Bounded.hs b/src/Bounded.hs new file mode 100644 --- /dev/null +++ b/src/Bounded.hs @@ -0,0 +1,13 @@ +module Bounded + ( -- * Bounded + Bounded(..) + , Lower(..) + , Upper(..) + -- ** Newtypes + , Bound(..) + ) where + +import Data.Semilattice.Bound +import Data.Semilattice.Lower +import Data.Semilattice.Upper +import GHC.Enum diff --git a/src/ByteString.hs b/src/ByteString.hs new file mode 100644 --- /dev/null +++ b/src/ByteString.hs @@ -0,0 +1,86 @@ +module ByteString + ( -- * ByteString + ByteString + , all + , any + , asHexadecimal + , append + , break + , breakEnd + , breakSubstring + , concat + , concatMap + , cons + , copy + , count + , drop + , dropWhile + , elem + , elemIndex + , elemIndexEnd + , elemIndices + , empty + , filter + , find + , findIndex + , findIndices + , foldl' + , foldr + , group + , groupBy + , index + , inits + , intercalate + , intersperse + , isInfixOf + , isPrefixOf + , isSuffixOf + , length + , map + , mapAccumL + , mapAccumR + , notElem + , null + , pack + , packCString + , packCStringLen + , partition + , replicate + , reverse + , scanl + , scanl1 + , scanr + , scanr1 + , singleton + , snoc + , sort + , span + , spanEnd + , split + , splitAt + , splitWith + , stripPrefix + , stripSuffix + , tails + , take + , takeWhile + , transpose + , uncons + , unfoldr + , unfoldrN + , unpack + , unsnoc + , unzip + , useAsCString + , useAsCStringLen + , zip + , zipWith + -- ** Optics + , bytes + , packedBytes + , unpackedBytes + ) where + +import Data.ByteString +import Data.ByteString.Lens +import Data.ByteString.Lex.Integral (asHexadecimal) diff --git a/src/ByteString/Base16.hs b/src/ByteString/Base16.hs new file mode 100644 --- /dev/null +++ b/src/ByteString/Base16.hs @@ -0,0 +1,6 @@ +module ByteString.Base16 + ( encode + , decode + ) where + +import Data.ByteString.Base16 (decode, encode) diff --git a/src/ByteString/Latin1.hs b/src/ByteString/Latin1.hs new file mode 100644 --- /dev/null +++ b/src/ByteString/Latin1.hs @@ -0,0 +1,96 @@ +module ByteString.Latin1 + ( -- * Latin-1 ByteString + all + , any + , append + , break + , breakEnd + , breakSubstring + , concat + , concatMap + , cons + , copy + , count + , drop + , dropWhile + , elem + , elemIndex + , elemIndexEnd + , elemIndices + , empty + , filter + , find + , findIndex + , findIndices + , foldl' + , foldr' + , foldr + , group + , groupBy + , inits + , intercalate + , intersperse + , isInfixOf + , isPrefixOf + , isSuffixOf + , length + , lines + , map + , mapAccumL + , mapAccumR + , notElem + , null + , pack + , packCString + , packCStringLen + , packDecimal + , packHexadecimal + , packOctal + , readDecimal + , readInt + , readInteger + , readHexadecimal + , readOctal + , readSigned + , replicate + , reverse + , scanl + , scanl1 + , scanr + , scanr1 + , singleton + , snoc + , sort + , span + , spanEnd + , split + , splitAt + , splitWith + , stripPrefix + , stripSuffix + , tails + , take + , takeWhile + , transpose + , uncons + , unfoldr + , unfoldrN + , unlines + , unpack + , unsnoc + , unwords + , unzip + , useAsCString + , useAsCStringLen + , words + , zip + , zipWith + -- ** Optics + , chars + , packedChars + , unpackedChars + ) where + +import Data.ByteString.Char8 +import Data.ByteString.Lens (chars, packedChars, unpackedChars) +import Data.ByteString.Lex.Integral diff --git a/src/ByteString/Latin1/Partial.hs b/src/ByteString/Latin1/Partial.hs new file mode 100644 --- /dev/null +++ b/src/ByteString/Latin1/Partial.hs @@ -0,0 +1,14 @@ +module ByteString.Latin1.Partial + ( foldl1' + , foldr1 + , foldr1' + , head + , index + , init + , last + , maximum + , minimum + , tail + ) where + +import Data.ByteString.Char8 diff --git a/src/ByteString/Lazy.hs b/src/ByteString/Lazy.hs new file mode 100644 --- /dev/null +++ b/src/ByteString/Lazy.hs @@ -0,0 +1,11 @@ +module ByteString.Lazy + ( -- FIXME + module Data.ByteString.Lazy + -- ** Optics + , bytes + , packedBytes + , unpackedBytes + ) where + +import Data.ByteString.Lazy +import Data.ByteString.Lens (bytes, packedBytes, unpackedBytes) diff --git a/src/ByteString/Lazy/Base16.hs b/src/ByteString/Lazy/Base16.hs new file mode 100644 --- /dev/null +++ b/src/ByteString/Lazy/Base16.hs @@ -0,0 +1,6 @@ +module ByteString.Lazy.Base16 + ( encode + , decode + ) where + +import Data.ByteString.Base16.Lazy (decode, encode) diff --git a/src/ByteString/Lazy/Latin1.hs b/src/ByteString/Lazy/Latin1.hs new file mode 100644 --- /dev/null +++ b/src/ByteString/Lazy/Latin1.hs @@ -0,0 +1,5 @@ +module ByteString.Lazy.Latin1 + ( module Data.ByteString.Lazy.Char8 + ) where + +import Data.ByteString.Lazy.Char8 diff --git a/src/ByteString/Lazy/Utf8.hs b/src/ByteString/Lazy/Utf8.hs new file mode 100644 --- /dev/null +++ b/src/ByteString/Lazy/Utf8.hs @@ -0,0 +1,19 @@ +module ByteString.Lazy.Utf8 + ( break + , drop + , foldl + , foldr + , fromString + , length + , span + , splitAt + , take + , toString + , uncons + -- ** Optics + , utf8 + ) where + +import Data.ByteString.Lazy.UTF8 (break, drop, foldl, foldr, fromString, length, + span, splitAt, take, toString, uncons) +import Data.Text.Lazy.Lens (utf8) diff --git a/src/ByteString/Partial.hs b/src/ByteString/Partial.hs new file mode 100644 --- /dev/null +++ b/src/ByteString/Partial.hs @@ -0,0 +1,13 @@ +module ByteString.Partial + ( foldl1' + , foldr1 + , foldr1' + , head + , init + , last + , maximum + , minimum + , tail + ) where + +import Data.ByteString diff --git a/src/ByteString/Short.hs b/src/ByteString/Short.hs new file mode 100644 --- /dev/null +++ b/src/ByteString/Short.hs @@ -0,0 +1,14 @@ +module ByteString.Short + ( -- * ShortByteString + ShortByteString + , toShort + , fromShort + , pack + , unpack + , empty + , null + , length + ) where + +import Data.ByteString.Short (ShortByteString, empty, fromShort, length, null, + pack, toShort, unpack) diff --git a/src/ByteString/Short/Partial.hs b/src/ByteString/Short/Partial.hs new file mode 100644 --- /dev/null +++ b/src/ByteString/Short/Partial.hs @@ -0,0 +1,6 @@ +module ByteString.Short.Partial + ( -- * ShortByteString + index + ) where + +import Data.ByteString.Short (index) diff --git a/src/ByteString/Utf8.hs b/src/ByteString/Utf8.hs new file mode 100644 --- /dev/null +++ b/src/ByteString/Utf8.hs @@ -0,0 +1,19 @@ +module ByteString.Utf8 + ( break + , drop + , foldl + , foldr + , fromString + , length + , span + , splitAt + , take + , toString + , uncons + -- ** Optics + , utf8 + ) where + +import Data.ByteString.UTF8 (break, drop, foldl, foldr, fromString, length, + span, splitAt, take, toString, uncons) +import Data.Text.Strict.Lens (utf8) diff --git a/src/CaseInsensitive.hs b/src/CaseInsensitive.hs new file mode 100644 --- /dev/null +++ b/src/CaseInsensitive.hs @@ -0,0 +1,7 @@ +-- TODO find a better home for CaseInsensitive + +module CaseInsensitive + ( module Data.CaseInsensitive + ) where + +import Data.CaseInsensitive diff --git a/src/Category.hs b/src/Category.hs new file mode 100644 --- /dev/null +++ b/src/Category.hs @@ -0,0 +1,7 @@ +module Category + ( Category(..) + , (>>>) + , (<<<) + ) where + +import Control.Category diff --git a/src/Char.hs b/src/Char.hs new file mode 100644 --- /dev/null +++ b/src/Char.hs @@ -0,0 +1,37 @@ +module Char + ( -- * Char + Char + , isControl + , isSpace + , isLower + , isUpper + , isAlpha + , isAlphaNum + , isPrint + , isDigit + , isOctDigit + , isHexDigit + , isLetter + , isMark + , isNumber + , isPunctuation + , isSymbol + , isSeparator + , isAscii + , isAsciiUpper + , isAsciiLower + , isLatin1 + , GeneralCategory(..) + , generalCategory + , toUpper + , toLower + , toTitle + , ord + , showChar + , showLitChar + , lexLitChar + , readLitChar + ) where + +import Data.Char +import GHC.Show (showChar) diff --git a/src/Char/Partial.hs b/src/Char/Partial.hs new file mode 100644 --- /dev/null +++ b/src/Char/Partial.hs @@ -0,0 +1,7 @@ +module Char.Partial + ( digitToInt + , intToDigit + , chr + ) where + +import Data.Char (chr, digitToInt, intToDigit) diff --git a/src/Clock.hs b/src/Clock.hs new file mode 100644 --- /dev/null +++ b/src/Clock.hs @@ -0,0 +1,18 @@ +{-# LANGUAGE CPP #-} + +module Clock + ( +#if MIN_VERSION_base(4,11,0) + -- * Monotonic time + getMonotonicTime, + getMonotonicTimeNSec, +#endif + -- * CPU time + getCPUTime, + cpuTimePrecision, + ) where + +#if MIN_VERSION_base(4,11,0) +import GHC.Clock +#endif +import System.CPUTime diff --git a/src/Coerce.hs b/src/Coerce.hs new file mode 100644 --- /dev/null +++ b/src/Coerce.hs @@ -0,0 +1,16 @@ +module Coerce + ( -- * Coercible + Coercible + , coerce + -- * Coercion + , Coercion(..) + , coerceWith + , gcoerceWith + , sym + , trans + , repr + , TestCoercion(..) + ) where + +import Data.Coerce +import Data.Type.Coercion diff --git a/src/Coerce/Unsafe.hs b/src/Coerce/Unsafe.hs new file mode 100644 --- /dev/null +++ b/src/Coerce/Unsafe.hs @@ -0,0 +1,5 @@ +module Coerce.Unsafe + ( unsafeCoerce + ) where + +import Unsafe.Coerce (unsafeCoerce) diff --git a/src/Comonad.hs b/src/Comonad.hs new file mode 100644 --- /dev/null +++ b/src/Comonad.hs @@ -0,0 +1,20 @@ +module Comonad + ( -- * Comonad + Comonad(..) + , wfix + , cfix + , kfix + , (=>=) + , (=<=) + , (<<=) + , (=>>) + -- * ComonadApply + , ComonadApply(..) + , (<@@>) + , liftW2 + , liftW3 + -- * Newtypes + , Cokleisli(..) + ) where + +import Control.Comonad diff --git a/src/CompactRegion.hs b/src/CompactRegion.hs new file mode 100644 --- /dev/null +++ b/src/CompactRegion.hs @@ -0,0 +1,17 @@ +module CompactRegion + ( -- * Compact + Compact + , compact + , compactWithSharing + , compactAdd + , compactAddWithSharing + , compactSized + , getCompact + , inCompact + , isCompact + , compactSize + , CompactionFailed(..) + ) where + +import Control.Exception (CompactionFailed(..)) +import Data.Compact diff --git a/src/Concurrency.hs b/src/Concurrency.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency.hs @@ -0,0 +1,115 @@ +module Concurrency + ( -- * Concurrency + -- ** High-level concurrency + concurrently + , concurrently_ + , race + , race_ + , mapConcurrently + , mapConcurrently_ + , forConcurrently + , forConcurrently_ + , replicateConcurrently + , replicateConcurrently_ + , Concurrently(..) + -- ** Low-level concurrency using @async@ + , Async + , async + , asyncBound + , asyncOn + , asyncWithUnmask + , asyncOnWithUnmask + , cancel + , uninterruptibleCancel + , cancelWith + , withAsync + , withAsyncBound + , withAsyncOn + , withAsyncWithUnmask + , withAsyncOnWithUnmask + , wait + , waitSTM + , waitCatch + , waitCatchSTM + , waitAny + , waitAnySTM + , waitAnyCatch + , waitAnyCatchSTM + , waitAnyCancel + , waitAnyCatchCancel + , waitEither + , waitEitherSTM + , waitEither_ + , waitEitherSTM_ + , waitEitherCatch + , waitEitherCatchSTM + , waitEitherCancel + , waitEitherCatchCancel + , waitBoth + , waitBothSTM + , poll + , pollSTM + , link + , link2 + , asyncThreadId + , compareAsyncs + , ExceptionInLinkedThread(..) + , AsyncCancelled(..) + -- ** Lower-level concurrency using @forkIO@ + , forkIO + , forkWithUnmask + , forkOn + , forkOnWithUnmask + , forkFinally + , throwTo + , killThread + -- * STM + , STM + , atomically + , retry + , throwSTM + , catchSTM + , unsafeIOToSTM + -- * Delay + , threadDelay + , registerDelay + -- * Cooperative concurrency + , yield + -- * Thread info + , ThreadId + , myThreadId + , mkWeakThreadId + , ThreadStatus(..) + , BlockReason(..) + , threadStatus + , threadCapability + , labelThread + -- * File descriptor blocking + , threadWaitRead + , threadWaitReadSTM + , threadWaitWrite + , threadWaitWriteSTM + , closeFdWith + -- * Re-exports + , module Concurrency.IORef + , module Concurrency.MVar + , module Concurrency.TVar + , module Concurrency.TMVar + ) where + +import Control.Concurrent.Async (AsyncCancelled(..), + ExceptionInLinkedThread(..), compareAsyncs) +import GHC.Conc (BlockReason(BlockedOnBlackHole, BlockedOnException, BlockedOnForeignCall, BlockedOnMVar, BlockedOnOther, BlockedOnSTM), + ThreadStatus(..), catchSTM, closeFdWith, + labelThread, retry, threadStatus, + threadWaitReadSTM, threadWaitWriteSTM, + throwSTM, unsafeIOToSTM) +import UnliftIO.Async +import UnliftIO.Concurrent +import UnliftIO.STM + +-- Re-exports +import Concurrency.IORef +import Concurrency.MVar +import Concurrency.TMVar +import Concurrency.TVar diff --git a/src/Concurrency/Chan.hs b/src/Concurrency/Chan.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/Chan.hs @@ -0,0 +1,19 @@ +module Concurrency.Chan + ( -- * Creating channels + newChan + , InChan + , OutChan + -- * Reading + , readChan + , readChanOnException + , tryReadChan + , Element(..) + , estimatedLength + -- * Writing + , writeChan + , tryWriteChan + -- * Broadcasting + , dupChan + ) where + +import Control.Concurrent.Chan.Unagi.Bounded diff --git a/src/Concurrency/Counter.hs b/src/Concurrency/Counter.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/Counter.hs @@ -0,0 +1,11 @@ +module Concurrency.Counter + ( -- * Counter + AtomicCounter + , newCounter + , incrCounter + , incrCounter_ + , readCounter + , casCounter + ) where + +import Data.Atomics.Counter diff --git a/src/Concurrency/IORef.hs b/src/Concurrency/IORef.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/IORef.hs @@ -0,0 +1,27 @@ +module Concurrency.IORef + ( -- * IORef + IORef + , newIORef + , readIORef + , writeIORef + , writeIORef' + , modifyIORef + , modifyIORef' + , atomicModifyIORef + , atomicModifyIORef' + , atomicWriteIORef + , atomicWriteIORef' + , mkWeakIORef + -- * Atomic check-and-set + , Ticket + , peekTicket + , readForCAS + , casIORef + , casIORef2 + , atomicModifyIORefCAS + , atomicModifyIORefCAS_ + ) where + +import Data.Atomics +import Data.IORef.Extra (atomicWriteIORef', writeIORef') +import UnliftIO.IORef diff --git a/src/Concurrency/MVar.hs b/src/Concurrency/MVar.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/MVar.hs @@ -0,0 +1,23 @@ +module Concurrency.MVar + ( -- * MVar + MVar + , newEmptyMVar + , newMVar + , takeMVar + , putMVar + , readMVar + , swapMVar + , tryTakeMVar + , tryPutMVar + , isEmptyMVar + , withMVar + , withMVarMasked + , modifyMVar_ + , modifyMVar + , modifyMVarMasked_ + , modifyMVarMasked + , tryReadMVar + , mkWeakMVar + ) where + +import UnliftIO.MVar diff --git a/src/Concurrency/QSem.hs b/src/Concurrency/QSem.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/QSem.hs @@ -0,0 +1,15 @@ +module Concurrency.QSem + ( -- * QSem + QSem + , newQSem + , waitQSem + , signalQSem + -- * QSemN + , QSemN + , newQSemN + , waitQSemN + , signalQSemN + ) where + +import Control.Concurrent.QSem +import Control.Concurrent.QSemN diff --git a/src/Concurrency/TBChan.hs b/src/Concurrency/TBChan.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/TBChan.hs @@ -0,0 +1,5 @@ +module Concurrency.TBChan + ( module Control.Concurrent.STM.TBChan + ) where + +import Control.Concurrent.STM.TBChan diff --git a/src/Concurrency/TBMChan.hs b/src/Concurrency/TBMChan.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/TBMChan.hs @@ -0,0 +1,5 @@ +module Concurrency.TBMChan + ( module Control.Concurrent.STM.TBMChan + ) where + +import Control.Concurrent.STM.TBMChan diff --git a/src/Concurrency/TBMQueue.hs b/src/Concurrency/TBMQueue.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/TBMQueue.hs @@ -0,0 +1,5 @@ +module Concurrency.TBMQueue + ( module Control.Concurrent.STM.TBMQueue + ) where + +import Control.Concurrent.STM.TBMQueue diff --git a/src/Concurrency/TBQueue.hs b/src/Concurrency/TBQueue.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/TBQueue.hs @@ -0,0 +1,22 @@ +module Concurrency.TBQueue + ( + TBQueue + , newTBQueue + , newTBQueueIO + , readTBQueue + , tryReadTBQueue + , flushTBQueue + , peekTBQueue + , tryPeekTBQueue + , writeTBQueue + , unGetTBQueue + , isEmptyTBQueue + , isFullTBQueue + ) where + +import Control.Concurrent.STM.TBQueue (flushTBQueue) +import UnliftIO.STM (TBQueue, isEmptyTBQueue, isFullTBQueue, + newTBQueue, newTBQueueIO, peekTBQueue, + readTBQueue, tryPeekTBQueue, + tryReadTBQueue, unGetTBQueue, + writeTBQueue) diff --git a/src/Concurrency/TBimap.hs b/src/Concurrency/TBimap.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/TBimap.hs @@ -0,0 +1,5 @@ +module Concurrency.TBimap + ( module STMContainers.Bimap + ) where + +import STMContainers.Bimap diff --git a/src/Concurrency/TChan.hs b/src/Concurrency/TChan.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/TChan.hs @@ -0,0 +1,19 @@ +module Concurrency.TChan + ( -- * TChan + TChan + , newTChan + , newTChanIO + , newBroadcastTChan + , newBroadcastTChanIO + , dupTChan + , cloneTChan + , readTChan + , tryReadTChan + , peekTChan + , tryPeekTChan + , writeTChan + , unGetTChan + , isEmptyTChan + ) where + +import UnliftIO.STM diff --git a/src/Concurrency/TMChan.hs b/src/Concurrency/TMChan.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/TMChan.hs @@ -0,0 +1,5 @@ +module Concurrency.TMChan + ( module Control.Concurrent.STM.TMChan + ) where + +import Control.Concurrent.STM.TMChan diff --git a/src/Concurrency/TMQueue.hs b/src/Concurrency/TMQueue.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/TMQueue.hs @@ -0,0 +1,5 @@ +module Concurrency.TMQueue + ( module Control.Concurrent.STM.TMQueue + ) where + +import Control.Concurrent.STM.TMQueue diff --git a/src/Concurrency/TMVar.hs b/src/Concurrency/TMVar.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/TMVar.hs @@ -0,0 +1,19 @@ +module Concurrency.TMVar + ( -- * TMVar + TMVar + , newTMVar + , newTMVarIO + , newEmptyTMVar + , newEmptyTMVarIO + , takeTMVar + , tryTakeTMVar + , putTMVar + , tryPutTMVar + , readTMVar + , tryReadTMVar + , swapTMVar + , isEmptyTMVar + , mkWeakTMVar + ) where + +import UnliftIO.STM diff --git a/src/Concurrency/TMap.hs b/src/Concurrency/TMap.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/TMap.hs @@ -0,0 +1,5 @@ +module Concurrency.TMap + ( module STMContainers.Map + ) where + +import STMContainers.Map diff --git a/src/Concurrency/TMultimap.hs b/src/Concurrency/TMultimap.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/TMultimap.hs @@ -0,0 +1,5 @@ +module Concurrency.TMultimap + ( module STMContainers.Multimap + ) where + +import STMContainers.Multimap diff --git a/src/Concurrency/TSem.hs b/src/Concurrency/TSem.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/TSem.hs @@ -0,0 +1,10 @@ +module Concurrency.TSem + ( -- * TSem + TSem + , newTSem + , waitTSem + , signalTSem + , signalTSemN + ) where + +import Control.Concurrent.STM.TSem diff --git a/src/Concurrency/TSet.hs b/src/Concurrency/TSet.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/TSet.hs @@ -0,0 +1,5 @@ +module Concurrency.TSet + ( module STMContainers.Set + ) where + +import STMContainers.Set diff --git a/src/Concurrency/TVar.hs b/src/Concurrency/TVar.hs new file mode 100644 --- /dev/null +++ b/src/Concurrency/TVar.hs @@ -0,0 +1,15 @@ +module Concurrency.TVar + ( -- * TVar + TVar + , newTVar + , newTVarIO + , readTVar + , readTVarIO + , writeTVar + , modifyTVar + , modifyTVar' + , swapTVar + , mkWeakTVar + ) where + +import UnliftIO.STM diff --git a/src/Constraint.hs b/src/Constraint.hs new file mode 100644 --- /dev/null +++ b/src/Constraint.hs @@ -0,0 +1,10 @@ +-- | + +module Constraint + ( -- * Re-exports + module Data.Constraint + , module Data.Constraint.Forall + ) where + +import Data.Constraint +import Data.Constraint.Forall diff --git a/src/Cont.hs b/src/Cont.hs new file mode 100644 --- /dev/null +++ b/src/Cont.hs @@ -0,0 +1,17 @@ +module Cont + ( -- * Cont + Cont + , cont + , runCont + , mapCont + , withCont + -- * ContT + , ContT(..) + , mapContT + , withContT + -- * MonadCont + , MonadCont(..) + ) where + +import Control.Monad.Cont.Class +import Control.Monad.Trans.Cont diff --git a/src/Contravariant.hs b/src/Contravariant.hs new file mode 100644 --- /dev/null +++ b/src/Contravariant.hs @@ -0,0 +1,13 @@ +module Contravariant + ( -- * Contravariant + Contravariant(..) + , phantom + , (>$<) + , (>$$<) + , ($<) + -- ** Optics + , contramapped + ) where + +import Control.Lens.Setter (contramapped) +import Data.Functor.Contravariant diff --git a/src/Copointed.hs b/src/Copointed.hs new file mode 100644 --- /dev/null +++ b/src/Copointed.hs @@ -0,0 +1,6 @@ +module Copointed + ( -- * Copointed + Copointed(..) + ) where + +import Data.Copointed (Copointed(copoint)) diff --git a/src/Data.hs b/src/Data.hs new file mode 100644 --- /dev/null +++ b/src/Data.hs @@ -0,0 +1,50 @@ +module Data + ( module Data.Data + , gtraverse + , Plated + , plate + , template + , tinplate + , uniplate + , biplate + , children + , rewrite + , rewriteOf + , rewriteOn + , rewriteOnOf + , rewriteM + , rewriteMOf + , rewriteMOn + , rewriteMOnOf + , universe + , universeOf + , universeOn + , universeOnOf + , cosmos + , cosmosOf + , cosmosOn + , cosmosOnOf + , transform + , transformOf + , transformOnOf + , transformM + , transformMOf + , transformMOn + , transformMOnOf + , contexts + , contextsOf + , contextsOn + , contextsOnOf + , holes + , holesOn + , holesOnOf + , para + , paraOf + , deep + , composOpFold + , parts + ) where + +import Control.Lens.Plated +import Data.Data +import Data.Data.Lens diff --git a/src/Debug.hs b/src/Debug.hs new file mode 100644 --- /dev/null +++ b/src/Debug.hs @@ -0,0 +1,69 @@ +{-# LANGUAGE PackageImports #-} + +module Debug + ( -- * Tracing strings + trace + , traceId + , traceShow + , traceShowId + , traceStack + , traceM + , traceShowM + , traceEvent + , traceEventIO + , traceMarker + , traceMarkerIO + -- * Simulated call stack + , CallStack + , currentCallStack + , whoCreated + , HasCallStack + , callStack + , emptyCallStack + , freezeCallStack + , fromCallSiteList + , getCallStack + , popCallStack + , prettyCallStack + , pushCallStack + , withFrozenCallStack + , GHC.Stack.SrcLoc(..) + , prettySrcLoc + -- * Execution stack (requires @libdw@) + , Location(..) + , getStackTrace + , showStackTrace + ) where + +import "base" Prelude + +import Debug.Trace +import GHC.ExecutionStack hiding (Location(..), getStackTrace) +import GHC.Stack + +import qualified GHC.ExecutionStack + +data Location = Location + { objectName :: String + , functionName :: String + , srcLoc :: Maybe (String, Int, Int) + } + +mkLoc :: GHC.ExecutionStack.Location -> Location +mkLoc loc = + Location + { objectName = GHC.ExecutionStack.objectName loc + , functionName = GHC.ExecutionStack.functionName loc + , srcLoc = fmap mkSrcLoc (GHC.ExecutionStack.srcLoc loc) + } + +mkSrcLoc :: GHC.ExecutionStack.SrcLoc -> (String, Int, Int) +mkSrcLoc loc = + ( GHC.ExecutionStack.sourceFile loc + , GHC.ExecutionStack.sourceLine loc + , GHC.ExecutionStack.sourceColumn loc + ) + +getStackTrace :: IO (Maybe [Location]) +getStackTrace = + (fmap.fmap.fmap) mkLoc (GHC.ExecutionStack.getStackTrace) diff --git a/src/Decidable.hs b/src/Decidable.hs new file mode 100644 --- /dev/null +++ b/src/Decidable.hs @@ -0,0 +1,10 @@ +module Decidable + ( -- * Decidable + Decidable(..) + , chosen + , lost + , contramany + ) where + +import Contravariant.Extras +import Data.Functor.Contravariant.Divisible diff --git a/src/Distributive.hs b/src/Distributive.hs new file mode 100644 --- /dev/null +++ b/src/Distributive.hs @@ -0,0 +1,9 @@ +module Distributive + ( -- * Distributive + Distributive(..) + , cotraverse + , comapM + , fmapCollect + ) where + +import Data.Distributive diff --git a/src/Divisible.hs b/src/Divisible.hs new file mode 100644 --- /dev/null +++ b/src/Divisible.hs @@ -0,0 +1,12 @@ +module Divisible + ( Divisible(..) + , divided + , conquered + , contrazip3 + , contrazip4 + , contrazip5 + , Supplied(..) + ) where + +import Contravariant.Extras +import Data.Functor.Contravariant.Divisible diff --git a/src/Dynamic.hs b/src/Dynamic.hs new file mode 100644 --- /dev/null +++ b/src/Dynamic.hs @@ -0,0 +1,10 @@ +module Dynamic + ( -- * Dynamic + Dynamic(..) + , toDyn + , fromDynamic + , dynApply + , dynTypeRep + ) where + +import Data.Dynamic diff --git a/src/Either.hs b/src/Either.hs new file mode 100644 --- /dev/null +++ b/src/Either.hs @@ -0,0 +1,20 @@ +module Either + ( Either(..) + , either + , eitherM + , lefts + , rights + , isLeft + , isRight + , fromLeft + , fromRight + , partitionEithers + -- ** Optics + , _Left + , _Right + ) where + +import Control.Lens.Prism (_Left, _Right) +import Control.Monad.Extra (eitherM) +import Data.Either (Either(Left, Right), either, fromLeft, fromRight, + isLeft, isRight, lefts, partitionEithers, rights) diff --git a/src/Enum.hs b/src/Enum.hs new file mode 100644 --- /dev/null +++ b/src/Enum.hs @@ -0,0 +1,5 @@ +module Enum + ( Enum(..) + ) where + +import GHC.Enum diff --git a/src/Environment.hs b/src/Environment.hs new file mode 100644 --- /dev/null +++ b/src/Environment.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE CPP #-} + +module Environment + ( getArgs + , getFullArgs + , withArgs + , getProgName + , withProgName + , getExecutablePath + , getEnvironment +#if MIN_VERSION_base(4,11,0) + , getEnv + , getEnvDefault +#else + , lookupEnv +#endif + , setEnv + , unsetEnv + ) where + +import GHC.Environment +#if MIN_VERSION_base(4,11,0) +import System.Environment.Blank +#else +import UnliftIO.Environment +#endif diff --git a/src/Equality.hs b/src/Equality.hs new file mode 100644 --- /dev/null +++ b/src/Equality.hs @@ -0,0 +1,32 @@ +{-# LANGUAGE ExplicitNamespaces #-} + +module Equality + ( + Eq(..) + , Equivalence(..) + , defaultEquivalence + , comparisonEquivalence + , Eq1(..) + , eq1 + , liftEqDefault + , Eq2(..) + , eq2 + -- * Propositional equality + , (:~:)(..) + , (:~~:)(..) + , sym + , trans + , castWith + , gcastWith + , apply + , inner + , outer + , TestEquality(..) + , type (==) + ) where + +import Data.Eq +import Data.Functor.Classes +import Data.Functor.Classes.Generic +import Data.Functor.Contravariant +import Data.Type.Equality diff --git a/src/Error.hs b/src/Error.hs new file mode 100644 --- /dev/null +++ b/src/Error.hs @@ -0,0 +1,11 @@ +module Error + ( -- * Error + error + , errorWithoutStackTrace + , undefined + , throw + , assert + ) where + +import Control.Exception +import GHC.Err diff --git a/src/Eval.hs b/src/Eval.hs new file mode 100644 --- /dev/null +++ b/src/Eval.hs @@ -0,0 +1,46 @@ +module Eval + ( -- * Weak head normal form + seq + , lazy + , ($!) + , evaluate + -- * Normal form + , NF + , makeNF + , getNF + , NFData(..) + , deepseq + , force + , ($!!) + , (<$!!>) + , rwhnf + , NFData1(..) + , rnf1 + , NFData2(..) + , rnf2 + -- * Evaluation strategies + , Eval + , runEval + , Strategy + , using + , withStrategy + , dot + , rseq + , rdeepseq + , evalTraversable + , evalList + , evalTuple2 + , evalTuple3 + , evalTuple4 + , evalTuple5 + , evalTuple6 + , evalTuple7 + , evalTuple8 + , evalTuple9 + ) where + +import Control.DeepSeq +import Control.Exception +import Control.Parallel.Strategies hiding (rwhnf) +import Data.NF +import GHC.Base diff --git a/src/Except.hs b/src/Except.hs new file mode 100644 --- /dev/null +++ b/src/Except.hs @@ -0,0 +1,13 @@ +module Except + ( -- * ExceptT + ExceptT(..) + , runExceptT + , mapExceptT + , withExceptT + -- * MonadError + , MonadError(..) + , liftEither + ) where + +import Control.Monad.Error.Class +import Control.Monad.Trans.Except diff --git a/src/Exception.hs b/src/Exception.hs new file mode 100644 --- /dev/null +++ b/src/Exception.hs @@ -0,0 +1,63 @@ +module Exception + ( -- * Throwing exceptions + throwIO + , MonadThrow(..) + -- ** Throwing specific exceptions + , ioError + , userError + , exitWith + , exitFailure + , exitSuccess + , die + -- * Catching exceptions + , catch + , catchAny + , catches + , Handler(..) + , catchJust + , handle + , handleJust + , try + , tryAny + , tryJust + , tryIO + -- * Cleanup + , bracket + , bracket_ + , bracketOnError + , finally + , onException + -- * Masking exceptions + , MaskingState(..) + , mask + , mask_ + , uninterruptibleMask + , uninterruptibleMask_ + , getMaskingState + , interruptible + , allowInterrupt + -- * Exception types + , SomeException(..) + , Exception(..) + , mapException + , ExitCode(..) + , IOException + -- ** Asynchronous exceptions + , SomeAsyncException(..) + , AsyncException(..) + , asyncExceptionToException + , asyncExceptionFromException + ) where + +import Control.Exception (AsyncException(..), Exception(..), IOException, + MaskingState(..), SomeAsyncException(..), + SomeException(..), allowInterrupt, + asyncExceptionFromException, + asyncExceptionToException, getMaskingState, + interruptible, ioError, mapException) +import Control.Monad.Catch (MonadThrow(throwM)) +import System.Exit (ExitCode(..), die, exitFailure, exitSuccess, + exitWith) +import System.IO.Error (userError) +import UnliftIO.Exception hiding (Exception(..), IOException, + SomeAsyncException(..), SomeException(..)) diff --git a/src/FRP.hs b/src/FRP.hs new file mode 100644 --- /dev/null +++ b/src/FRP.hs @@ -0,0 +1,9 @@ +module FRP + ( module Control.Event.Handler + , module Reactive.Banana.Combinators + , module Reactive.Banana.Frameworks + ) where + +import Control.Event.Handler +import Reactive.Banana.Combinators +import Reactive.Banana.Frameworks diff --git a/src/Field.hs b/src/Field.hs new file mode 100644 --- /dev/null +++ b/src/Field.hs @@ -0,0 +1,5 @@ +module Field + ( HasField(..) + ) where + +import GHC.Records diff --git a/src/File.hs b/src/File.hs new file mode 100644 --- /dev/null +++ b/src/File.hs @@ -0,0 +1,50 @@ +module File + ( -- * File path + FilePath + -- * File handle + , Handle + -- ** Standard file handles + , stdin + , stdout + , stderr + -- ** File handle queries + , hFileSize + , hGetEcho + , hGetPosn + , hIsClosed + , hIsEOF + , hIsOpen + , hIsReadable + , hIsSeekable + , hIsTerminalDevice + , hIsWritable + , hReady + , hShow + , hTell + , hWaitForInput + -- ** File handle operations + , hClose + , hFlush + , hSeek + , hSetBinaryMode + , hSetBuffering + , hSetEcho + , hSetFileSize + , hSetPosn + -- ** File handle types + , BufferMode(..) + , HandlePosn + , IOMode(..) + , SeekMode(..) + -- * Re-exports + , module System.FilePath + , module UnliftIO.Temporary + , module UnliftIO.Directory + ) where + +import System.FilePath hiding (FilePath) +import System.IO (FilePath, HandlePosn, SeekMode(..), hGetPosn, + hSetBinaryMode, hSetPosn, hShow) +import UnliftIO.Directory +import UnliftIO.IO +import UnliftIO.Temporary diff --git a/src/File/Binary.hs b/src/File/Binary.hs new file mode 100644 --- /dev/null +++ b/src/File/Binary.hs @@ -0,0 +1,28 @@ +-- | Binary file handling. + +module File.Binary + ( -- * File path operations + withBinaryFile + -- ** Reading + , readFile + , readFileDeserialise + -- ** Writing + , writeFile + , writeFileSerialise + , appendFile + -- * File handle operations + -- ** Reading + , getContents + , hGetContents + , hGet + , hGetSome + , hGetNonBlocking + -- ** Writing + , putStr + , hPutStr + , hPutNonBlocking + ) where + +import Codec.Serialise (readFileDeserialise, writeFileSerialise) +import Data.ByteString +import UnliftIO.IO (withBinaryFile) diff --git a/src/File/Text.hs b/src/File/Text.hs new file mode 100644 --- /dev/null +++ b/src/File/Text.hs @@ -0,0 +1,49 @@ +-- | Textual file handling. + +module File.Text + ( + -- * File path operations + withFile + , openFileBlocking + -- ** Reading + , readFile + -- ** Writing + , writeFile + , appendFile + -- * File handle operations + -- ** Reading + , getChar + , getLine + , getContents + , hGetChar + , hGetLine + , hGetChunk + , hGetContents + -- ** Writing + , putStr + , putStrLn + , print + , hPutStr + , hPutStrLn + , hPrint + -- * File encoding + , TextEncoding + , hSetEncoding + , hGetEncoding + , latin1 + , utf8 + , utf8_bom + , utf16 + , utf16le + , utf16be + , utf32 + , utf32le + , utf32be + ) where + +import Data.Text.IO +import GHC.IO.Handle.FD (openFileBlocking) +import System.IO (TextEncoding, getChar, hGetChar, hGetEncoding, hPrint, + hSetEncoding, latin1, print, utf16, utf16be, utf16le, + utf32, utf32be, utf32le, utf8, utf8_bom) +import UnliftIO.IO (withFile) diff --git a/src/Foldable.hs b/src/Foldable.hs new file mode 100644 --- /dev/null +++ b/src/Foldable.hs @@ -0,0 +1,48 @@ +module Foldable + ( -- * Foldable + Foldable(fold, foldMap, foldr, foldr', foldl', toList, null, length, + elem, sum, product) + , foldrM + , foldlM + , traverse_ + , for_ + , sequenceA_ + , asum + , msum + , concatMap + , and + , or + , all + , notElem + , find + , foldM + , foldM_ + , foldMapBy + , foldBy + , inits + , tails + , insert + , group + , groupBy + , groupWith + , groupAllWith + -- * Foldable1 + , Foldable1(..) + , asum1 + , foldlM1 + , foldrM1 + , for1_ + , intercalate1 + , intercalateMap1 + , sequenceA1_ + , traverse1_ + ) where + +import Control.Monad +import Data.Foldable +import Data.List.NonEmpty (group, groupAllWith, groupBy, groupWith, inits, + insert, tails) +import Data.Reflection +import Data.Semigroup.Foldable (Foldable1(fold1, foldMap1, toNonEmpty), asum1, + foldlM1, foldrM1, for1_, intercalate1, + intercalateMap1, sequenceA1_, traverse1_) diff --git a/src/Foldable/Partial.hs b/src/Foldable/Partial.hs new file mode 100644 --- /dev/null +++ b/src/Foldable/Partial.hs @@ -0,0 +1,9 @@ +module Foldable.Partial + ( foldr1 + , maximum + , maximumBy + , minimum + , minimumBy + ) where + +import Data.Foldable diff --git a/src/Foldl.hs b/src/Foldl.hs new file mode 100644 --- /dev/null +++ b/src/Foldl.hs @@ -0,0 +1,5 @@ +module Foldl + ( module Control.Foldl + ) where + +import Control.Foldl diff --git a/src/Function.hs b/src/Function.hs new file mode 100644 --- /dev/null +++ b/src/Function.hs @@ -0,0 +1,20 @@ +module Function + ( ($) + , ($!) + , (&) + , asTypeOf + , const + , fix + , flip + , loop + , on + , until + , Endo(..) + , Op(..) + ) where + +import Control.Monad.Extra (loop) +import Data.Function +import Data.Functor.Contravariant +import Data.Semigroup (Endo(Endo, appEndo)) +import GHC.Base diff --git a/src/Functor.hs b/src/Functor.hs new file mode 100644 --- /dev/null +++ b/src/Functor.hs @@ -0,0 +1,47 @@ +{-# LANGUAGE CPP #-} + +module Functor + ( -- * Functor + Functor(..) + , (<$>) + , ($>) +#if MIN_VERSION_base(4,11,0) + , (<&>) +#endif + , void + , unzip + -- ** Optics + , mapped + -- * Apply + , Apply(..) + , liftF3 + -- ** Newtypes + , MaybeApply(..) + , Static(..) + -- * Alt + , Alt(..) + -- * Plus + , Plus(..) + -- * Bind + , Bind(..) + , (-<<) + -- * Extend + , Extend(..) + -- * MFunctor + , MFunctor(..) + ) where + +import Control.Lens.Setter (mapped) +import Control.Monad.Morph (MFunctor, hoist) +import Data.Functor (Functor(fmap, (<$)), void, ($>), (<$>)) +#if MIN_VERSION_base(4,11,0) +import Data.Functor ((<&>)) +#endif +import Data.Functor.Alt (Alt(())) +import Data.Functor.Apply (Apply(liftF2, (.>), (<.), (<.>)), + MaybeApply(MaybeApply, runMaybeApply), liftF3) +import Data.Functor.Bind (Bind(join, (>>-)), (-<<)) +import Data.Functor.Extend (Extend(duplicated, extended)) +import Data.Functor.Plus (Plus(zero)) +import Data.List.NonEmpty (unzip) +import Data.Semigroupoid.Static (Static(Static, runStatic)) diff --git a/src/Generic.hs b/src/Generic.hs new file mode 100644 --- /dev/null +++ b/src/Generic.hs @@ -0,0 +1,5 @@ +module Generic + ( module GHC.Generics + ) where + +import GHC.Generics diff --git a/src/Graph/Adjacency.hs b/src/Graph/Adjacency.hs new file mode 100644 --- /dev/null +++ b/src/Graph/Adjacency.hs @@ -0,0 +1,5 @@ +module Graph.Adjacency + ( module Data.Graph + ) where + +import Data.Graph diff --git a/src/Graph/Inductive.hs b/src/Graph/Inductive.hs new file mode 100644 --- /dev/null +++ b/src/Graph/Inductive.hs @@ -0,0 +1,219 @@ +module Graph.Inductive + ( -- * Graph + Gr + , UGr + -- * Static graphs + , Graph(..) + , mkUGraph + , order + , size + , nodes + , edges + , context + , lab + , neighbors + , lneighbors + , suc + , pre + , lsuc + , lpre + , out + , inn + , outdeg + , indeg + , deg + , hasNeighbor + , hasNeighborAdj + , hasEdge + , hasLEdge + , equal + , gelem + , gsel + , gfold + , ufold + , hasLoop + , isSimple + , newNodes + -- ** Articulation points + , ap + -- ** Breadth-first search + , bfs + , bfsn + , bfsWith + , bfsnWith + , level + , leveln + , bfe + , bfen + , bft + , lbft + , esp + , lesp + -- ** Depth-first search + , CFun + , dfs + , dfs' + , dfsWith + , dfsWith' + , dff + , dff' + , dffWith + , dffWith' + , xdfsWith + , xdfWith + , xdffWith + , udfs + , udfs' + , udff + , udff' + , udffWith + , udffWith' + , rdff + , rdff' + , rdfs' + , rdffWith + , rdffWith' + , topsort + , topsort' + , scc + , reachable + , components + , noComponents + , isConnected + , condensation + -- ** Dominators + , dom + , iDom + -- ** Voronoi diagrams + , Voronoi + , gvdIn + , gvdOut + , voronoiSet + , nearestNode + , nearestDist + , nearestPath + -- ** Independent node sets + , indep + , indepSize + -- ** Minimum spanning trees + , msTreeAt + , msTree + , msPath + -- ** Max flow + , getRevEdges + , augmentGraph + , updAdjList + , updateFlow + , mfmg + , mf + , maxFlowgraph + , maxFlow + , Network + , ekSimple + , ekFused + , ekList + -- ** Shortest path + , Heap + , spTree + , sp + , spLength + , dijkstra + -- * Dynamic graphs + , DynGraph(..) + , buildGr + , insNode + , insNodes + , insEdge + , insEdges + , delNode + , delNodes + , delEdge + , delEdges + , delLEdge + , delAllLEdge + , gmap + , nmap + , emap + , nemap + , gfiltermap + , nfilter + , labnfilter + , labfilter + , subgraph + , grev + , undir + , unlab + , efilter + , elfilter + -- ** Bi-connected components + , bcc + -- ** Pretty-printing + , prettify + , prettyPrint + -- ** Transitive/reflexive closure + , trc + , rc + , tc + -- * Misc. types + -- ** Node + , Node + , LNode + , UNode + -- ** Edge + , Edge + , LEdge + , UEdge + , toEdge + , edgeLabel + , toLEdge + -- ** Context + , Context + , MContext + , UContext + , node' + , lab' + , labNode' + , neighbors' + , lneighbors' + , suc' + , pre' + , lpre' + , lsuc' + , out' + , inn' + , outdeg' + , indeg' + , deg' + -- ** Decomposition + , Decomp + , GDecomp + , UDecomp + -- ** Path + , Path + , LPath(..) + , UPath + -- ** Tree + , RTree + , LRTree + -- ** Adj + , Adj + -- ** OrdGr + , OrdGr(..) + ) where + +import Data.Graph.Inductive.Basic +import Data.Graph.Inductive.Graph +import Data.Graph.Inductive.PatriciaTree +import Data.Graph.Inductive.Query + +-- TODO: +-- DFS +-- Dominators +-- GVD +-- Indep +-- MST +-- MaxFlow +-- MaxFlow2 +-- Monad +-- SP +-- TransClos diff --git a/src/Groupoid.hs b/src/Groupoid.hs new file mode 100644 --- /dev/null +++ b/src/Groupoid.hs @@ -0,0 +1,5 @@ +module Groupoid + ( Groupoid(..) + ) where + +import Data.Groupoid (Groupoid(inv)) diff --git a/src/Hashable.hs b/src/Hashable.hs new file mode 100644 --- /dev/null +++ b/src/Hashable.hs @@ -0,0 +1,16 @@ +module Hashable + ( -- * Hashable + Hashable(..) + , hashUsing + , hashPtr + , hashPtrWithSalt + , hashByteArray + , hashByteArrayWithSalt + , Hashed + , hashed + , unhashed + , mapHashed + , traverseHashed + ) where + +import Data.Hashable diff --git a/src/Heap.hs b/src/Heap.hs new file mode 100644 --- /dev/null +++ b/src/Heap.hs @@ -0,0 +1,5 @@ +module Heap + ( module Data.Heap + ) where + +import Data.Heap diff --git a/src/IO.hs b/src/IO.hs new file mode 100644 --- /dev/null +++ b/src/IO.hs @@ -0,0 +1,17 @@ +module IO + ( -- * IO + IO + , MonadIO(..) + , fixIO + , timeout + , once + , onceFork + -- * IO exceptions + , module System.IO.Error + ) where + +import Control.Concurrent.Extra (once, onceFork) +import Control.Monad.IO.Class (MonadIO(..)) +import System.IO +import System.IO.Error +import UnliftIO.Timeout (timeout) diff --git a/src/IO/Unsafe.hs b/src/IO/Unsafe.hs new file mode 100644 --- /dev/null +++ b/src/IO/Unsafe.hs @@ -0,0 +1,9 @@ +module IO.Unsafe + ( unsafePerformIO + , unsafeDupablePerformIO + , unsafeInterleaveIO + , unsafeFixIO + ) where + +import System.IO.Unsafe (unsafeDupablePerformIO, unsafeFixIO, + unsafeInterleaveIO, unsafePerformIO) diff --git a/src/Ix.hs b/src/Ix.hs new file mode 100644 --- /dev/null +++ b/src/Ix.hs @@ -0,0 +1,5 @@ +module Ix + ( Ix(..) + ) where + +import Data.Ix diff --git a/src/Json.hs b/src/Json.hs new file mode 100644 --- /dev/null +++ b/src/Json.hs @@ -0,0 +1,35 @@ +-- | +-- JSON functionality common to both encoding and decoding. Re-exported by both +-- "Json.Encode" and "Json.Decode" for convenience. + +module Json + ( + Value(..) + , Primitive(..) + -- * Prisms + , AsNumber + , _Number + , _Double + , _Integer + , _Integral + , nonNull + , AsPrimitive + , _Primitive + , _String + , _Bool + , _Null + , AsValue + , _Value + , _Object + , _Array + , AsJSON + , _JSON + -- * Traversals + , key + , members + , nth + , values + ) where + +import Data.Aeson (Value(..)) +import Data.Aeson.Lens diff --git a/src/Json/Decode.hs b/src/Json/Decode.hs new file mode 100644 --- /dev/null +++ b/src/Json/Decode.hs @@ -0,0 +1,58 @@ +module Json.Decode + ( -- * Decoding + FromJSON(..) + , gparseJson + , FromJSONKey(..) + , FromJSONKeyFunction(..) + , fromJSON + , decode + , decode' + , decodeStrict + , decodeStrict' + , eitherDecode + , eitherDecode' + , eitherDecodeStrict + , eitherDecodeStrict' + , decodeWith + , decodeStrictWith + , eitherDecodeWith + , eitherDecodeStrictWith + , withObject + , withText + , withArray + , withScientific + , withBool + , withEmbeddedJSON + , (.:) + , (.:?) + , (.:!) + , (.!=) + , parseField + , parseFieldMaybe + , parseFieldMaybe' + , explicitParseField + , explicitParseFieldMaybe + , explicitParseFieldMaybe' + , Parser + , Result(..) + , parse + , parseMaybe + , parseEither + , iparse + , json + , json' + , value + , value' + , jstring + , scientific + -- * Re-exports + , module Json + ) where + +import Json + +import Data.Aeson +import Data.Aeson.Internal +import Data.Aeson.Parser +import Data.Aeson.Types +import Generics.Generic.Aeson (gparseJson) diff --git a/src/Json/Encode.hs b/src/Json/Encode.hs new file mode 100644 --- /dev/null +++ b/src/Json/Encode.hs @@ -0,0 +1,85 @@ +module Json.Encode + ( -- * Encoding + Array + , emptyArray + , Object + , emptyObject + , ToJSON(..) + , gtoJson + , ToJSONKey(..) + , ToJSONKeyFunction(..) + , encode + , encodeToLazyText + , encodePretty + , KeyValue + , (.=) + , object + -- ** Direct encoding + , Encoding + , Encoding' + , encodingToLazyByteString + , Series + , pairs + , pair + , pair' + , foldable + , emptyArray_ + , emptyObject_ + , text + , lazyText + , string + , list + , dict + , null_ + , bool + , int8 + , int16 + , int32 + , int64 + , int + , word8 + , word16 + , word32 + , word64 + , word + , integer + , float + , double + , scientific + , int8Text + , int16Text + , int32Text + , int64Text + , intText + , word8Text + , word16Text + , word32Text + , word64Text + , wordText + , integerText + , floatText + , doubleText + , scientificText + , day + , localTime + , utcTime + , timeOfDay + , zonedTime + , value + -- ** Quasi-quotation + , aesonQQ + -- * Newtypes + , DotNetTime(..) + -- * Re-exports + , module Json + ) where + +import Json + +import Data.Aeson +import Data.Aeson.Encode.Pretty (encodePretty) +import Data.Aeson.Encoding +import Data.Aeson.QQ (aesonQQ) +import Data.Aeson.Text +import Data.Aeson.Types +import Generics.Generic.Aeson (gtoJson) diff --git a/src/Label.hs b/src/Label.hs new file mode 100644 --- /dev/null +++ b/src/Label.hs @@ -0,0 +1,5 @@ +module Label + ( IsLabel(..) + ) where + +import GHC.OverloadedLabels diff --git a/src/List.hs b/src/List.hs new file mode 100644 --- /dev/null +++ b/src/List.hs @@ -0,0 +1,173 @@ +{-# LANGUAGE CPP #-} + +module List + ( -- * List + (++) + , (\\) + , allSame + , anySame + , break + , breakOn + , breakOnEnd + , breakEnd + , chop + , cons + , cycle + , delete + , deleteBy + , deleteFirstsBy + , disjoint + , divvy + , drop + , dropEnd + , dropPrefix + , dropSuffix + , dropWhile + , dropWhileEnd + , elemIndex + , elemIndices + , endBy + , filter + , findIndex + , findIndices + , genericDrop + , genericIndex + , genericLength + , genericReplicate + , genericSplitAt + , genericTake + , group + , groupBy + , groupOn + , groupSort + , groupSortBy + , groupSortOn + , inits + , insert + , insertBy + , intercalate + , intersect + , intersectBy + , intersperse + , isInfixOf + , isPrefixOf + , isSubsequenceOf + , isSuffixOf + , iterate +#if MIN_VERSION_base(4,11,0) + , iterate' +#endif + , lookup + , map + , nub + , nubBy + , nubOn + , nubOrd + , nubOrdBy + , nubOrdOn + , nubSort + , nubSortBy + , nubSortOn + , partition + , permutations + , repeat + , replicate + , reverse + , scanl + , scanl' + , scanl1 + , scanr + , scanr1 + , sort + , sortBy + , sortOn + , span + , spanEnd + , split + , splitAt + , splitAtEnd + , splitOn + , snoc + , stripInfix + , stripInfixEnd + , stripPrefix + , stripSuffix + , subsequences + , tails + , take + , takeEnd + , takeWhile + , takeWhileEnd + , transpose + , uncons + , unfoldr + , union + , unionBy + , unsnoc + , unzip + , unzip3 + , unzip4 + , unzip5 + , unzip6 + , unzip7 + , wordsBy + , zip + , zip3 + , zip4 + , zip5 + , zip6 + , zip7 + , zipWith + , zipWith3 + , zipWith4 + , zipWith5 + , zipWith6 + , zipWith7 + -- ** String + , String + , words + , unwords + , lines + , unlines + , lower + , upper + , trim + , trimStart + , trimEnd + , showString + , lexDigits + , IsString(..) + -- ** Optics + , prefixed + , suffixed + ) where + +import Data.List (break, cycle, delete, deleteBy, deleteFirstsBy, drop, + dropWhile, dropWhileEnd, elemIndex, elemIndices, filter, + findIndex, findIndices, genericDrop, genericIndex, + genericLength, genericReplicate, genericSplitAt, genericTake, + group, groupBy, inits, insert, insertBy, intercalate, + intersect, intersectBy, intersperse, isInfixOf, isPrefixOf, + isSubsequenceOf, isSuffixOf, iterate, lines, lookup, map, nub, + nubBy, partition, permutations, repeat, replicate, reverse, + scanl, scanl', scanl1, scanr, scanr1, sort, sortBy, sortOn, + span, splitAt, stripPrefix, subsequences, tails, take, + takeWhile, transpose, uncons, unfoldr, union, unionBy, + unlines, unwords, unzip, unzip3, unzip4, unzip5, unzip6, + unzip7, words, zip, zip3, zip4, zip5, zip6, zip7, zipWith, + zipWith3, zipWith4, zipWith5, zipWith6, zipWith7, (++), (\\)) +#if MIN_VERSION_base(4,11,0) +import Data.List (iterate') +#endif +import Data.List.Extra (allSame, anySame, breakEnd, breakOn, breakOnEnd, cons, + disjoint, dropEnd, dropPrefix, dropSuffix, groupOn, + groupSort, groupSortBy, groupSortOn, lower, nubOn, + nubOrd, nubOrdBy, nubOrdOn, nubSort, nubSortBy, + nubSortOn, snoc, spanEnd, split, splitAtEnd, stripInfix, + stripInfixEnd, stripSuffix, takeEnd, takeWhileEnd, trim, + trimEnd, trimStart, unsnoc, upper, wordsBy) +import Data.List.Lens (prefixed, suffixed) +import Data.List.Split (chop, divvy, endBy, splitOn) +import Data.String (IsString(fromString), String) +import GHC.Show (showString) +import Numeric (lexDigits) diff --git a/src/List/Builder.hs b/src/List/Builder.hs new file mode 100644 --- /dev/null +++ b/src/List/Builder.hs @@ -0,0 +1,20 @@ +module List.Builder + ( -- * List builder + DList(Nil, Cons) + , fromList + , toList + , apply + , empty + , singleton + , cons + , snoc + , append + , concat + , replicate + , list + , unfoldr + , foldr + , map + ) where + +import Data.DList diff --git a/src/List/Builder/Partial.hs b/src/List/Builder/Partial.hs new file mode 100644 --- /dev/null +++ b/src/List/Builder/Partial.hs @@ -0,0 +1,6 @@ +module List.Builder.Partial + ( head + , tail + ) where + +import Data.DList diff --git a/src/List/Partial.hs b/src/List/Partial.hs new file mode 100644 --- /dev/null +++ b/src/List/Partial.hs @@ -0,0 +1,11 @@ +module List.Partial + ( (!!) + , chunksOf + , head + , init + , last + , tail + ) where + +import Data.List (head, init, last, tail, (!!)) +import Data.List.Extra (chunksOf) diff --git a/src/List1.hs b/src/List1.hs new file mode 100644 --- /dev/null +++ b/src/List1.hs @@ -0,0 +1,46 @@ +module List1 + ( NonEmpty(..) + , break + , cons + , cycle + , drop + , dropWhile + , filter + , group1 + , groupAllWith1 + , groupBy1 + , groupWith1 + , head + , init + , intersperse + , isPrefixOf + , iterate + , last + , map + , nonEmpty + , nub + , nubBy + , partition + , repeat + , reverse + , scanl + , scanl1 + , scanr + , scanr1 + , sort + , sortBy + , sortWith + , span + , splitAt + , tail + , take + , takeWhile + , transpose + , uncons + , unfoldr + , xor + , zip + , zipWith + ) where + +import Data.List.NonEmpty diff --git a/src/List1/Partial.hs b/src/List1/Partial.hs new file mode 100644 --- /dev/null +++ b/src/List1/Partial.hs @@ -0,0 +1,6 @@ +module List1.Partial + ( (!!) + , fromList + ) where + +import Data.List.NonEmpty (fromList, (!!)) diff --git a/src/ListT.hs b/src/ListT.hs new file mode 100644 --- /dev/null +++ b/src/ListT.hs @@ -0,0 +1,14 @@ +module ListT + ( ListT(..) + , runListT + , fold + , foldM + , select + , take + , drop + , takeWhile + , unfold + , zip + ) where + +import List.Transformer diff --git a/src/Logic.hs b/src/Logic.hs new file mode 100644 --- /dev/null +++ b/src/Logic.hs @@ -0,0 +1,24 @@ +module Logic + ( -- ** Logic + Logic + , logic + , runLogic + , observeAll + -- ** LogicT + , LogicT(..) + , runLogicT + , observeT + , observeManyT + , observeAllT + -- ** MonadLogic + , MonadLogic + , msplit + , interleave + , (>>-) + , ifte + , once + , reflect + , lnot + ) where + +import Control.Monad.Logic diff --git a/src/Managed.hs b/src/Managed.hs new file mode 100644 --- /dev/null +++ b/src/Managed.hs @@ -0,0 +1,12 @@ +module Managed + ( -- * Managed + Managed + , managed + , managed_ + , with + , runManaged + -- * MonadManaged + , MonadManaged(..) + ) where + +import Control.Monad.Managed diff --git a/src/Map.hs b/src/Map.hs new file mode 100644 --- /dev/null +++ b/src/Map.hs @@ -0,0 +1,5 @@ +module Map + ( module Data.Map.Strict + ) where + +import Data.Map.Strict diff --git a/src/Map/Hash.hs b/src/Map/Hash.hs new file mode 100644 --- /dev/null +++ b/src/Map/Hash.hs @@ -0,0 +1,5 @@ +module Map.Hash + ( module Data.HashMap.Strict + ) where + +import Data.HashMap.Strict diff --git a/src/Map/Int.hs b/src/Map/Int.hs new file mode 100644 --- /dev/null +++ b/src/Map/Int.hs @@ -0,0 +1,5 @@ +module Map.Int + ( module Data.IntMap.Strict + ) where + +import Data.IntMap.Strict diff --git a/src/Map/Int/Lazy.hs b/src/Map/Int/Lazy.hs new file mode 100644 --- /dev/null +++ b/src/Map/Int/Lazy.hs @@ -0,0 +1,5 @@ +module Map.Int.Lazy + ( module Data.IntMap.Lazy + ) where + +import Data.IntMap.Lazy diff --git a/src/Map/Lazy.hs b/src/Map/Lazy.hs new file mode 100644 --- /dev/null +++ b/src/Map/Lazy.hs @@ -0,0 +1,5 @@ +module Map.Lazy + ( module Data.Map.Lazy + ) where + +import Data.Map.Lazy diff --git a/src/Maybe.hs b/src/Maybe.hs new file mode 100644 --- /dev/null +++ b/src/Maybe.hs @@ -0,0 +1,27 @@ +module Maybe + ( -- * Maybe + Maybe(..) + , maybe + , maybeM + , isJust + , isNothing + , fromMaybe + , listToMaybe + , maybeToList + , catMaybes + , mapMaybe + -- ** Prisms + , _Just + , _Nothing + -- ** Newtypes + , Option(..) + , option + , First(..) + , Last(..) + ) where + +import Control.Lens.Prism (_Just, _Nothing) +import Control.Monad.Extra (maybeM) +import Data.Maybe +import Data.Monoid +import Data.Semigroup (Option(..), option) diff --git a/src/Maybe/Partial.hs b/src/Maybe/Partial.hs new file mode 100644 --- /dev/null +++ b/src/Maybe/Partial.hs @@ -0,0 +1,5 @@ +module Maybe.Partial + ( fromJust + ) where + +import Data.Maybe (fromJust) diff --git a/src/MaybeT.hs b/src/MaybeT.hs new file mode 100644 --- /dev/null +++ b/src/MaybeT.hs @@ -0,0 +1,7 @@ +module MaybeT + ( -- * MaybeT + MaybeT(..) + , mapMaybeT + ) where + +import Control.Monad.Trans.Maybe diff --git a/src/Mitchell/Prelude.hs b/src/Mitchell/Prelude.hs new file mode 100644 --- /dev/null +++ b/src/Mitchell/Prelude.hs @@ -0,0 +1,376 @@ +{-# LANGUAGE CPP #-} + +module Mitchell.Prelude + ( -- * Ala.Identity + Identity(..) + -- * Applicative + , Applicative(..) + , filterM + , forever + , liftA3 + , replicateM + , replicateM_ + , unless + , when + , zipWithM + , zipWithM_ + , Alternative((<|>), empty) + , guard + , optional + -- * Bool + , Bool(..) + , (&&) + , (||) + , not + , otherwise + -- * Bounded + , Bounded(..) + , ByteString + -- * Category + , Category(..) + , (>>>) + , (<<<) + -- * Char + , Char +#if MIN_VERSION_base(4,11,0) + -- * Clock + , getMonotonicTime + , getMonotonicTimeNSec +#endif + -- * Coerce + , Coercible + , coerce + -- * Debug + , trace + , traceId + , traceShow + , traceShowId + , traceStack + , traceM + , traceShowM + -- * Either + , Either(Left, Right) + , either + , eitherM + , _Left + , _Right + -- * Enum + , Enum(..) + -- * Equality + , Eq(..) + -- * Error + , assert + , error + , undefined + -- * Exception + , Exception + , SomeException(..) + , SomeAsyncException(..) + , throwIO + -- * File + , stdin + , stdout + , stderr + -- * File.Text + , hGetChar + , hGetLine + , hGetContents + , putStr + , putStrLn + , print + , hPutStr + , hPutStrLn + , hPrint + -- * Foldable + , Foldable(..) + , foldrM + , foldlM + , traverse_ + , for_ + , sequenceA_ + , asum + , msum + , concatMap + , and + , or + , all + , notElem + , find + , foldM + , foldM_ + , foldMapBy + , foldBy + -- * Function + , ($) + , ($!) + , (&) + , const + , fix + , flip + , until + , Endo(..) + -- * Functor + , Functor(..) + , (<$>) + , ($>) +#if MIN_VERSION_base(4,11,0) + , (<&>) +#endif + , void + -- * Generic + , Generic + -- * Hashable + , Hashable + -- * IO + , IO + , MonadIO(..) + -- * List + , (++) + , cycle + , iterate +#if MIN_VERSION_base(4,11,0) + , iterate' +#endif + , map + , repeat + , replicate + , scanl + , scanl' + , scanl1 + , scanr + , scanr1 + , unfoldr + -- * Map + , Map + -- * Map.Hash + , HashMap + -- * Map.Int + , IntMap + -- * Maybe + , Maybe(..) + , maybe + , maybeM + , fromMaybe + , catMaybes + , mapMaybe + , _Nothing + , _Just + -- * Monad + , Monad(..) + , (=<<) + , (>=>) + , (<=<) + , unlessM + , whenJustM + , whenM + , whileM + -- * Monad.Trans + , MonadTrans(..) + -- * Monoid + , Monoid + , mconcat + , mempty + -- * Numeric.Double + , Double + -- * Numeric.Float + , Float + -- * Numeric.Floating + , Floating(..) + -- * Numeric.Fractional + , Fractional(..) + -- * Numeric.Int + , Int + , Int8 + , Int16 + , Int32 + , Int64 + -- * Numeric.Integer + , Integer + -- * Numeric.Integral + , Integral(..) + , even + , odd + , gcd + , lcm + , fromIntegral + -- * Numeric.Nat + , Nat + , KnownNat + , natVal + , natVal' + , SomeNat(..) + , someNatVal + -- * Numeric.Num + , Num(..) + , subtract + -- * Numeric.Real + , Real(..) + , div' + , mod' + , divMod' + , realToFrac + -- * Numeric.RealFloat + , RealFloat(..) + -- * Numeric.RealFrac + , RealFrac(..) + -- * Numeric.Word + , Word + , Word8 + , Word16 + , Word32 + , Word64 + -- * Optic.Fold + , (^?) + , preview + , has + , folded + -- * Optic.Getting + , (^.) + , view + -- * Optic.Lens + , Lens + , Lens' + , lens + -- * Optic.Lens.At + , At(..) + -- * Optic.Prism + , Prism + , prism + , is + -- * Optic.Setter + , (.~) + , (%~) + , over + , set + -- * Optic.Traversal + , Traversal + -- * Optic.Traversal.Ixed + , Ixed(..) + , Index + , IxValue + -- * Ord + , Ord(..) + , Ordering(..) + -- * Semigroup + , Semigroup(..) + -- * Sequence + , Seq + -- * Set + , Set + -- * Set.Hash + , HashSet + -- * Set.Int + , IntSet + -- * Show + , Show(show) + -- * Text + , Text + -- * Traversable + , Traversable(..) + , for + -- * Tuple + , fst + , snd + , Field1(..) + , Field2(..) + , Field3(..) + , Field4(..) + , Field5(..) + , Field6(..) + -- * Void + , Void + ) where + +import Ala.Identity (Identity(Identity, runIdentity)) +import Applicative (Alternative(empty, (<|>)), Applicative, filterM, forever, + guard, liftA2, liftA3, optional, pure, replicateM, + replicateM_, unless, when, zipWithM, zipWithM_, (*>), (<*), + (<*>)) +import Bool (Bool(False, True), not, otherwise, (&&), (||)) +import Bounded (Bounded(maxBound, minBound)) +import ByteString (ByteString) +import Category (Category(id, (.)), (<<<), (>>>)) +import Char (Char) +#if MIN_VERSION_base(4,11,0) +import Clock (getMonotonicTime, getMonotonicTimeNSec) +#endif +import Coerce (Coercible, coerce) +import Debug (trace, traceId, traceM, traceShow, traceShowId, traceShowM, + traceStack) +import Either (Either(Left, Right), either) +import Either (eitherM) +import Either (_Left, _Right) +import Enum (Enum(enumFrom, enumFromThen, enumFromThenTo, enumFromTo, fromEnum, pred, succ, toEnum)) +import Equality (Eq((/=), (==))) +import Error (assert, error, undefined) +import Exception (Exception, SomeAsyncException(SomeAsyncException), + SomeException(SomeException), throwIO) +import File (stderr, stdin, stdout) +import File.Text (hGetChar, hPrint, print) +import File.Text (hGetContents, hGetLine, hPutStr, hPutStrLn, putStr, putStrLn) +import Foldable (Foldable(elem, fold, foldMap, foldl', foldr, foldr', length, null, product, sum, toList), + all, and, asum, concatMap, find, foldM, foldM_, foldlM, + foldrM, for_, msum, notElem, or, sequenceA_, traverse_) +import Foldable (foldBy, foldMapBy) +import Function (Endo(Endo, appEndo), const, fix, flip, until, ($), ($!), (&)) +import Functor (Functor(fmap, (<$)), void, ($>), (<$>)) +#if MIN_VERSION_base(4,11,0) +import Functor ((<&>)) +#endif +import Generic (Generic) +import Hashable (Hashable) +import IO (IO, MonadIO(liftIO)) +import List (cycle, iterate, map, repeat, replicate, scanl, scanl', scanl1, + scanr, scanr1, unfoldr, (++)) +#if MIN_VERSION_base(4,11,0) +import List (iterate') +#endif +import Map (Map) +import Map.Hash (HashMap) +import Map.Int (IntMap) +import Maybe (Maybe(Just, Nothing), catMaybes, fromMaybe, + mapMaybe, maybe) +import Maybe (maybeM) +import Maybe (_Just, _Nothing) +import Monad (Monad((>>=)), (<=<), (=<<), (>=>)) +import Monad (unlessM, whenJustM, whenM, whileM) +import Monad.Trans (MonadTrans(lift)) +import Monoid (Monoid, mconcat, mempty) +import Numeric.Double (Double) +import Numeric.Float (Float) +import Numeric.Floating (Floating(..)) +import Numeric.Fractional (Fractional(..)) +import Numeric.Int (Int, Int16, Int32, Int64, Int8) +import Numeric.Integer (Integer) +import Numeric.Integral (Integral(..), even, fromIntegral, gcd, lcm, odd) +import Numeric.Nat (KnownNat, Nat, SomeNat(..), natVal, natVal', + someNatVal) +import Numeric.Num (Num(..), subtract) +import Numeric.Real (Real(..), div', divMod', mod', realToFrac) +import Numeric.RealFloat (RealFloat(..)) +import Numeric.RealFrac (RealFrac(..)) +import Numeric.Word (Word, Word16, Word32, Word64, Word8) +import Optic.Fold (folded, has, preview, (^?)) +import Optic.Getting (view, (^.)) +import Optic.Lens (Lens, Lens', lens) +import Optic.Lens.At (At(at)) +import Optic.Prism (Prism, is, prism) +import Optic.Setter (over, set, (%~), (.~)) +import Optic.Traversal (Traversal) +import Optic.Traversal.Ixed (Index, IxValue, Ixed(ix)) +import Ord (Ord(compare, max, min, (<), (<=), (>), (>=)), + Ordering(EQ, GT, LT)) +import Semigroup (Semigroup((<>))) +import Sequence (Seq) +import Set (Set) +import Set.Hash (HashSet) +import Set.Int (IntSet) +import Show (Show, show) +import Text (Text) +import Traversable (Traversable(sequenceA, traverse), for) +import Tuple (fst, snd) +import Tuple (Field1(_1), Field2(_2), Field3(_3), Field4(_4), + Field5(_5), Field6(_6)) +import Void (Void) + +import Data.Orphans () diff --git a/src/Monad.hs b/src/Monad.hs new file mode 100644 --- /dev/null +++ b/src/Monad.hs @@ -0,0 +1,29 @@ +module Monad + ( -- * Monad + Monad((>>=), return) + , (=<<) + , (>=>) + , (<=<) + , (<$!>) + , join + , loopM + , unlessM + , whenJustM + , whenM + , whileM + -- ** Newtypes + , Kleisli(..) + -- * MMonad + , MMonad(..) + , squash + , (>|>) + , (<|<) + , (=<|) + , (|>=) + ) where + +import Control.Arrow (Kleisli(Kleisli, runKleisli)) +import Control.Monad (Monad(return, (>>=)), join, (<$!>), (<=<), (=<<), + (>=>)) +import Control.Monad.Extra (loopM, unlessM, whenJustM, whenM, whileM) +import Control.Monad.Morph (MMonad(embed), squash, (<|<), (=<|), (>|>), (|>=)) diff --git a/src/Monad/Base.hs b/src/Monad/Base.hs new file mode 100644 --- /dev/null +++ b/src/Monad/Base.hs @@ -0,0 +1,5 @@ +module Monad.Base + ( MonadBase(..) + ) where + +import Control.Monad.Base (MonadBase(..)) diff --git a/src/Monad/Fail.hs b/src/Monad/Fail.hs new file mode 100644 --- /dev/null +++ b/src/Monad/Fail.hs @@ -0,0 +1,5 @@ +module Monad.Fail + ( MonadFail(..) + ) where + +import Control.Monad.Fail diff --git a/src/Monad/Fix.hs b/src/Monad/Fix.hs new file mode 100644 --- /dev/null +++ b/src/Monad/Fix.hs @@ -0,0 +1,5 @@ +module Monad.Fix + ( MonadFix(..) + ) where + +import Control.Monad.Fix (MonadFix(..)) diff --git a/src/Monad/Plus.hs b/src/Monad/Plus.hs new file mode 100644 --- /dev/null +++ b/src/Monad/Plus.hs @@ -0,0 +1,23 @@ +module Monad.Plus + ( MonadPlus(..) + , endBy + , endBy1 + , many + , mfilter + , sepBy1 + , sepEndBy1 + , someTill + , manyTill + , sepBy + , sepEndBy + , skipMany + , skipManyTill + , skipSome + , skipSomeTill + ) where + +import Control.Monad (MonadPlus(..), mfilter) +import Control.Monad.Combinators (endBy, many, manyTill, sepBy, + sepEndBy, skipMany, skipManyTill, + skipSome, skipSomeTill) +import Control.Monad.Combinators.NonEmpty (endBy1, sepBy1, sepEndBy1, someTill) diff --git a/src/Monad/Trans.hs b/src/Monad/Trans.hs new file mode 100644 --- /dev/null +++ b/src/Monad/Trans.hs @@ -0,0 +1,30 @@ +module Monad.Trans + ( -- * MonadTrans + MonadTrans(..) + -- * Free monad transformer + , FreeF(..) + , liftF + , Free + , free + , runFree + , retract + , iter + , iterM + , FreeT(..) + , iterT + , iterTM + , hoistFreeT + , foldFreeT + , transFreeT + , joinFreeT + , retractT + , MonadFree(..) + ) where + +import Control.Monad.Trans.Class (MonadTrans(..)) +import Control.Monad.Trans.Free (Free, FreeF(Free, Pure), + FreeT(FreeT, runFreeT), MonadFree(wrap), + foldFreeT, free, hoistFreeT, iter, iterM, + iterT, iterTM, joinFreeT, liftF, retract, + retractT, runFree, transFreeT) + diff --git a/src/Monad/Zip.hs b/src/Monad/Zip.hs new file mode 100644 --- /dev/null +++ b/src/Monad/Zip.hs @@ -0,0 +1,5 @@ +module Monad.Zip + ( MonadZip(..) + ) where + +import Control.Monad.Zip (MonadZip(..)) diff --git a/src/Monoid.hs b/src/Monoid.hs new file mode 100644 --- /dev/null +++ b/src/Monoid.hs @@ -0,0 +1,8 @@ +module Monoid + ( -- * Monoid + Monoid(mconcat, mempty) + , gmempty + ) where + +import Data.Monoid +import Data.Semigroup.Generic diff --git a/src/MultiSet.hs b/src/MultiSet.hs new file mode 100644 --- /dev/null +++ b/src/MultiSet.hs @@ -0,0 +1,68 @@ +module MultiSet + ( -- * MultiSet + MultiSet + , Occur + , null + , size + , distinctSize + , member + , notMember + , occur + , isSubsetOf + , isProperSubsetOf + , empty + , singleton + , insert + , insertMany + , delete + , deleteMany + , deleteAll + , union + , unions + , maxUnion + , difference + , intersection + , filter + , partition + , split + , splitOccur + , map + , mapMonotonic + , mapMaybe + , mapEither + , concatMap + , unionsMap + , bind + , join + , fold + , foldOccur + , findMin + , findMax + , deleteMin + , deleteMax + , deleteMinAll + , deleteMaxAll + , deleteFindMin + , deleteFindMax + , maxView + , minView + , elems + , distinctElems + , toList + , toAscList + , toOccurList + , toAscOccurList + , fromList + , fromAscList + , fromDistinctAscList + , fromOccurList + , fromAscOccurList + , fromDistinctAscOccurList + , toMap + , fromMap + , fromOccurMap + , toSet + , fromSet + ) where + +import Data.MultiSet diff --git a/src/MultiSet/Int.hs b/src/MultiSet/Int.hs new file mode 100644 --- /dev/null +++ b/src/MultiSet/Int.hs @@ -0,0 +1,68 @@ +module MultiSet.Int + ( -- * IntMultiSet + IntMultiSet + , Key + , null + , size + , distinctSize + , member + , notMember + , occur + , isSubsetOf + , isProperSubsetOf + , empty + , singleton + , insert + , insertMany + , delete + , deleteMany + , deleteAll + , union + , unions + , maxUnion + , difference + , intersection + , filter + , partition + , split + , splitOccur + , map + , mapMonotonic + , mapMaybe + , mapEither + , concatMap + , unionsMap + , bind + , join + , fold + , foldOccur + , findMin + , findMax + , deleteMin + , deleteMax + , deleteMinAll + , deleteMaxAll + , deleteFindMin + , deleteFindMax + , maxView + , minView + , elems + , distinctElems + , toList + , toAscList + , toOccurList + , toAscOccurList + , fromList + , fromAscList + , fromDistinctAscList + , fromOccurList + , fromAscOccurList + , fromDistinctAscOccurList + , toMap + , fromMap + , fromOccurMap + , toSet + , fromSet + ) where + +import Data.IntMultiSet diff --git a/src/Numeric/Approximate.hs b/src/Numeric/Approximate.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Approximate.hs @@ -0,0 +1,12 @@ +module Numeric.Approximate + ( -- * Approximate + Approximate(..) + , HasApproximate(..) + , exact + , zero + , one + , withMin + , withMax + ) where + +import Data.Approximate.Type diff --git a/src/Numeric/Complex.hs b/src/Numeric/Complex.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Complex.hs @@ -0,0 +1,22 @@ +module Numeric.Complex + ( -- * Complex + Complex + , realPart + , imagPart + , mkPolar + , cis + , polar + , magnitude + , phase + , conjugate + -- ** Optics + , _realPart + , _imagPart + , _polar + , _magnitude + , _phase + , _conjugate + ) where + +import Data.Complex +import Data.Complex.Lens diff --git a/src/Numeric/Double.hs b/src/Numeric/Double.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Double.hs @@ -0,0 +1,12 @@ +module Numeric.Double + ( -- * Double + Double + , toExponential + , toFixed + , toPrecision + , toShortest + ) where + +import Data.Double.Conversion.Text (toExponential, toFixed, toPrecision, + toShortest) +import GHC.Float diff --git a/src/Numeric/Erf.hs b/src/Numeric/Erf.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Erf.hs @@ -0,0 +1,5 @@ +module Numeric.Erf + ( Erf(..) + ) where + +import Data.Number.Erf diff --git a/src/Numeric/Fast.hs b/src/Numeric/Fast.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Fast.hs @@ -0,0 +1,6 @@ +module Numeric.Fast + ( Fast(..) + , blog + ) where + +import Data.Approximate.Numerics diff --git a/src/Numeric/Float.hs b/src/Numeric/Float.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Float.hs @@ -0,0 +1,5 @@ +module Numeric.Float + ( Float + ) where + +import GHC.Float diff --git a/src/Numeric/Floating.hs b/src/Numeric/Floating.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Floating.hs @@ -0,0 +1,5 @@ +module Numeric.Floating + ( Floating(..) + ) where + +import GHC.Float diff --git a/src/Numeric/Fractional.hs b/src/Numeric/Fractional.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Fractional.hs @@ -0,0 +1,5 @@ +module Numeric.Fractional + ( Fractional(..) + ) where + +import GHC.Real diff --git a/src/Numeric/Half.hs b/src/Numeric/Half.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Half.hs @@ -0,0 +1,21 @@ +{-# LANGUAGE PackageImports, PatternSynonyms #-} + +module Numeric.Half + ( Half(..) + , isZero + , fromHalf + , toHalf + , pattern POS_INF + , pattern NEG_INF + , pattern QNaN + , pattern SNaN + , pattern HALF_MIN + , pattern HALF_NRM_MIN + , pattern HALF_MAX + , pattern HALF_EPSILON + , pattern HALF_DIG + , pattern HALF_MIN_10_EXP + , pattern HALF_MAX_10_EXP + ) where + +import "half" Numeric.Half diff --git a/src/Numeric/Int.hs b/src/Numeric/Int.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Int.hs @@ -0,0 +1,11 @@ +module Numeric.Int + ( Int + , intLog2 + , Int8 + , Int16 + , Int32 + , Int64 + ) where + +import GHC.Int (Int, Int16, Int32, Int64, Int8) +import Math.NumberTheory.Logarithms (intLog2) diff --git a/src/Numeric/Integer.hs b/src/Numeric/Integer.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Integer.hs @@ -0,0 +1,10 @@ +module Numeric.Integer + ( -- * Integer + Integer + , integerLogBase + , integerLog2 + , integerLog10 + ) where + +import GHC.Num +import Math.NumberTheory.Logarithms (integerLog10, integerLog2, integerLogBase) diff --git a/src/Numeric/Integral.hs b/src/Numeric/Integral.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Integral.hs @@ -0,0 +1,17 @@ +module Numeric.Integral + ( -- * Integral + Integral(..) + , even + , odd + , gcd + , lcm + , fromIntegral + -- ** Show + , showInt + , showIntAtBase + , showOct + , showHex + ) where + +import GHC.Real +import Numeric (showHex, showInt, showIntAtBase, showOct) diff --git a/src/Numeric/InvErf.hs b/src/Numeric/InvErf.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/InvErf.hs @@ -0,0 +1,5 @@ +module Numeric.InvErf + ( InvErf(..) + ) where + +import Data.Number.Erf diff --git a/src/Numeric/Nat.hs b/src/Numeric/Nat.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Nat.hs @@ -0,0 +1,120 @@ +{-# LANGUAGE CPP, ExplicitNamespaces #-} +#if __GLASGOW_HASKELL__ >= 806 +{-# LANGUAGE NoStarIsType #-} +#endif + +module Numeric.Nat + ( -- * Nat + Nat + , KnownNat + , natVal + , natVal' + , SomeNat(..) + , someNatVal + , sameNat + , type (<=) + , type (<=?) + , type (+) + , type (*) + , type (^) + , type (-) + , Min + , Max + , Lcm + , Gcd + , Divides +#if MIN_VERSION_base(4,11,0) + , Div + , Mod + , Log2 +#endif + , CmpNat + -- ** Constraints + , plusNat + , timesNat + , powNat + , minNat + , maxNat + , gcdNat + , lcmNat + , divNat + , modNat + , plusZero + , timesZero + , timesOne + , powZero + , powOne + , maxZero + , minZero + , gcdZero + , gcdOne + , lcmZero + , lcmOne + , plusAssociates + , timesAssociates + , minAssociates + , maxAssociates + , gcdAssociates + , lcmAssociates + , plusCommutes + , timesCommutes + , minCommutes + , maxCommutes + , gcdCommutes + , lcmCommutes + , plusDistributesOverTimes + , timesDistributesOverPow + , timesDistributesOverGcd + , timesDistributesOverLcm + , minDistributesOverPlus + , minDistributesOverTimes + , minDistributesOverPow1 + , minDistributesOverPow2 + , minDistributesOverMax + , maxDistributesOverPlus + , maxDistributesOverTimes + , maxDistributesOverPow1 + , maxDistributesOverPow2 + , maxDistributesOverMin + , gcdDistributesOverLcm + , lcmDistributesOverGcd + , minIsIdempotent + , maxIsIdempotent + , lcmIsIdempotent + , gcdIsIdempotent + , plusIsCancellative + , timesIsCancellative + , dividesPlus + , dividesTimes + , dividesMin + , dividesMax + , dividesPow + , dividesGcd + , dividesLcm + , plusMonotone1 + , plusMonotone2 + , timesMonotone1 + , timesMonotone2 + , powMonotone1 + , powMonotone2 + , minMonotone1 + , minMonotone2 + , maxMonotone1 + , maxMonotone2 + , divMonotone1 + , divMonotone2 + , euclideanNat + , plusMod + , timesMod + , modBound + , dividesDef + , timesDiv + , eqLe + , leEq + , leId + , leTrans + , zeroLe + ) where + +import Data.Constraint.Nat +import GHC.TypeLits diff --git a/src/Numeric/Natural.hs b/src/Numeric/Natural.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Natural.hs @@ -0,0 +1,11 @@ +{-# LANGUAGE PackageImports #-} + +module Numeric.Natural + ( Natural + , naturalLogBase + , naturalLog2 + , naturalLog10 + ) where + +import Math.NumberTheory.Logarithms (naturalLog10, naturalLog2, naturalLogBase) +import "base" Numeric.Natural diff --git a/src/Numeric/Num.hs b/src/Numeric/Num.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Num.hs @@ -0,0 +1,12 @@ +module Numeric.Num + ( Num(..) + , subtract + -- ** Read + , readInt + , readDec + , readOct + , readHex + ) where + +import GHC.Num (Num(..), subtract) +import Numeric diff --git a/src/Numeric/Product.hs b/src/Numeric/Product.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Product.hs @@ -0,0 +1,5 @@ +module Numeric.Product + ( Product(..) + ) where + +import Data.Monoid diff --git a/src/Numeric/Ratio.hs b/src/Numeric/Ratio.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Ratio.hs @@ -0,0 +1,12 @@ +module Numeric.Ratio + ( Ratio + , Rational + , (%) + , numerator + , denominator + , approxRational + , fromRat + ) where + +import Data.Ratio +import GHC.Float (fromRat) diff --git a/src/Numeric/Real.hs b/src/Numeric/Real.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Real.hs @@ -0,0 +1,16 @@ +module Numeric.Real + ( -- * Real + Real(..) + , div' + , mod' + , divMod' + , realToFrac + -- ** Show + , showSigned + -- ** Read + , readSigned + ) where + +import Data.Fixed (div', divMod', mod') +import GHC.Real (Real(..), realToFrac, showSigned) +import Numeric (readSigned) diff --git a/src/Numeric/RealFloat.hs b/src/Numeric/RealFloat.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/RealFloat.hs @@ -0,0 +1,20 @@ +{-# LANGUAGE CPP #-} + +module Numeric.RealFloat + ( -- * RealFloat + RealFloat(..) + , floatToDigits + -- ** Show + , showEFloat + , showFFloat + , showGFloat + , showFFloatAlt + , showGFloatAlt + , showFloat +#if MIN_VERSION_base(4,11,0) + , showHFloat +#endif + ) where + +import GHC.Float +import Numeric diff --git a/src/Numeric/RealFrac.hs b/src/Numeric/RealFrac.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/RealFrac.hs @@ -0,0 +1,9 @@ +module Numeric.RealFrac + ( -- * RealFrac + RealFrac(..) + -- ** Read + , readFloat + ) where + +import GHC.Real (RealFrac(..)) +import Numeric (readFloat) diff --git a/src/Numeric/Scientific.hs b/src/Numeric/Scientific.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Scientific.hs @@ -0,0 +1,5 @@ +module Numeric.Scientific + ( module Data.Scientific + ) where + +import Data.Scientific diff --git a/src/Numeric/Sum.hs b/src/Numeric/Sum.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Sum.hs @@ -0,0 +1,5 @@ +module Numeric.Sum + ( Sum(..) + ) where + +import Data.Monoid diff --git a/src/Numeric/Word.hs b/src/Numeric/Word.hs new file mode 100644 --- /dev/null +++ b/src/Numeric/Word.hs @@ -0,0 +1,16 @@ +module Numeric.Word + ( -- * Word + Word + , wordLog2 + , Word8 + , Word16 + , byteSwap16 + , Word32 + , byteSwap32 + , Word64 + , byteSwap64 + ) where + +import GHC.Word (Word, Word16, Word32, Word64, Word8, byteSwap16, byteSwap32, + byteSwap64) +import Math.NumberTheory.Logarithms (wordLog2) diff --git a/src/Optic/Fold.hs b/src/Optic/Fold.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Fold.hs @@ -0,0 +1,65 @@ +module Optic.Fold + ( -- * Fold + Fold + , (^..) + , (^?) + , pre + , preview + , previews + , preuse + , preuses + , has + , hasn't + , folding + , folded + , folded64 + , unfolded + , iterated + , filtered + , backwards + , repeated + , replicated + , cycled + , takingWhile + , droppingWhile + , foldMapOf + , foldMapByOf + , foldOf + , foldByOf + , foldrOf + , foldrOf' + , foldrMOf + , foldlOf' + , foldlMOf + , toListOf + , toNonEmptyOf + , anyOf + , allOf + , noneOf + , andOf + , orOf + , productOf + , sumOf + , traverseOf_ + , forOf_ + , sequenceAOf_ + , asumOf + , msumOf + , concatMapOf + , elemOf + , notElemOf + , lengthOf + , nullOf + , notNullOf + , firstOf + , lastOf + , maximumOf + , minimumOf + , maximumByOf + , minimumByOf + , findOf + , findMOf + , lookupOf + ) where + +import Control.Lens.Fold diff --git a/src/Optic/Getter.hs b/src/Optic/Getter.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Getter.hs @@ -0,0 +1,7 @@ +module Optic.Getter + ( -- * Getter + Getter + , to + ) where + +import Control.Lens.Getter diff --git a/src/Optic/Getting.hs b/src/Optic/Getting.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Getting.hs @@ -0,0 +1,11 @@ +module Optic.Getting + ( -- * Getting + Getting + , (^.) + , view + , views + , use + , uses + ) where + +import Control.Lens.Getter diff --git a/src/Optic/Iso.hs b/src/Optic/Iso.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Iso.hs @@ -0,0 +1,14 @@ +module Optic.Iso + ( -- * Iso + Iso + , Iso' + , iso + , from + , under + , enum + , curried + , uncurried + , flipped + ) where + +import Control.Lens.Iso diff --git a/src/Optic/Iso/Reversing.hs b/src/Optic/Iso/Reversing.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Iso/Reversing.hs @@ -0,0 +1,7 @@ +module Optic.Iso.Reversing + ( -- * Reversing + Reversing(..) + , reversed + ) where + +import Control.Lens.Iso (Reversing(reversing), reversed) diff --git a/src/Optic/Iso/Strict.hs b/src/Optic/Iso/Strict.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Iso/Strict.hs @@ -0,0 +1,7 @@ +module Optic.Iso.Strict + ( -- * Strict + Strict(..) + , lazy + ) where + +import Control.Lens.Iso (Strict(strict), lazy) diff --git a/src/Optic/Lens.hs b/src/Optic/Lens.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Lens.hs @@ -0,0 +1,8 @@ +module Optic.Lens + ( -- * Lens + Lens + , Lens' + , lens + ) where + +import Control.Lens.Lens (Lens, Lens', lens) diff --git a/src/Optic/Lens/At.hs b/src/Optic/Lens/At.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Lens/At.hs @@ -0,0 +1,10 @@ +module Optic.Lens.At + ( -- * At + At(..) + , sans + -- ** Re-exports + , module Optic.Traversal.Ixed + ) where + +import Control.Lens.At (At(at), sans) +import Optic.Traversal.Ixed diff --git a/src/Optic/Lens/Contains.hs b/src/Optic/Lens/Contains.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Lens/Contains.hs @@ -0,0 +1,7 @@ +module Optic.Lens.Contains + ( -- * Contains + Contains(..) + , Index + ) where + +import Control.Lens.At (Contains(contains), Index) diff --git a/src/Optic/Prism.hs b/src/Optic/Prism.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Prism.hs @@ -0,0 +1,12 @@ +module Optic.Prism + ( -- * Prism + Prism + , Prism' + , prism + , prism' + , is + , only + ) where + +import Control.Lens.Extras (is) +import Control.Lens.Prism (Prism, Prism', only, prism, prism') diff --git a/src/Optic/Prism/Cons.hs b/src/Optic/Prism/Cons.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Prism/Cons.hs @@ -0,0 +1,15 @@ +{-# LANGUAGE PatternSynonyms #-} + +module Optic.Prism.Cons + ( -- * Cons + Cons(..) + , (<|) + , cons + , uncons + , _head + , _tail + , pattern (:<) + ) where + +import Control.Lens.Cons (pattern (:<), Cons(_Cons), cons, uncons, (<|), _head, + _tail) diff --git a/src/Optic/Prism/Empty.hs b/src/Optic/Prism/Empty.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Prism/Empty.hs @@ -0,0 +1,9 @@ +{-# LANGUAGE PatternSynonyms #-} + +module Optic.Prism.Empty + ( -- * Empty + AsEmpty(..) + , pattern Empty + ) where + +import Control.Lens.Empty (AsEmpty(_Empty), pattern Empty) diff --git a/src/Optic/Prism/Snoc.hs b/src/Optic/Prism/Snoc.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Prism/Snoc.hs @@ -0,0 +1,15 @@ +{-# LANGUAGE PatternSynonyms #-} + +module Optic.Prism.Snoc + ( -- * Snoc + Snoc(..) + , (|>) + , snoc + , unsnoc + , _init + , _last + , pattern (:>) + ) where + +import Control.Lens.Cons (pattern (:>), Snoc(_Snoc), snoc, unsnoc, _init, _last, + (|>)) diff --git a/src/Optic/Review.hs b/src/Optic/Review.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Review.hs @@ -0,0 +1,7 @@ +module Optic.Review + ( -- * Review + Review + , review + ) where + +import Control.Lens.Review (Review, review) diff --git a/src/Optic/Setter.hs b/src/Optic/Setter.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Setter.hs @@ -0,0 +1,21 @@ +module Optic.Setter + ( -- * Setter + Setter + , Setter' + , (.~) + , (%~) + , (+~) + , (-~) + , (*~) + , (//~) + , (^~) + , (^^~) + , (**~) + , (||~) + , (&&~) + , set + , over + ) where + +import Control.Lens.Setter (Setter, Setter', over, set, (%~), (&&~), (**~), + (*~), (+~), (-~), (.~), (//~), (^^~), (^~), (||~)) diff --git a/src/Optic/Traversal.hs b/src/Optic/Traversal.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Traversal.hs @@ -0,0 +1,11 @@ +module Optic.Traversal + ( -- * Traversal + Traversal + , Traversal' + , traverseOf + , forOf + , sequenceAOf + ) where + +import Control.Lens.Traversal (Traversal, Traversal', forOf, sequenceAOf, + traverseOf) diff --git a/src/Optic/Traversal/Each.hs b/src/Optic/Traversal/Each.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Traversal/Each.hs @@ -0,0 +1,6 @@ +module Optic.Traversal.Each + ( -- * Each + Each(..) + ) where + +import Control.Lens.Each (Each(each)) diff --git a/src/Optic/Traversal/Ixed.hs b/src/Optic/Traversal/Ixed.hs new file mode 100644 --- /dev/null +++ b/src/Optic/Traversal/Ixed.hs @@ -0,0 +1,8 @@ +module Optic.Traversal.Ixed + ( -- * Ixed + Ixed(..) + , Index + , IxValue + ) where + +import Control.Lens.At (Index, IxValue, Ixed(ix)) diff --git a/src/Ord.hs b/src/Ord.hs new file mode 100644 --- /dev/null +++ b/src/Ord.hs @@ -0,0 +1,24 @@ +module Ord + ( Ord(..) + , Ordering(..) + , Comparison(..) + , defaultComparison + , comparing + , Down(..) + , Min(..) + , Max(..) + , Arg(..) + , ArgMin + , ArgMax + , Ord1(..) + , compare1 + , liftCompareDefault + , Ord2(..) + , compare2 + ) where + +import Data.Functor.Classes +import Data.Functor.Classes.Generic +import Data.Functor.Contravariant +import Data.Ord +import Data.Semigroup diff --git a/src/Parallelism.hs b/src/Parallelism.hs new file mode 100644 --- /dev/null +++ b/src/Parallelism.hs @@ -0,0 +1,26 @@ +module Parallelism + ( par + , pseq + , rpar + , rparWith + , parTraversable + , parList + , parListChunk + , parMap + , parTuple2 + , parTuple3 + , parTuple4 + , parTuple5 + , parTuple6 + , parTuple7 + , parTuple8 + , parTuple9 + -- * Re-exports + , module Eval + ) where + +import Control.Parallel.Strategies +import GHC.Conc + +-- Re-exports +import Eval diff --git a/src/Parser/Binary.hs b/src/Parser/Binary.hs new file mode 100644 --- /dev/null +++ b/src/Parser/Binary.hs @@ -0,0 +1,7 @@ +module Parser.Binary + ( module Text.Megaparsec + , module Text.Megaparsec.Byte + ) where + +import Text.Megaparsec +import Text.Megaparsec.Byte diff --git a/src/Parser/Cli.hs b/src/Parser/Cli.hs new file mode 100644 --- /dev/null +++ b/src/Parser/Cli.hs @@ -0,0 +1,5 @@ +module Parser.Cli + ( module Options.Applicative + ) where + +import Options.Applicative diff --git a/src/Parser/Earley.hs b/src/Parser/Earley.hs new file mode 100644 --- /dev/null +++ b/src/Parser/Earley.hs @@ -0,0 +1,7 @@ +module Parser.Earley + ( module Text.Earley + , module Text.Earley.Mixfix + ) where + +import Text.Earley +import Text.Earley.Mixfix diff --git a/src/Parser/Env.hs b/src/Parser/Env.hs new file mode 100644 --- /dev/null +++ b/src/Parser/Env.hs @@ -0,0 +1,5 @@ +module Parser.Env + ( module Env + ) where + +import Env diff --git a/src/Parser/Text.hs b/src/Parser/Text.hs new file mode 100644 --- /dev/null +++ b/src/Parser/Text.hs @@ -0,0 +1,7 @@ +module Parser.Text + ( module Text.Megaparsec + , module Text.Megaparsec.Char + ) where + +import Text.Megaparsec +import Text.Megaparsec.Char diff --git a/src/Pointed.hs b/src/Pointed.hs new file mode 100644 --- /dev/null +++ b/src/Pointed.hs @@ -0,0 +1,6 @@ +module Pointed + ( -- * Pointed + Pointed(..) + ) where + +import Data.Pointed (Pointed(point)) diff --git a/src/Posix.hs b/src/Posix.hs new file mode 100644 --- /dev/null +++ b/src/Posix.hs @@ -0,0 +1,5 @@ +module Posix + ( module System.Posix.Types + ) where + +import System.Posix.Types diff --git a/src/Predicate.hs b/src/Predicate.hs new file mode 100644 --- /dev/null +++ b/src/Predicate.hs @@ -0,0 +1,5 @@ +module Predicate + ( Predicate(..) + ) where + +import Data.Functor.Contravariant diff --git a/src/Pretty.hs b/src/Pretty.hs new file mode 100644 --- /dev/null +++ b/src/Pretty.hs @@ -0,0 +1,7 @@ +module Pretty + ( module Data.Text.Prettyprint.Doc + , module Data.Text.Prettyprint.Doc.Render.Terminal + ) where + +import Data.Text.Prettyprint.Doc +import Data.Text.Prettyprint.Doc.Render.Terminal diff --git a/src/Prim.hs b/src/Prim.hs new file mode 100644 --- /dev/null +++ b/src/Prim.hs @@ -0,0 +1,22 @@ +module Prim + ( -- * Re-exports + module Control.Monad.Primitive + , module Data.Primitive.Addr + , module Data.Primitive.Array + , module Data.Primitive.ByteArray + , module Data.Primitive.MachDeps + , module Data.Primitive.MutVar + , module Data.Primitive.SmallArray + , module Data.Primitive.Types + , module Data.Primitive.UnliftedArray + ) where + +import Control.Monad.Primitive +import Data.Primitive.Addr +import Data.Primitive.Array +import Data.Primitive.ByteArray +import Data.Primitive.MachDeps +import Data.Primitive.MutVar +import Data.Primitive.SmallArray +import Data.Primitive.Types +import Data.Primitive.UnliftedArray diff --git a/src/Printf.hs b/src/Printf.hs new file mode 100644 --- /dev/null +++ b/src/Printf.hs @@ -0,0 +1,5 @@ +module Printf + ( module Text.Printf + ) where + +import Text.Printf diff --git a/src/Process.hs b/src/Process.hs new file mode 100644 --- /dev/null +++ b/src/Process.hs @@ -0,0 +1,35 @@ +module Process + ( -- * Spawning processes + -- ** High-level Haskell API + module System.Process.Typed + -- ** Low-level POSIX API + , forkProcess + , forkProcessWithUnmask + -- ** Waiting + , getProcessStatus + , getAnyProcessStatus + , getGroupProcessStatus + -- * Exiting the current process + , exitImmediately + -- * Replacing the current process + , executeFile + -- * Process info + , getProcessID + , getParentProcessID + -- ** Process groups + , getProcessGroupID + , getProcessGroupIDOf + , createProcessGroupFor + , joinProcessGroup + , setProcessGroupIDOf + , createSession + ) where + +import System.Posix.Process (createProcessGroupFor, createSession, executeFile, + exitImmediately, forkProcess, + forkProcessWithUnmask, getAnyProcessStatus, + getGroupProcessStatus, getParentProcessID, + getProcessGroupID, getProcessGroupIDOf, + getProcessID, getProcessStatus, joinProcessGroup, + setProcessGroupIDOf) +import System.Process.Typed diff --git a/src/Profunctor.hs b/src/Profunctor.hs new file mode 100644 --- /dev/null +++ b/src/Profunctor.hs @@ -0,0 +1,5 @@ +module Profunctor + ( Profunctor(..) + ) where + +import Data.Profunctor diff --git a/src/Proxy.hs b/src/Proxy.hs new file mode 100644 --- /dev/null +++ b/src/Proxy.hs @@ -0,0 +1,7 @@ +module Proxy + ( Proxy(..) + , asProxyTypeOf + , KProxy(..) + ) where + +import Data.Proxy diff --git a/src/Ptr.hs b/src/Ptr.hs new file mode 100644 --- /dev/null +++ b/src/Ptr.hs @@ -0,0 +1,70 @@ +module Ptr + ( Ptr + , nullPtr + , castPtr + , plusPtr + , alignPtr + , minusPtr + , alloca + , allocaBytes + , allocaBytesAligned + , malloc + , mallocBytes + , calloc + , callocBytes + , realloc + , reallocBytes + , copyBytes + , moveBytes + , fillBytes + , free + , mallocArray + , mallocArray0 + , allocaArray + , allocaArray0 + , reallocArray + , reallocArray0 + , callocArray + , callocArray0 + , peekArray + , peekArray0 + , pokeArray + , pokeArray0 + , newArray + , newArray0 + , withArray + , withArray0 + , withArrayLen + , withArrayLen0 + , copyArray + , moveArray + , lengthArray0 + , advancePtr + , Pool + , newPool + , freePool + , withPool + , pooledMalloc + , pooledMallocBytes + , pooledRealloc + , pooledReallocBytes + , pooledMallocArray + , pooledMallocArray0 + , pooledReallocArray + , pooledReallocArray0 + , pooledNew + , pooledNewArray + , pooledNewArray0 + , IntPtr(..) + , ptrToIntPtr + , intPtrToPtr + , WordPtr(..) + , ptrToWordPtr + , wordPtrToPtr + ) where + +import Foreign.Marshal.Alloc +import Foreign.Marshal.Array +import Foreign.Marshal.Pool +import Foreign.Marshal.Utils +import Foreign.Ptr diff --git a/src/Ptr/Foreign.hs b/src/Ptr/Foreign.hs new file mode 100644 --- /dev/null +++ b/src/Ptr/Foreign.hs @@ -0,0 +1,21 @@ +module Ptr.Foreign + ( ForeignPtr + , newForeignPtr + , newForeignPtr_ + , addForeignPtrFinalizer + , newForeignPtrEnv + , addForeignPtrFinalizerEnv + , withForeignPtr + , finalizeForeignPtr + , touchForeignPtr + , castForeignPtr + , plusForeignPtr + , mallocForeignPtr + , mallocForeignPtrBytes + , mallocForeignPtrArray + , mallocForeignPtrArray0 + , unsafeForeignPtrToPtr + ) where + +import Foreign.ForeignPtr +import Foreign.ForeignPtr.Unsafe diff --git a/src/Ptr/Fun.hs b/src/Ptr/Fun.hs new file mode 100644 --- /dev/null +++ b/src/Ptr/Fun.hs @@ -0,0 +1,15 @@ +module Ptr.Fun + ( FunPtr + , nullFunPtr + , castFunPtr + , castFunPtrToPtr + , castPtrToFunPtr + , freeHaskellFunPtr + , FinalizerPtr + , FinalizerEnvPtr + , finalizerFree + ) where + +import Foreign.ForeignPtr +import Foreign.Marshal.Alloc +import Foreign.Ptr diff --git a/src/Ptr/Stable.hs b/src/Ptr/Stable.hs new file mode 100644 --- /dev/null +++ b/src/Ptr/Stable.hs @@ -0,0 +1,10 @@ +module Ptr.Stable + ( StablePtr + , newStablePtr + , deRefStablePtr + , freeStablePtr + , castStablePtrToPtr + , castPtrToStablePtr + ) where + +import Foreign.StablePtr diff --git a/src/Ptr/Static.hs b/src/Ptr/Static.hs new file mode 100644 --- /dev/null +++ b/src/Ptr/Static.hs @@ -0,0 +1,13 @@ +module Ptr.Static + ( StaticPtr + , deRefStaticPtr + , StaticKey + , staticKey + , unsafeLookupStaticPtr + , StaticPtrInfo(..) + , staticPtrInfo + , staticPtrKeys + , IsStatic(..) + ) where + +import GHC.StaticPtr diff --git a/src/Ptr/Weak.hs b/src/Ptr/Weak.hs new file mode 100644 --- /dev/null +++ b/src/Ptr/Weak.hs @@ -0,0 +1,11 @@ +module Ptr.Weak + ( Weak + , mkWeak + , deRefWeak + , finalize + , mkWeakPtr + , addFinalizer + , mkWeakPair + ) where + +import System.Mem.Weak diff --git a/src/Queue/Prio/Hash.hs b/src/Queue/Prio/Hash.hs new file mode 100644 --- /dev/null +++ b/src/Queue/Prio/Hash.hs @@ -0,0 +1,34 @@ +module Queue.Prio.Hash + ( -- * HashPSQ + HashPSQ + -- * Construction + , empty + , singleton + , fromList + -- * Querying + , null + , size + , member + , lookup + , findMin + , minView + , atMostView + -- * Insertion + , insert + , insertView + -- * Deletion + , delete + , deleteView + -- * Alteration + , alter + , alterMin + -- * Mapping + , map + , unsafeMapMonotonic + -- * Folding + , toList + , keys + , fold' + ) where + +import Data.HashPSQ diff --git a/src/Queue/Prio/Int.hs b/src/Queue/Prio/Int.hs new file mode 100644 --- /dev/null +++ b/src/Queue/Prio/Int.hs @@ -0,0 +1,34 @@ +module Queue.Prio.Int + ( -- * IntPSQ + IntPSQ + -- * Construction + , empty + , singleton + , fromList + -- * Querying + , null + , size + , member + , lookup + , findMin + , minView + , atMostView + -- * Insertion + , insert + , insertView + -- * Deletion + , delete + , deleteView + -- * Alteration + , alter + , alterMin + -- * Mapping + , map + , unsafeMapMonotonic + -- * Folding + , toList + , keys + , fold' + ) where + +import Data.IntPSQ diff --git a/src/Queue/Prio/Ord.hs b/src/Queue/Prio/Ord.hs new file mode 100644 --- /dev/null +++ b/src/Queue/Prio/Ord.hs @@ -0,0 +1,35 @@ +module Queue.Prio.Ord + ( -- * OrdPSQ + OrdPSQ + -- * Construction + , empty + , singleton + , fromList + -- * Querying + , null + , size + , member + , lookup + , findMin + , minView + , atMostView + -- * Insertion + , insert + , insertView + -- * Deletion + , delete + , deleteView + -- * Alteration + , alter + , alterMin + -- * Mapping + , map + , unsafeMapMonotonic + -- * Folding + , toList + , toAscList + , keys + , fold' + ) where + +import Data.OrdPSQ diff --git a/src/Random.hs b/src/Random.hs new file mode 100644 --- /dev/null +++ b/src/Random.hs @@ -0,0 +1,9 @@ +module Random + ( module System.Random.MWC + , module System.Random.MWC.CondensedTable + , module System.Random.MWC.Distributions + ) where + +import System.Random.MWC +import System.Random.MWC.CondensedTable +import System.Random.MWC.Distributions diff --git a/src/Read.hs b/src/Read.hs new file mode 100644 --- /dev/null +++ b/src/Read.hs @@ -0,0 +1,28 @@ +module Read + ( Read(..) + , ReadS + , reads + , readMaybe + , readEither + , readParen + , readsData + , readData + , readsUnaryWith + , readUnaryWith + , readsBinaryWith + , readBinaryWith + , Read1(..) + , readsPrec1 + , readPrec1 + , liftReadListDefault + , liftReadListPrecDefault + , Read2(..) + , readsPrec2 + , readPrec2 + , liftReadList2Default + , liftReadListPrec2Default + ) where + +import Data.Functor.Classes +import GHC.Read +import Text.Read diff --git a/src/Read/Partial.hs b/src/Read/Partial.hs new file mode 100644 --- /dev/null +++ b/src/Read/Partial.hs @@ -0,0 +1,5 @@ +module Read.Partial + ( read + ) where + +import Text.Read (read) diff --git a/src/Reader.hs b/src/Reader.hs new file mode 100644 --- /dev/null +++ b/src/Reader.hs @@ -0,0 +1,20 @@ +module Reader + ( -- * Reader + Reader + , runReader + , mapReader + , withReader + -- * ReaderT + , ReaderT(..) + , mapReaderT + , withReaderT + -- * MonadReader + , MonadReader(..) + -- * Magnify + , Magnify + , magnify + ) where + +import Control.Lens.Zoom (Magnify(magnify)) +import Control.Monad.Reader.Class +import Control.Monad.Trans.Reader diff --git a/src/Reflection.hs b/src/Reflection.hs new file mode 100644 --- /dev/null +++ b/src/Reflection.hs @@ -0,0 +1,9 @@ +module Reflection + ( Reifies(..) + , reify + , reifyNat + , reifySymbol + , reifyTypeable + ) where + +import Data.Reflection diff --git a/src/Regex.hs b/src/Regex.hs new file mode 100644 --- /dev/null +++ b/src/Regex.hs @@ -0,0 +1,36 @@ +module Regex + ( -- * Regex + RE + , Greediness(..) + -- * Building regular expressions + -- ** Generic combinators + , sym + , psym + , msym + , anySym + , few + , reFoldl + , withMatched + -- ** Strings + , string + -- ** Digits + , digit + , hexDigit + -- ** Numbers + , signed + , decimal + , hexadecimal + -- * Running regular expressions + , match + , (=~) + , replace + , findFirstPrefix + , findLongestPrefix + , findShortestPrefix + , findFirstInfix + , findLongestInfix + , findShortestInfix + ) where + +import Text.Regex.Applicative +import Text.Regex.Applicative.Common diff --git a/src/RuntimeSystem.hs b/src/RuntimeSystem.hs new file mode 100644 --- /dev/null +++ b/src/RuntimeSystem.hs @@ -0,0 +1,59 @@ +module RuntimeSystem + ( -- * Garbage collection + performGC + , performMajorGC + , performMinorGC + -- * Allocation counter and limits + , setAllocationCounter + , getAllocationCounter + , enableAllocationLimit + , disableAllocationLimit + -- * Capabilities + , getNumCapabilities + , setNumCapabilities + -- * Spark pool + , numSparks + , runSparks + -- * Processors + , getNumProcessors + -- * Uncaught exception handler + , getUncaughtExceptionHandler + , setUncaughtExceptionHandler + -- * Event manager + , EventManager + , getSystemEventManager + , new + , Event + , evtRead + , evtWrite + , IOCallback + , FdKey + , Lifetime + , registerFd + , unregisterFd + , unregisterFd_ + , closeFd + -- * Timer manager + , TimerManager + , TimeoutCallback + , TimeoutKey + , registerTimeout + , updateTimeout + , unregisterTimeout + -- * Runtime stats + , RTSStats(..) + , GCDetails(..) + , RtsTime + , getRTSStats + , getRTSStatsEnabled + -- * Memory barriers + , storeLoadBarrier + , loadLoadBarrier + , writeBarrier + ) where + +import Data.Atomics +import GHC.Conc +import GHC.Event +import GHC.Stats +import System.Mem diff --git a/src/ST.hs b/src/ST.hs new file mode 100644 --- /dev/null +++ b/src/ST.hs @@ -0,0 +1,28 @@ +module ST + ( -- * ST + ST + , runST + , fixST + , RealWorld + , stToIO + -- * STE + , STE + , runSTE + , fixSTE + , throwSTE + , handleSTE + , unsafeInterleaveSTE + , unsafeIOToSTE + , unsafeSTEToIO + -- * STRef + , STRef + , newSTRef + , readSTRef + , writeSTRef + , modifySTRef + , modifySTRef' + ) where + +import Control.Monad.ST +import Control.Monad.STE.Internal +import Data.STRef diff --git a/src/Semigroup.hs b/src/Semigroup.hs new file mode 100644 --- /dev/null +++ b/src/Semigroup.hs @@ -0,0 +1,14 @@ +module Semigroup + ( -- * Semigroup + Semigroup(..) + , gmappend + -- * Newtypes + , First(..) + , Last(..) + , Dual(..) + , diff + , cycle1 + ) where + +import Data.Semigroup +import Data.Semigroup.Generic diff --git a/src/Semigroupoid.hs b/src/Semigroupoid.hs new file mode 100644 --- /dev/null +++ b/src/Semigroupoid.hs @@ -0,0 +1,10 @@ +module Semigroupoid + ( -- * Semigroupoid + Semigroupoid(..) + -- ** Newtypes + , Semi(..) + , Dual(..) + ) where + +import Data.Semigroupoid (Semi(Semi, getSemi), Semigroupoid(o)) +import Data.Semigroupoid.Dual (Dual(Dual, getDual)) diff --git a/src/Semilattice.hs b/src/Semilattice.hs new file mode 100644 --- /dev/null +++ b/src/Semilattice.hs @@ -0,0 +1,9 @@ +module Semilattice + ( Join(..) + , Meet(..) + , Order(..) + ) where + +import Data.Semilattice.Join +import Data.Semilattice.Meet +import Data.Semilattice.Order diff --git a/src/Sequence.hs b/src/Sequence.hs new file mode 100644 --- /dev/null +++ b/src/Sequence.hs @@ -0,0 +1,14 @@ +module Sequence + ( -- * Sequence + module Data.Sequence + -- ** Optics + , viewL + , viewR + , sliced + , slicedTo + , slicedFrom + , seqOf + ) where + +import Data.Sequence +import Data.Sequence.Lens diff --git a/src/Serialise.hs b/src/Serialise.hs new file mode 100644 --- /dev/null +++ b/src/Serialise.hs @@ -0,0 +1,19 @@ +module Serialise + ( -- * Encoding + serialise + , serialiseIncremental + -- * Decoding + , deserialiseOrFail + , deserialiseIncremental + , DeserialiseFailure(..) + , ByteOffset + , IDecode(..) + -- * Serialise class + , Serialise(..) + ) where + +import Codec.CBOR.Read (ByteOffset) +import Codec.Serialise (DeserialiseFailure(DeserialiseFailure), + IDecode(Done, Fail, Partial), Serialise(decode, encode), + deserialiseIncremental, deserialiseOrFail, serialise, + serialiseIncremental) diff --git a/src/Set.hs b/src/Set.hs new file mode 100644 --- /dev/null +++ b/src/Set.hs @@ -0,0 +1,10 @@ +module Set + ( -- * Set + module Data.Set + -- ** Optics + , setmapped + , setOf + ) where + +import Data.Set +import Data.Set.Lens (setOf, setmapped) diff --git a/src/Set/Hash.hs b/src/Set/Hash.hs new file mode 100644 --- /dev/null +++ b/src/Set/Hash.hs @@ -0,0 +1,9 @@ +module Set.Hash + ( -- * HashSet + module Data.HashSet + -- ** Optics + , setOf + ) where + +import Data.HashSet +import Data.HashSet.Lens (setOf) diff --git a/src/Set/Int.hs b/src/Set/Int.hs new file mode 100644 --- /dev/null +++ b/src/Set/Int.hs @@ -0,0 +1,11 @@ +module Set.Int + ( -- * IntSet + module Data.IntSet + -- ** Optics + , members + , setmapped + , setOf + ) where + +import Data.IntSet +import Data.IntSet.Lens (members, setOf, setmapped) diff --git a/src/Show.hs b/src/Show.hs new file mode 100644 --- /dev/null +++ b/src/Show.hs @@ -0,0 +1,18 @@ +module Show + ( Show(..) + , ShowS + , shows + , showParen + , showListWith + , showsUnaryWith + , showsBinaryWith + , Show1(..) + , showsPrec1 + , liftShowsPrecDefault + , Show2(..) + , showsPrec2 + ) where + +import Data.Functor.Classes +import Data.Functor.Classes.Generic +import Text.Show diff --git a/src/Socket.hs b/src/Socket.hs new file mode 100644 --- /dev/null +++ b/src/Socket.hs @@ -0,0 +1,85 @@ +module Socket + ( Socket(..) + , Family(..) + , isSupportedFamily + , SocketType(..) + , isSupportedSocketType + , SockAddr(..) + , isSupportedSockAddr + , SocketStatus(..) + , HostAddress + , iNADDR_ANY + , hostAddressToTuple + , tupleToHostAddress + , HostAddress6 + , iN6ADDR_ANY + , hostAddress6ToTuple + , tupleToHostAddress6 + , FlowInfo + , ScopeID + , htonl + , ntohl + , ShutdownCmd(..) + , ProtocolNumber + , defaultProtocol + , PortNumber + , aNY_PORT + , HostName + , ServiceName + , AddrInfo(..) + , AddrInfoFlag(..) + , addrInfoFlagImplemented + , defaultHints + , getAddrInfo + , NameInfoFlag(..) + , getNameInfo + , socket + , socketPair + , connect + , bind + , listen + , accept + , getPeerName + , getSocketName + , getPeerCred + , socketPort + , socketToHandle + , send + , sendTo + , sendAll + , sendAllTo + , sendBuf + , sendBufTo + , sendFd + , sendMany + , sendManyTo + , recv + , recvFrom + , recvBuf + , recvBufFrom + , recvFd + , inet_addr + , inet_ntoa + , shutdown + , close + , isConnected + , isBound + , isListening + , isReadable + , isWritable + , SocketOption(..) + , isSupportedSocketOption + , getSocketOption + , setSocketOption + , sOMAXCONN + , sOL_SOCKET + , sCM_RIGHTS + , maxListenQueue + , withSocketsDo + , fdSocket + , mkSocket + , setNonBlockIfNeeded + ) where + +import Network.Socket hiding (recv, recvFrom, send, sendTo) +import Network.Socket.ByteString diff --git a/src/StableName.hs b/src/StableName.hs new file mode 100644 --- /dev/null +++ b/src/StableName.hs @@ -0,0 +1,8 @@ +module StableName + ( StableName + , makeStableName + , hashStableName + , eqStableName + ) where + +import System.Mem.StableName diff --git a/src/State.hs b/src/State.hs new file mode 100644 --- /dev/null +++ b/src/State.hs @@ -0,0 +1,31 @@ +module State + ( -- * State + State + , runState + , evalState + , execState + , mapState + , withState + -- * StateT + , StateT(..) + , evalStateT + , execStateT + , mapStateT + , withStateT + -- * MonadState + , MonadState(..) + , gets + , modify + , modify' + -- * Zoom + , Zoom + , zoom + , Zoomed + ) where + +import Control.Lens.Zoom (Zoom(zoom), Zoomed) +import Control.Monad.State.Class (MonadState(..), gets, modify, modify') +import Control.Monad.Trans.State.Strict (State, StateT(..), evalState, + evalStateT, execState, execStateT, + mapState, mapStateT, runState, + withState, withStateT) diff --git a/src/Storable.hs b/src/Storable.hs new file mode 100644 --- /dev/null +++ b/src/Storable.hs @@ -0,0 +1,5 @@ +module Storable + ( Storable(..) + ) where + +import Foreign.Storable diff --git a/src/Symbol.hs b/src/Symbol.hs new file mode 100644 --- /dev/null +++ b/src/Symbol.hs @@ -0,0 +1,39 @@ +{-# LANGUAGE ExplicitNamespaces #-} + +module Symbol + ( -- * Symbol + Symbol + , KnownSymbol + , symbolVal + , symbolVal' + , SomeSymbol(..) + , someSymbolVal + , sameSymbol + , AppendSymbol + , CmpSymbol + , type (++) + , Take + , Drop + , Length + , appendSymbol + , appendUnit1 + , appendUnit2 + , appendAssociates + , takeSymbol + , dropSymbol + , takeAppendDrop + , lengthSymbol + , takeLength + , take0 + , takeEmpty + , dropLength + , drop0 + , dropEmpty + , lengthTake + , lengthDrop + , dropDrop + , takeTake + ) where + +import Data.Constraint.Symbol +import GHC.TypeLits diff --git a/src/System.hs b/src/System.hs new file mode 100644 --- /dev/null +++ b/src/System.hs @@ -0,0 +1,29 @@ +{-# LANGUAGE CPP #-} + +module System + ( -- * System info +#if MIN_VERSION_base(4,11,0) + ByteOrder(..), + targetByteOrder, +#endif + os, + isWindows, + isMac, + arch, + compilerName, + compilerVersion, + -- * Network info + getNetworkInterfaces, + NetworkInterface(..), + IPv4(..), + IPv6(..), + MAC(..), + ) where + +#if MIN_VERSION_base(4,11,0) +import GHC.ByteOrder +#endif +import Network.Info (IPv4(IPv4), IPv6(IPv6), MAC(MAC), NetworkInterface(NetworkInterface, ipv4, ipv6, mac, name), + getNetworkInterfaces) +import System.Info +import System.Info.Extra diff --git a/src/Tagged.hs b/src/Tagged.hs new file mode 100644 --- /dev/null +++ b/src/Tagged.hs @@ -0,0 +1,5 @@ +module Tagged + ( module Data.Tagged + ) where + +import Data.Tagged diff --git a/src/Terminal.hs b/src/Terminal.hs new file mode 100644 --- /dev/null +++ b/src/Terminal.hs @@ -0,0 +1,5 @@ +module Terminal + ( module System.Console.ANSI + ) where + +import System.Console.ANSI diff --git a/src/Test.hs b/src/Test.hs new file mode 100644 --- /dev/null +++ b/src/Test.hs @@ -0,0 +1,5 @@ +module Test + ( module Hedgehog + ) where + +import Hedgehog diff --git a/src/Test/Gen.hs b/src/Test/Gen.hs new file mode 100644 --- /dev/null +++ b/src/Test/Gen.hs @@ -0,0 +1,5 @@ +module Test.Gen + ( module Hedgehog.Gen + ) where + +import Hedgehog.Gen diff --git a/src/Test/Range.hs b/src/Test/Range.hs new file mode 100644 --- /dev/null +++ b/src/Test/Range.hs @@ -0,0 +1,5 @@ +module Test.Range + ( module Hedgehog.Range + ) where + +import Hedgehog.Range diff --git a/src/Text.hs b/src/Text.hs new file mode 100644 --- /dev/null +++ b/src/Text.hs @@ -0,0 +1,112 @@ +{-# LANGUAGE MagicHash #-} + +module Text + ( -- * Text + Text + , Reader + , IReader + , all + , any + , append + , break + , breakOn + , breakOnAll + , breakOnEnd + , center + , chunksOf + , commonPrefixes + , compareLength + , concat + , concatMap + , cons + , copy + , decimal + , decodeUtf8' + , double + , drop + , dropAround + , dropEnd + , dropWhile + , dropWhileEnd + , empty + , encodeUtf16BE + , encodeUtf16LE + , encodeUtf32BE + , encodeUtf32LE + , encodeUtf8 + , filter + , find + , findIndex + , foldl' + , foldr + , group + , groupBy + , hexadecimal + , inits + , intercalate + , intersperse + , isInfixOf + , isPrefixOf + , isSuffixOf + , justifyLeft + , justifyRight + , length + , lines + , map + , mapAccumL + , mapAccumR + , null + , pack + , partition + , rational + , replace + , replicate + , reverse + , scanl + , scanl1 + , scanr + , scanr1 + , signed + , singleton + , snoc + , span + , split + , splitAt + , strip + , stripEnd + , stripPrefix + , stripStart + , stripSuffix + , tails + , take + , takeEnd + , takeWhile + , takeWhileEnd + , toCaseFold + , toLower + , toTitle + , toUpper + , transpose + , uncons + , unfoldr + , unfoldrN + , unlines + , unpack + , unpackCString# + , unsnoc + , unwords + , words + , zip + , zipWith + -- ** Optics + , packed + , unpacked + , text + , builder + ) where + +import Data.Text +import Data.Text.Encoding +import Data.Text.Internal.Read (IReader) +import Data.Text.Read +import Data.Text.Strict.Lens (builder, packed, text, unpacked) diff --git a/src/Text/Lazy.hs b/src/Text/Lazy.hs new file mode 100644 --- /dev/null +++ b/src/Text/Lazy.hs @@ -0,0 +1,14 @@ +module Text.Lazy + ( -- * Text + module Data.Text.Lazy + , module Data.Text.Lazy.Encoding + -- ** Optics + , packed + , unpacked + , text + , builder + ) where + +import Data.Text.Lazy +import Data.Text.Lazy.Encoding +import Data.Text.Lazy.Lens (builder, packed, text, unpacked) diff --git a/src/Text/Lazy/Builder.hs b/src/Text/Lazy/Builder.hs new file mode 100644 --- /dev/null +++ b/src/Text/Lazy/Builder.hs @@ -0,0 +1,21 @@ +module Text.Lazy.Builder + ( -- * Builder + Builder + , toLazyText + , toLazyTextWith + , singleton + , fromText + , fromLazyText + , fromString + , flush + , decimal + , hexadecimal + , FPFormat(..) + , realFloat + , formatRealFloat + ) where + +import Data.Text.Lazy.Builder +import Data.Text.Lazy.Builder.Int (decimal, hexadecimal) +import Data.Text.Lazy.Builder.RealFloat (FPFormat(..), formatRealFloat, + realFloat) diff --git a/src/Text/Partial.hs b/src/Text/Partial.hs new file mode 100644 --- /dev/null +++ b/src/Text/Partial.hs @@ -0,0 +1,22 @@ +module Text.Partial + ( count + , decodeLatin1 + , decodeUtf16BE + , decodeUtf16LE + , decodeUtf32BE + , decodeUtf32LE + , decodeUtf8 + , foldl1' + , foldr1 + , head + , index + , init + , last + , maximum + , minimum + , splitOn + , tail + ) where + +import Data.Text +import Data.Text.Encoding diff --git a/src/Text/Short.hs b/src/Text/Short.hs new file mode 100644 --- /dev/null +++ b/src/Text/Short.hs @@ -0,0 +1,5 @@ +module Text.Short + ( module Data.Text.Short + ) where + +import Data.Text.Short diff --git a/src/Text/Short/Partial.hs b/src/Text/Short/Partial.hs new file mode 100644 --- /dev/null +++ b/src/Text/Short/Partial.hs @@ -0,0 +1,5 @@ +module Text.Short.Partial + ( module Data.Text.Short.Partial + ) where + +import Data.Text.Short.Partial diff --git a/src/Text/Short/Unsafe.hs b/src/Text/Short/Unsafe.hs new file mode 100644 --- /dev/null +++ b/src/Text/Short/Unsafe.hs @@ -0,0 +1,5 @@ +module Text.Short.Unsafe + ( module Data.Text.Short.Unsafe + ) where + +import Data.Text.Short.Unsafe diff --git a/src/Time.hs b/src/Time.hs new file mode 100644 --- /dev/null +++ b/src/Time.hs @@ -0,0 +1,5 @@ +module Time + ( module Data.Time + ) where + +import Data.Time diff --git a/src/Traversable.hs b/src/Traversable.hs new file mode 100644 --- /dev/null +++ b/src/Traversable.hs @@ -0,0 +1,21 @@ +module Traversable + ( -- * Traversable + Traversable(..) + , for + , mapAccumL + , mapAccumR + , traverseBy + , sequenceBy + -- ** Default @Functor@ implementation + , fmapDefault + -- ** Default @Foldable@ implementation + , foldMapDefault + -- * Traversable1 + , Traversable1(..) + ) where + +import Data.Reflection (sequenceBy, traverseBy) +import Data.Semigroup.Traversable (Traversable1(sequence1, traverse1)) +import Data.Traversable (Traversable(sequenceA, traverse), + fmapDefault, foldMapDefault, for, mapAccumL, + mapAccumR) diff --git a/src/Tree.hs b/src/Tree.hs new file mode 100644 --- /dev/null +++ b/src/Tree.hs @@ -0,0 +1,14 @@ +module Tree + ( module Data.Tree + , postorder + , postorderF + , preorder + , preorderF + -- ** Optics + , root + , branches + ) where + +import Data.Graph.Inductive.Basic (postorder, postorderF, preorder, preorderF) +import Data.Tree +import Data.Tree.Lens (branches, root) diff --git a/src/Tuple.hs b/src/Tuple.hs new file mode 100644 --- /dev/null +++ b/src/Tuple.hs @@ -0,0 +1,51 @@ +module Tuple + ( fst + , snd + , curry + , uncurry + , swap + , dupe + -- ** Optics + , Field1(..) + , _1' + , Field2(..) + , _2' + , Field3(..) + , _3' + , Field4(..) + , _4' + , Field5(..) + , _5' + , Field6(..) + , _6' + , Field7(..) + , _7' + , Field8(..) + , _8' + , Field9(..) + , _9' + , Field10(..) + , _10' + , Field11(..) + , _11' + , Field12(..) + , _12' + , Field13(..) + , _13' + , Field14(..) + , _14' + , Field15(..) + , _15' + , Field16(..) + , _16' + , Field17(..) + , _17' + , Field18(..) + , _18' + , Field19(..) + , _19' + ) where + +import Control.Lens.Tuple +import Data.Tuple +import Data.Tuple.Extra diff --git a/src/Type.hs b/src/Type.hs new file mode 100644 --- /dev/null +++ b/src/Type.hs @@ -0,0 +1,8 @@ +module Type + ( Type + , TypeError + , ErrorMessage(..) + ) where + +import Data.Kind +import GHC.TypeLits diff --git a/src/Typeable.hs b/src/Typeable.hs new file mode 100644 --- /dev/null +++ b/src/Typeable.hs @@ -0,0 +1,44 @@ +{-# LANGUAGE PatternSynonyms #-} + +module Typeable + ( Typeable + , cast + , eqT + , gcast + , gcast1 + , gcast2 + , TypeRep + , typeRep + , typeOf + , withTypeable + , pattern App + , pattern Con + , pattern Con' + , pattern Fun + , typeRepTyCon + , rnfTypeRep + , eqTypeRep + , typeRepKind + , splitApps + , SomeTypeRep(..) + , someTypeRep + , someTypeRepTyCon + , rnfSomeTypeRep + , TyCon + , tyConPackage + , tyConModule + , tyConName + , rnfTyCon + , Module + , moduleName + , modulePackage + , rnfModule + -- ** Optics + , _cast + , _gcast + ) where + +import Data.Typeable hiding (TypeRep, rnfTypeRep, typeOf, typeRep, + typeRepTyCon) +import Data.Typeable.Lens (_cast, _gcast) +import Type.Reflection diff --git a/src/URI.hs b/src/URI.hs new file mode 100644 --- /dev/null +++ b/src/URI.hs @@ -0,0 +1,5 @@ +module URI + ( module Network.URI + ) where + +import Network.URI diff --git a/src/UUID.hs b/src/UUID.hs new file mode 100644 --- /dev/null +++ b/src/UUID.hs @@ -0,0 +1,19 @@ +module UUID + ( UUID + , toText + , fromText + , toByteString + , fromByteString + , toWords + , fromWords + , null + , nil + , generateNamed + , namespaceDNS + , namespaceURL + , namespaceOID + , namespaceX500 + ) where + +import Data.UUID.Types +import Data.UUID.V5 diff --git a/src/Unique.hs b/src/Unique.hs new file mode 100644 --- /dev/null +++ b/src/Unique.hs @@ -0,0 +1,7 @@ +module Unique + ( Unique + , newUnique + , hashUnique + ) where + +import Data.Unique diff --git a/src/Vault.hs b/src/Vault.hs new file mode 100644 --- /dev/null +++ b/src/Vault.hs @@ -0,0 +1,5 @@ +module Vault + ( module Data.Vault.Strict + ) where + +import Data.Vault.Strict diff --git a/src/Vault/Lazy.hs b/src/Vault/Lazy.hs new file mode 100644 --- /dev/null +++ b/src/Vault/Lazy.hs @@ -0,0 +1,5 @@ +module Vault.Lazy + ( module Data.Vault.Lazy + ) where + +import Data.Vault.Lazy diff --git a/src/Vector.hs b/src/Vector.hs new file mode 100644 --- /dev/null +++ b/src/Vector.hs @@ -0,0 +1,12 @@ +module Vector + ( -- * Vector + module Data.Vector + -- ** Optics + , toVectorOf + , vector + , forced + , sliced + ) where + +import Data.Vector +import Data.Vector.Lens (forced, sliced, toVectorOf, vector) diff --git a/src/Vector/Builder.hs b/src/Vector/Builder.hs new file mode 100644 --- /dev/null +++ b/src/Vector/Builder.hs @@ -0,0 +1,9 @@ +module Vector.Builder + ( -- * Builder + Builder + , empty + , singleton + , vector + ) where + +import VectorBuilder.Builder (Builder, empty, singleton, vector) diff --git a/src/Vector/Generic.hs b/src/Vector/Generic.hs new file mode 100644 --- /dev/null +++ b/src/Vector/Generic.hs @@ -0,0 +1,7 @@ +module Vector.Generic + ( module Data.Vector.Generic + , build + ) where + +import Data.Vector.Generic +import VectorBuilder.Vector (build) diff --git a/src/Vector/Generic/Mutable.hs b/src/Vector/Generic/Mutable.hs new file mode 100644 --- /dev/null +++ b/src/Vector/Generic/Mutable.hs @@ -0,0 +1,7 @@ +module Vector.Generic.Mutable + ( module Data.Vector.Generic.Mutable + , build + ) where + +import Data.Vector.Generic.Mutable +import VectorBuilder.MVector (build) diff --git a/src/Vector/Mutable.hs b/src/Vector/Mutable.hs new file mode 100644 --- /dev/null +++ b/src/Vector/Mutable.hs @@ -0,0 +1,5 @@ +module Vector.Mutable + ( module Data.Vector.Mutable + ) where + +import Data.Vector.Mutable diff --git a/src/Vector/Primitive.hs b/src/Vector/Primitive.hs new file mode 100644 --- /dev/null +++ b/src/Vector/Primitive.hs @@ -0,0 +1,5 @@ +module Vector.Primitive + ( module Data.Vector.Primitive + ) where + +import Data.Vector.Primitive diff --git a/src/Vector/Storable.hs b/src/Vector/Storable.hs new file mode 100644 --- /dev/null +++ b/src/Vector/Storable.hs @@ -0,0 +1,5 @@ +module Vector.Storable + ( module Data.Vector.Storable + ) where + +import Data.Vector.Storable diff --git a/src/Vector/Unboxed.hs b/src/Vector/Unboxed.hs new file mode 100644 --- /dev/null +++ b/src/Vector/Unboxed.hs @@ -0,0 +1,5 @@ +module Vector.Unboxed + ( module Data.Vector.Unboxed + ) where + +import Data.Vector.Unboxed diff --git a/src/Void.hs b/src/Void.hs new file mode 100644 --- /dev/null +++ b/src/Void.hs @@ -0,0 +1,7 @@ +module Void + ( Void + , absurd + , vacuous + ) where + +import Data.Void diff --git a/src/Weigh.hs b/src/Weigh.hs new file mode 100644 --- /dev/null +++ b/src/Weigh.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE PackageImports #-} + +module Weigh + ( module X + ) where + +import "weigh" Weigh as X diff --git a/src/Writer.hs b/src/Writer.hs new file mode 100644 --- /dev/null +++ b/src/Writer.hs @@ -0,0 +1,19 @@ +module Writer + ( -- * Writer + Writer + , runWriter + , execWriter + , mapWriter + -- * WriterT + , WriterT + , writerT + , runWriterT + , execWriterT + , mapWriterT + -- * MonadWriter + , MonadWriter(..) + , listens + , censor + ) where + +import Control.Monad.Writer.CPS