diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,5 @@ +# Revision history for no-prelude + +## 0.1.0.0 -- 17.08.2021 + +* First version. Released on an unsuspecting world. diff --git a/not-prelude.cabal b/not-prelude.cabal new file mode 100644 --- /dev/null +++ b/not-prelude.cabal @@ -0,0 +1,33 @@ +cabal-version: 2.4 +name: not-prelude +version: 0.1.0.0 + +synopsis: An opinionated Prelude replacement library + +description: This package provides a Prelude that emphasizes reduction of repetitive import boilerplate code for real world haskell programs + +license: MIT +author: Erick Gonzalez +maintainer: erick@codemonkeylabs.de + +category: Prelude +extra-source-files: CHANGELOG.md + +source-repository head + type: git + location: https://gitlab.com/codemonkeylabs/not-prelude.git + +library + hs-source-dirs: src + exposed-modules: Prelude + + default-language: Haskell2010 + other-extensions: NoImplicitPrelude + + build-depends: base-noprelude ^>= 4.13 + , data-default ^>= 0.7 + , exceptions ^>= 0.10 + , failable ^>= 1.2 + , mtl ^>= 2.2 + , text ^>= 1.2 + , transformers ^>= 0.5 diff --git a/src/Prelude.hs b/src/Prelude.hs new file mode 100644 --- /dev/null +++ b/src/Prelude.hs @@ -0,0 +1,217 @@ +{-# LANGUAGE Trustworthy #-} +{-# LANGUAGE NoImplicitPrelude #-} + +----------------------------------------------------------------------------- +-- | +-- Module : Prelude +-- Copyright : (c) The University of Glasgow 2001 +-- License : BSD-style (see the file libraries/base/LICENSE) +-- +-- Maintainer : libraries@haskell.org +-- Stability : stable +-- Portability : portable +-- +-- The Prelude: a standard module. The Prelude is imported by default +-- into all Haskell modules unless either there is an explicit import +-- statement for it, or the NoImplicitPrelude extension is enabled. +-- +----------------------------------------------------------------------------- + +module Prelude ( + + module Whole, + + -- * Standard types, classes and related functions + + -- ** Basic data types + Bool(False, True), bool, + (&&), (||), not, otherwise, + + Ordering(LT, EQ, GT), + Char, String, Text, pack, unpack, + + -- *** Tuples + fst, snd, curry, uncurry, + + -- ** Basic type classes + Eq((==), (/=)), + Ord(compare, (<), (<=), (>=), (>), max, min), + Enum(succ, pred, toEnum, fromEnum, enumFrom, enumFromThen, + enumFromTo, enumFromThenTo), + Bounded(minBound, maxBound), + + -- ** Numbers + + -- *** Numeric types + Int, Int16, Int32, Int64, Integer, Float, Double, + Rational, Word, Word8, Word16, Word32, Word64, + + -- *** Numeric type classes + Num((+), (-), (*), negate, abs, signum, fromInteger), + Real(toRational), + Integral(quot, rem, div, mod, quotRem, divMod, toInteger), + Fractional((/), recip, fromRational), + Floating(pi, exp, sqrt, (**), logBase, sin, cos, tan, + asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh), + RealFrac(properFraction, truncate, round, ceiling, floor), + RealFloat(floatRadix, floatDigits, floatRange, decodeFloat, + encodeFloat, exponent, significand, scaleFloat, isNaN, + isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2), + + -- *** Numeric functions + subtract, even, odd, gcd, lcm, (^), (^^), + fromIntegral, realToFrac, + + -- ** Semigroups and Monoids + Semigroup((<>)), + Monoid(mempty, mappend, mconcat), + + -- ** Arrows + (>>>), (<<<), (&&&), + + -- ** Monads and functors + Functor(fmap, (<$)), (<$>), (<&>), + Applicative(pure, (<*>), (*>), (<*)), (<|>), + Monad((>>=), (>>), return), + MonadFail(fail), + forM, forM_, mapM_, foldM, sequence_, (=<<), + void, unless, when, + (>=>), (<=<), + + -- ** Transformers + MaybeT(runMaybeT), ExceptT, runExceptT, lift, + + -- ** Folds and traversals + Foldable(elem, -- :: (Foldable t, Eq a) => a -> t a -> Bool + -- fold, -- :: Monoid m => t m -> m + foldMap, -- :: Monoid m => (a -> m) -> t a -> m + foldr, -- :: (a -> b -> b) -> b -> t a -> b + -- foldr', -- :: (a -> b -> b) -> b -> t a -> b + foldl, -- :: (b -> a -> b) -> b -> t a -> b + -- foldl', -- :: (b -> a -> b) -> b -> t a -> b + foldr1, -- :: (a -> a -> a) -> t a -> a + foldl1, -- :: (a -> a -> a) -> t a -> a + maximum, -- :: (Foldable t, Ord a) => t a -> a + minimum, -- :: (Foldable t, Ord a) => t a -> a + product, -- :: (Foldable t, Num a) => t a -> a + sum), -- :: Num a => t a -> a + -- toList) -- :: Foldable t => t a -> [a] + + Traversable(traverse, sequenceA, mapM, sequence), + + -- ** Typeable + + Typeable, + + -- ** Default + Default(def), + + -- ** Exceptions + + Handler(Handler), Exception(fromException, toException), SomeException(SomeException), + try, throw, throwM, catch, catches, bracket, bracket_, finally, + + -- ** Miscellaneous functions + id, const, (.), flip, ($), until, + asTypeOf, error, errorWithoutStackTrace, undefined, + seq, ($!), + + -- * List operations + List.map, (List.++), List.filter, + List.head, List.last, List.tail, List.init, (List.!!), + Foldable.null, Foldable.length, + List.reverse, + -- *** Special folds + Foldable.and, Foldable.or, Foldable.any, Foldable.all, + Foldable.concat, Foldable.concatMap, + -- ** Building lists + -- *** Scans + List.scanl, List.scanl1, List.scanr, List.scanr1, + -- *** Infinite lists + List.iterate, List.repeat, List.replicate, List.cycle, + -- ** Sublists + List.take, List.drop, + List.takeWhile, List.dropWhile, + List.span, List.break, + List.splitAt, + -- ** Searching lists + Foldable.notElem, + List.lookup, + -- ** Zipping and unzipping lists + List.zip, List.zip3, + List.zipWith, List.zipWith3, + List.unzip, List.unzip3, + -- ** Functions on strings + List.lines, List.words, List.unlines, List.unwords, + + -- * Converting to and from @String@ + -- ** Converting to @String@ + ShowS, + Show(showsPrec, showList, show), + shows, + showChar, showString, showParen, + -- ** Converting from @String@ + ReadS, + Read(readsPrec, readList), + reads, readParen, read, lex, + + -- * Basic Input and output + IO, + -- ** Simple I\/O operations + -- All I/O functions defined here are character oriented. The + -- treatment of the newline character will vary on different systems. + -- For example, two characters of input, return and linefeed, may + -- read as a single newline character. These functions cannot be + -- used portably for binary I/O. + -- *** Output functions + putChar, + putStr, putStrLn, print, + -- *** Input functions + getChar, + getLine, getContents, interact, + -- *** Files + FilePath, + readFile, writeFile, appendFile, readIO, readLn, + -- ** Exception handling in the I\/O monad + IOError, ioError, userError, + + MonadIO, liftIO, + + readMaybe + + ) where + + +import Control.Arrow +import Control.Exception (throw) +import Control.Monad +import Control.Monad.Catch +import Control.Monad.Failable as Whole +import Control.Monad.IO.Class +import Control.Monad.Trans +import Control.Monad.Trans.Except +import Control.Monad.Trans.Maybe +import Data.Bool ( bool ) +import Data.Default +import Data.Either as Whole +import Data.Foldable ( Foldable(..) ) +import Data.Functor ( (<$>), (<&>) ) +import Data.Int +import Data.Word +import Data.Maybe as Whole +import Data.Text +import Data.Traversable ( Traversable(..) ) +import Data.Tuple +import Data.Typeable +import GHC.Base hiding ( foldr, mapM, sequence ) +import GHC.Enum +import GHC.Float +import GHC.Num +import GHC.Real +import GHC.Show +import qualified Data.Foldable as Foldable +import qualified Data.List as List +import System.IO +import System.IO.Error +import Text.Read hiding (lift) +