packages feed

protolude 0.1.1 → 0.1.2

raw patch · 7 files changed

+140/−85 lines, 7 filesdep +ghc-prim

Dependencies added: ghc-prim

Files

protolude.cabal view
@@ -1,5 +1,5 @@ name:                protolude-version:             0.1.1+version:             0.1.2 synopsis:            A sensible set of defaults for writing custom Preludes. description:         A sensible set of defaults for writing custom Preludes. homepage:            https://github.com/sdiehl/protolude@@ -33,37 +33,41 @@ library   exposed-modules:          Protolude+    Unsafe    other-modules:+    Base     Applicative     Bool     Debug     List     Monad     Show-    Unsafe     Either     Functor     Bifunctor    default-extensions:     NoImplicitPrelude+    OverloadedStrings+    MultiParamTypeClasses    ghc-options:     -Wall    build-depends:       -    base             >= 4.6 && <4.10,-    safe             >= 0.3 && <0.4,-    async            >= 2.1 && <2.2,-    deepseq          >= 1.3 && <= 1.5,-    containers       >= 0.5 && <0.6,-    semiring-simple  >= 0.1 && <1.1,-    mtl              >= 2.1 && <2.3,-    transformers     >= 0.4 && < 0.6,-    text             >= 1.2 && <1.3,-    stm              >= 2.4 && <2.5,-    string-conv      >= 0.1 && <0.2,+    base             >= 4.6  && <4.10,+    ghc-prim         >= 0.3  && <0.6,+    safe             >= 0.3  && <0.4,+    async            >= 2.1  && <2.2,+    deepseq          >= 1.3  && <= 1.5,+    containers       >= 0.5  && <0.6,+    semiring-simple  >= 0.1  && <1.1,+    mtl              >= 2.1  && <2.3,+    transformers     >= 0.4  && < 0.6,+    text             >= 1.2  && <1.3,+    stm              >= 2.4  && <2.5,+    string-conv      >= 0.1  && <0.2,     bytestring       >= 0.10 && <0.11    hs-source-dirs:      src
src/Applicative.hs view
@@ -7,9 +7,10 @@   eitherA, ) where -import Data.Monoid+import Data.Bool (Bool)+import Data.Either (Either(..))+import Data.Monoid (Monoid(..)) import Control.Applicative-import Prelude (Bool, Either(..))  orAlt :: (Alternative f, Monoid a) => f a -> f a orAlt f = f <|> pure mempty
+ src/Base.hs view
@@ -0,0 +1,57 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE Unsafe #-}+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE NoImplicitPrelude #-}++module Base (+  module X,+  ($!),+) where++-- Glorious Glashgow Haskell Compiler+#if defined(__GLASGOW_HASKELL__) && ( __GLASGOW_HASKELL__ >= 600 )++-- Base GHC types+import GHC.Num as X+import GHC.Enum as X+import GHC.Real as X+import GHC.Float as X+import GHC.Show as X+import GHC.Exts as X (+    Constraint+  , Ptr+  , FunPtr+  , the+  )+import GHC.Base as X (+    (++)+  , seq+  , asTypeOf+  )+import System.IO as X (+    print+  , putStr+  , putStrLn+  )++#if ( __GLASGOW_HASKELL__ >= 800 )+import GHC.Types as X hiding (Any)+#else+import GHC.Types as X+#endif++infixr 0 $!++($!) :: (a -> b) -> a -> b+f $! x  = let !vx = x in f vx++#endif++-- Simple Haskell Compiler+#if defined(__SHC_HASKELL__)++import SHC.Prim as X+import SHC.Types as X+import SHC.Classes as X++#endif
src/Monad.hs view
@@ -1,5 +1,5 @@ {-# LANGUAGE CPP #-}-{-# LANGUAGE Safe #-}+{-# LANGUAGE Trustworthy #-} {-# LANGUAGE NoImplicitPrelude #-}  module Monad (@@ -39,8 +39,8 @@   , (<$!>)   ) where +import Base (seq) import Data.List (concat)-import Prelude (seq)  #if (__GLASGOW_HASKELL__ >= 710) import Control.Monad hiding ((<$!>))
src/Protolude.hs view
@@ -1,13 +1,13 @@ {-# LANGUAGE CPP #-}+{-# LANGUAGE Trustworthy #-} {-# LANGUAGE NoImplicitPrelude #-} {-# OPTIONS_GHC -fno-warn-unused-imports #-}  module Protolude (   module X,+  module Base,   identity,-  bool,   (&),-  ($!),   uncons,   applyN,   print,@@ -16,17 +16,24 @@   LByteString, ) where -import qualified Prelude as P+{-import qualified Prelude as P-} -import qualified List as X-import qualified Show as X-import qualified Bool as X-import qualified Debug as X-import qualified Monad as X-import qualified Functor as X-import qualified Either as X-import qualified Applicative as X+import List as X+import Show as X+import Bool as X+import Debug as X+import Monad as X+import Functor as X+import Either as X+import Applicative as X +import Base as Base hiding (+    putStr+  , putStrLn+  , print+  )+import qualified Base as PBase+ -- Maybe'ized version of partial functions import Safe as X (     headMay@@ -88,7 +95,6 @@  -- Data structures import Data.Tuple as X-import Data.Semiring as X import Data.List as X (     splitAt   , break@@ -99,6 +105,8 @@   , reverse   , replicate   , take+  , zipWith+  , zip   ) import Data.Map as X (Map) import Data.Set as X (Set)@@ -117,6 +125,10 @@   , modify   , withState +  , runState+  , execState+  , evalState+   , runStateT   , execStateT   , evalStateT@@ -168,24 +180,6 @@   , on   ) --- Base GHC types-import GHC.IO as X (IO)-import GHC.Num as X-import GHC.Enum as X-import GHC.Real as X-import GHC.Float as X-import GHC.Show as X-import GHC.Exts as X (-    Constraint-  , Ptr-  , FunPtr-  , the-  )-import GHC.Base as X (-    (++)-  , seq-  , asTypeOf-  )  -- Genericss import GHC.Generics (@@ -208,13 +202,12 @@  -- ByteString import qualified Data.ByteString.Lazy-import qualified Data.ByteString as X (ByteString)+import Data.ByteString as X (ByteString)  -- Text import Data.Text as X (Text) import qualified Data.Text.Lazy import qualified Data.Text.IO-import Text.Printf as X (printf)  import Data.Text.Lazy (     toStrict@@ -226,10 +219,11 @@   , toS   , toSL   , Leniency(..)+  , StringConv   )  -- Printf-import Text.Printf as Exports (+import Text.Printf as X (     PrintfArg   , printf   , hPrintf@@ -244,7 +238,7 @@   )  -- ST-import Control.Monad.ST as ST+import Control.Monad.ST as X  -- Concurrency and Parallelism import Control.Exception as X@@ -252,7 +246,7 @@ import Control.Concurrent as X import Control.Concurrent.Async as X -import Foreign.Storable as Exports (Storable)+import Foreign.Storable as X (Storable)  -- Read instances hiding unsafe builtins (read) import Text.Read as X (@@ -271,14 +265,6 @@ (&) :: a -> (a -> b) -> b x & f = f x -infixr 0 $!--($!) :: (a -> b) -> a -> b-($!) = (P.$!)--bool :: a -> a -> Bool -> a-bool f t b = if b then t else f- identity :: a -> a identity x = x @@ -289,5 +275,5 @@ applyN :: Int -> (a -> a) -> a -> a applyN n f = X.foldr (.) identity (X.replicate n f) -print :: (X.MonadIO m, P.Show a) => a -> m ()-print = liftIO . P.print+print :: (X.MonadIO m, PBase.Show a) => a -> m ()+print = liftIO . PBase.print
src/Show.hs view
@@ -1,8 +1,9 @@-{-# LANGUAGE Safe #-}+{-# LANGUAGE Trustworthy #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE ExtendedDefaultRules #-}  module Show (   Print(..),@@ -10,8 +11,8 @@   putLText, ) where -import Prelude ((.), Char, IO)-import qualified Prelude+import qualified Base+import Data.Function ((.))  import Control.Monad.IO.Class (MonadIO, liftIO) import qualified Data.ByteString.Char8 as BS@@ -23,6 +24,7 @@ import qualified Data.Text.Lazy as TL import qualified Data.Text.Lazy.IO as TL + class Print a where   putStr :: MonadIO m => a -> m ()   putStrLn :: MonadIO m => a -> m ()@@ -43,15 +45,15 @@   putStr = liftIO . BL.putStr   putStrLn = liftIO . BL.putStrLn -instance Print [Char] where-  putStr = liftIO . Prelude.putStr-  putStrLn = liftIO . Prelude.putStrLn+instance Print [Base.Char] where+  putStr = liftIO . Base.putStr+  putStrLn = liftIO . Base.putStrLn  -- For forcing type inference putText :: MonadIO m => T.Text -> m () putText = putStrLn-{-# SPECIALIZE putText :: T.Text -> IO () #-}+{-# SPECIALIZE putText :: T.Text -> Base.IO () #-}  putLText :: MonadIO m => TL.Text -> m () putLText = putStrLn-{-# SPECIALIZE putLText :: TL.Text -> IO () #-}+{-# SPECIALIZE putLText :: TL.Text -> Base.IO () #-}
src/Unsafe.hs view
@@ -1,28 +1,33 @@+{-# LANGUAGE Unsafe #-} {-# LANGUAGE NoImplicitPrelude #-} -module Unsafe where+module Unsafe (+  unsafeHead,+  unsafeTail,+  unsafeInit,+  unsafeLast,+  fromJust,+  unsafeIndex,+) where -import qualified Prelude-import qualified Data.Maybe-import qualified Data.List+import Base (Int)+import qualified Data.List as List+import qualified Data.Maybe as Maybe  unsafeHead :: [a] -> a-unsafeHead = Prelude.head+unsafeHead = List.head  unsafeTail :: [a] -> [a]-unsafeTail = Prelude.tail+unsafeTail = List.tail  unsafeInit :: [a] -> [a]-unsafeInit = Prelude.init+unsafeInit = List.init  unsafeLast :: [a] -> a-unsafeLast = Prelude.last--fromJust :: Prelude.Maybe a -> a-fromJust = Data.Maybe.fromJust+unsafeLast = List.last -unsafeIndex :: [a] -> Prelude.Int -> a-unsafeIndex = (Data.List.!!)+fromJust :: Maybe.Maybe a -> a+fromJust = Maybe.fromJust -(!!) :: [a] -> Prelude.Int -> a-(!!) = (Data.List.!!)+unsafeIndex :: [a] -> Int -> a+unsafeIndex = (List.!!)