not-prelude (empty) → 0.1.0.0

raw patch · 3 files changed

+255/−0 lines, 3 filesdep +base-nopreludedep +data-defaultdep +exceptions

Dependencies added: base-noprelude, data-default, exceptions, failable, mtl, text, transformers

Files

• CHANGELOG.md +5/−0
• not-prelude.cabal +33/−0
• src/Prelude.hs +217/−0

@@ -0,0 +1,5 @@+# Revision history for no-prelude++## 0.1.0.0 -- 17.08.2021++* First version. Released on an unsuspecting world.

@@ -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

@@ -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)+