-
Notifications
You must be signed in to change notification settings - Fork 258
/
IHaskellPrelude.hs
149 lines (123 loc) · 4.51 KB
/
IHaskellPrelude.hs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
{-# LANGUAGE CPP #-}
module IHaskellPrelude (
module IHaskellPrelude,
module X,
-- Select reexports
Data.Typeable.Typeable,
Data.Typeable.cast,
#if MIN_VERSION_ghc(7,8,0)
Data.Typeable.Proxy,
GHC.Exts.IsString,
GHC.Exts.IsList,
#endif
System.IO.hPutStrLn,
System.IO.hPutStr,
System.IO.hPutChar,
System.IO.hPrint,
System.IO.stdout,
System.IO.stderr,
System.IO.stdin,
System.IO.getChar,
System.IO.getLine,
System.IO.writeFile,
System.IO.Handle,
System.IO.Strict.readFile,
System.IO.Strict.getContents,
System.IO.Strict.hGetContents,
Control.Exception.catch,
Control.Exception.SomeException,
Control.Applicative.Applicative(..),
Control.Applicative.ZipList(..),
(Control.Applicative.<$>),
Control.Concurrent.MVar.MVar,
Control.Concurrent.MVar.newMVar,
Control.Concurrent.MVar.newEmptyMVar,
Control.Concurrent.MVar.isEmptyMVar,
Control.Concurrent.MVar.readMVar,
Control.Concurrent.MVar.takeMVar,
Control.Concurrent.MVar.putMVar,
Control.Concurrent.MVar.modifyMVar,
Control.Concurrent.MVar.modifyMVar_,
Data.IORef.IORef,
Data.IORef.readIORef,
Data.IORef.writeIORef,
Data.IORef.modifyIORef',
Data.IORef.newIORef,
-- Miscellaneous names
Data.Map.Map,
GHC.IO.FilePath,
Data.Text.Text,
Data.ByteString.ByteString,
Text.Printf.printf,
Data.Function.on,
) where
import Prelude
import Data.Monoid as X
import Data.Tuple as X
import Control.Monad as X
import Data.Maybe as X
import Data.Either as X
import Control.Monad.IO.Class as X
import Data.Ord as X
import GHC.Show as X
import GHC.Enum as X
import GHC.Num as X
import GHC.Real as X
import GHC.Err as X hiding (absentErr)
#if MIN_VERSION_ghc(7,10,0)
import GHC.Base as X hiding (Any, mapM, foldr, sequence, many, (<|>))
#else
import GHC.Base as X hiding (Any)
#endif
import Data.List as X hiding (head, last, tail, init, transpose, subsequences, permutations,
foldl, foldl1, maximum, minimum, scanl, scanl1, scanr, scanr1,
span, break, mapAccumL, mapAccumR, dropWhileEnd, (!!),
elemIndices, elemIndex, findIndex, findIndices, zip5, zip6,
zip7, zipWith5, zipWith6, zipWith7, unzip5, unzip6, unzip6,
delete, union, lookup, intersect, insert, deleteBy,
deleteFirstBy, unionBy, intersectBy, group, groupBy, insertBy,
maximumBy, minimumBy, genericLength, genericDrop, genericTake,
genericSplitAt, genericIndex, genericReplicate, inits, tails)
import qualified Control.Applicative
import qualified Data.Typeable
import qualified Data.IORef
import qualified Data.Map
import qualified Data.Text
import qualified Data.Text.Lazy
import qualified Data.ByteString
import qualified Data.ByteString.Lazy
import qualified Data.Function
import qualified GHC.Exts
import qualified System.IO
import qualified System.IO.Strict
import qualified GHC.IO
import qualified Text.Printf
import qualified Control.Exception
import qualified Control.Concurrent.MVar
import qualified Data.List
import qualified Prelude as P
type LByteString = Data.ByteString.Lazy.ByteString
type LText = Data.Text.Lazy.Text
(headMay, tailMay, lastMay, initMay, maximumMay, minimumMay) =
(wrapEmpty head, wrapEmpty tail, wrapEmpty last,
wrapEmpty init, wrapEmpty maximum, wrapEmpty minimum)
where
wrapEmpty :: ([a] -> b) -> [a] -> Maybe b
wrapEmpty _ [] = Nothing
wrapEmpty f xs = Just (f xs)
maximumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a
maximumByMay _ [] = Nothing
maximumByMay f xs = Just (Data.List.maximumBy f xs)
minimumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a
minimumByMay _ [] = Nothing
minimumByMay f xs = Just (Data.List.minimumBy f xs)
readMay :: Read a => String -> Maybe a
readMay = fmap fst . headMay . reads
putStrLn :: (MonadIO m) => String -> m ()
putStrLn = liftIO . P.putStrLn
putStr :: (MonadIO m) => String -> m ()
putStr = liftIO . P.putStr
putChar :: MonadIO m => Char -> m ()
putChar = liftIO . P.putChar
print :: (MonadIO m, Show a) => a -> m ()
print = liftIO . P.print