module Praglude
(
module Prelude
, Monoid (..)
, (<>)
, Dual (..)
, Endo (..)
, All (..)
, Any (..)
, Sum (..)
, Product (..)
, First (..)
, Alt (..)
, concat
, append
, empty
, Maybe(Nothing, Just)
, maybe
, isJust
, isNothing
, fromJust
, fromMaybe
, listToMaybe
, maybeToList
, catMaybes
, mapMaybe
, (<|>)
, Monad ((>>=), (>>), return, fail)
, MonadPlus(mzero, mplus)
, mapM
, mapM_
, forM
, forM_
, sequence
, sequence_
, (=<<)
, (>=>)
, (<=<)
, forever
, void
, join
, msum
, mfilter
, filterM
, mapAndUnzipM
, zipWithM
, zipWithM_
, foldM
, foldM_
, replicateM
, replicateM_
, guard
, when
, unless
, liftM
, liftM2
, liftM3
, liftM4
, liftM5
, ap
, (<$!>)
, Arrow (..)
, Kleisli (..)
, returnA
, (^>>)
, (>>^)
, (>>>)
, (<<<)
, (<<^)
, (^<<)
, ArrowZero (..)
, ArrowPlus (..)
, ArrowChoice (..)
, ArrowApply (..)
, ArrowMonad (..)
, leftApp
, ArrowLoop (..)
, left
, right
, (+++)
, (|||)
, IORef
, newIORef
, readIORef
, writeIORef
, modifyIORef
, modifyIORef'
, atomicModifyIORef
, atomicModifyIORef'
, atomicWriteIORef
, mkWeakIORef
, MVar
, newEmptyMVar
, newMVar
, takeMVar
, putMVar
, readMVar
, swapMVar
, tryTakeMVar
, tryPutMVar
, isEmptyMVar
, withMVar
, withMVarMasked
, modifyMVar_
, modifyMVar
, modifyMVarMasked_
, modifyMVarMasked
, tryReadMVar
, mkWeakMVar
, addMVarFinalizer
, Chan
, newChan
, writeChan
, readChan
, dupChan
, getChanContents
, writeList2Chan
, Default (def)
, (#)
, (#%%=)
, (#%%~)
, (#%=)
, (#%~)
, (#=)
, (#~)
, (%%=)
, (%%@=)
, (%%@~)
, (%%~)
, (%=)
, (%@=)
, (%@~)
, (%~)
, (&)
, (&&=)
, (&&~)
, (&~)
, (**=)
, (**~)
, (*=)
, (*~)
, (+=)
, (+~)
, (-=)
, (-~)
, (...)
, (.=)
, (.>)
, (.@=)
, (.@~)
, (.~)
, (//=)
, (//~)
, (<#%=)
, (<#%~)
, (<#=)
, (<#~)
, (<%=)
, (<%@=)
, (<%@~)
, (<%~)
, (<&&=)
, (<&&~)
, (<&>)
, (<**=)
, (<**~)
, (<*=)
, (<*~)
, (<+=)
, (<+~)
, (<-=)
, (<-~)
, (<.)
, (<.=)
, (<.>)
, (<.~)
, (<//=)
, (<//~)
, (<<%=)
, (<<%@=)
, (<<%@~)
, (<<%~)
, (<<&&=)
, (<<&&~)
, (<<**=)
, (<<**~)
, (<<*=)
, (<<*~)
, (<<+=)
, (<<+~)
, (<<-=)
, (<<-~)
, (<<.=)
, (<<.~)
, (<<//=)
, (<<//~)
, (<<<>=)
, (<<<>~)
, (<<>=)
, (<<>~)
, (<<^=)
, (<<^^=)
, (<<^^~)
, (<<^~)
, (<<||=)
, (<<||~)
, (<<~)
, (<>=)
, (<>~)
, (<?=)
, (<?~)
, (<^=)
, (<^^=)
, (<^^~)
, (<^~)
, (<|)
, (<||=)
, (<||~)
, (<~)
, (?=)
, (??)
, (?~)
, ALens (..)
, ALens' (..)
, APrism (..)
, APrism' (..)
, AReview (..)
, ASetter (..)
, ASetter' (..)
, ATraversal (..)
, ATraversal' (..)
, ATraversal1 (..)
, ATraversal1' (..)
, Accessing (..)
, AnEquality (..)
, AnEquality' (..)
, AnIndexedLens (..)
, AnIndexedLens' (..)
, AnIndexedSetter (..)
, AnIndexedSetter' (..)
, AnIndexedTraversal (..)
, AnIndexedTraversal' (..)
, AnIndexedTraversal1 (..)
, AnIndexedTraversal1' (..)
, AnIso (..)
, AnIso' (..)
, As (..)
, AsEmpty (..)
, Ixed (..)
, Bazaar (..)
, Bazaar' (..)
, Bazaar1 (..)
, Bazaar1 (..)
, Bazaar1' (..)
, Bifunctor (..)
, Profunctor (..)
, ClassyNamer
, Cons (..)
, Const (..)
, Const (..)
, Contains (..)
, Context (..)
, Context' (..)
, Contravariant (..)
, DefName
, Each (..)
, Equality (..)
, Equality' (..)
, Field1 (..)
, Field2 (..)
, Field3 (..)
, Field4 (..)
, Field5 (..)
, Field6 (..)
, Field7 (..)
, Field8 (..)
, Field9 (..)
, FieldNamer
, Fold (..)
, Fold1 (..)
, Foldable (..)
, Functor (..)
, GPlated (..)
, Getter (..)
, Getting (..)
, Identical (..)
, Identical (..)
, Identity (..)
, Index (..)
, IndexPreservingFold (..)
, IndexPreservingFold1 (..)
, IndexPreservingGetter (..)
, IndexPreservingLens (..)
, IndexPreservingLens' (..)
, IndexPreservingSetter (..)
, IndexPreservingSetter' (..)
, IndexPreservingTraversal (..)
, IndexPreservingTraversal' (..)
, IndexPreservingTraversal1 (..)
, IndexPreservingTraversal1' (..)
, Conjoined (..)
, Indexed (..)
, IndexedFold (..)
, IndexedFold1 (..)
, IndexedGetter (..)
, IndexedGetting (..)
, IndexedLens (..)
, IndexedLens' (..)
, IndexedLensLike (..)
, IndexedLensLike' (..)
, IndexedSetter (..)
, IndexedSetter' (..)
, IndexedTraversal (..)
, IndexedTraversal' (..)
, IndexedTraversal1 (..)
, IndexedTraversal1' (..)
, Iso (..)
, Iso' (..)
, IxValue (..)
, Ixed (..)
, Leftmost (..)
, Lens (..)
, Lens' (..)
, LensLike (..)
, LensLike' (..)
, LensRules
, Level (..)
, Magma (..)
, Magnified (..)
, Optic (..)
, Optic' (..)
, Optical (..)
, Optical' (..)
, Over (..)
, Over' (..)
, Plated (..)
, Prism (..)
, Prism' (..)
, Profunctor (..)
, ReifiedFold (..)
, ReifiedFold (..)
, ReifiedGetter (..)
, ReifiedGetter (..)
, ReifiedIndexedFold (..)
, ReifiedIndexedFold (..)
, ReifiedIndexedGetter (..)
, ReifiedIndexedGetter (..)
, ReifiedIndexedLens (..)
, ReifiedIndexedLens (..)
, ReifiedIndexedLens' (..)
, ReifiedIndexedSetter (..)
, ReifiedIndexedSetter (..)
, ReifiedIndexedSetter' (..)
, ReifiedIndexedTraversal (..)
, ReifiedIndexedTraversal (..)
, ReifiedIndexedTraversal' (..)
, ReifiedIso (..)
, ReifiedIso (..)
, ReifiedIso' (..)
, ReifiedLens (..)
, ReifiedLens (..)
, ReifiedLens' (..)
, ReifiedPrism (..)
, ReifiedPrism (..)
, ReifiedPrism' (..)
, ReifiedSetter (..)
, ReifiedSetter (..)
, ReifiedSetter' (..)
, ReifiedTraversal (..)
, ReifiedTraversal (..)
, ReifiedTraversal' (..)
, Reversing (..)
, Review (..)
, Wrapped (..)
, Rightmost (..)
, Sequenced (..)
, Sequenced (..)
, Setter (..)
, Setter' (..)
, Setting (..)
, Setting' (..)
, Simple (..)
, Snoc (..)
, Strict
, Strict (..)
, Swapped
, Bifunctor (..)
, Traversal (..)
, Traversal' (..)
, Traversal1 (..)
, Traversal1' (..)
, Ord (..)
, Ord (..)
, Traversed (..)
, Traversed (..)
, Traversing (..)
, Traversing' (..)
, Traversing1 (..)
, Traversing1' (..)
, Unwrapped
, Wrapped
, Wrapped (..)
, Zoomed (..)
, (^#)
, (^.)
, (^..)
, (^=)
, (^?)
, (^?!)
, (^@.)
, (^@..)
, (^@?)
, (^@?!)
, (^^=)
, (^^~)
, (^~)
, _1'
, _2'
, _3'
, _4'
, _5'
, _6'
, _7'
, _8'
, _9'
, _Just
, _Left
, _Nothing
, _Right
, _Show
, _Unwrapped
, _Unwrapped'
, _Unwrapping
, _Unwrapping'
, _Void
, _Wrapped
, _Wrapping
, _Wrapping'
, _head
, _init
, _last
, _tail
, abbreviatedFields
, abbreviatedNamer
, ala
, alaf
, allOf
, alongside
, andOf
, anon
, anyOf
, argument
, asIndex
, aside
, assign
, assignA
, asumOf
, au
, auf
, backwards
, below
, beside
, bimapping
, both
, camelCaseFields
, camelCaseNamer
, censoring
, children
, choosing
, chosen
, classyRules
, classyRules_
, cloneIndexPreservingLens
, cloneIndexPreservingSetter
, cloneIndexPreservingTraversal
, cloneIndexPreservingTraversal1
, cloneIndexedLens
, cloneIndexedSetter
, cloneIndexedTraversal
, cloneIndexedTraversal1
, cloneIso
, cloneLens
, clonePrism
, cloneSetter
, cloneTraversal
, cloneTraversal1
, coerced
, composOpFold
, concatMapOf
, concatOf
, confusing
, cons
, contexts
, contextsOf
, contextsOn
, contextsOnOf
, contramapped
, contramapping
, cosmos
, cosmosOf
, cosmosOn
, cosmosOnOf
, createClass
, curried
, cycled
, declareClassy
, declareClassyFor
, declareFields
, declareLenses
, declareLensesFor
, declareLensesWith
, declarePrisms
, declareWrapped
, deep
, deepOf
, defaultFieldRules
, devoid
, dimapping
, dropping
, droppingWhile
, elemIndexOf
, elemIndicesOf
, elemOf
, element
, elementOf
, elements
, elementsOf
, enum
, failing
, failover
, filtered
, findIndexOf
, findIndicesOf
, findMOf
, findOf
, firstOf
, firsting
, flipped
, foldBy
, foldByOf
, foldMapBy
, foldMapByOf
, foldMapOf
, foldOf
, folded
, folded64
, folding
, foldl1Of
, foldl1Of'
, foldlMOf
, foldlOf
, foldlOf'
, foldr1Of
, foldr1Of'
, foldrMOf
, foldrOf
, foldrOf'
, foldring
, forMOf
, forMOf_
, forOf
, forOf_
, Control.Lens.from
, fromEq
, fusing
, generateLazyPatterns
, generateSignatures
, generateUpdateableOptics
, getting
, gplate
, has
, hasn't
, holes
, holesOf
, holesOn
, holesOnOf
, iall
, iallOf
, iany
, ianyOf
, iat
, icensoring
, icompose
, iconcatMap
, iconcatMapOf
, icontains
, idroppingWhile
, ifailover
, ifiltered
, ifind
, ifindMOf
, ifindOf
, ifoldMapBy
, ifoldMapByOf
, ifoldMapOf
, ifolding
, ifoldlM
, ifoldlMOf
, ifoldlOf
, ifoldlOf'
, ifoldrM
, ifoldrMOf
, ifoldrOf
, ifoldrOf'
, ifoldring
, ifor
, iforM
, iforMOf
, iforMOf_
, iforM_
, iforOf
, iforOf_
, ifor_
, ignored
, iix
, ilens
, ilevels
, ilike
, ilistening
, ilistenings
, iloci
, imagma
, imapAccumL
, imapAccumLOf
, imapAccumR
, imapAccumROf
, imapM
, imapMOf
, imapMOf_
, imapM_
, imapOf
, imodifying
, index
, indexing
, indexing64
, indices
, inone
, inoneOf
, inside
, involuted
, iover
, ipartsOf
, ipartsOf'
, ipassing
, iplens
, ipre
, ipreuse
, ipreuses
, ipreview
, ipreviews
, iset
, isets
, isn't
, iso
, itakingWhile
, iterated
, ito
, itoList
, itoListOf
, itraverseBy
, itraverseByOf
, itraverseOf
, itraverseOf_
, itraverse_
, iunsafePartsOf
, iunsafePartsOf'
, iuse
, iuses
, iview
, iviews
, ixAt
, lastOf
, Control.Lens.lazy
, lengthOf
, lens
, lensClass
, lensField
, lensRules
, lensRulesFor
, levels
, lifted
, like
, lined
, listening
, listenings
, lmapping
, loci
, locus
, lookingupNamer
, lookupOf
, magma
, makeClassy
, makeClassyFor
, makeClassyPrisms
, makeClassy_
, makeFields
, makeLenses
, makeLensesFor
, makeLensesWith
, makePrisms
, makeWrapped
, mapAccumLOf
, mapAccumROf
, mapEq
, mapMOf
, mapMOf_
, mapOf
, mapped
, mapping
, mappingNamer
, matching
, maximumByOf
, maximumOf
, minimumByOf
, minimumOf
, modifying
, msumOf
, nearly
, non
, non'
, none
, noneOf
, notElemOf
, notNullOf
, nullOf
, only
, op
, orOf
, outside
, over
, overA
, para
, paraOf
, parts
, partsOf
, partsOf'
, passing
, pre
, preuse
, preuses
, preview
, previews
, prism
, prism'
, productOf
, re
, reindexed
, repeated
, replicated
, retagged
, reuse
, reuses
, reversed
, review
, reviews
, rewrite
, rewriteM
, rewriteMOf
, rewriteMOn
, rewriteMOnOf
, rewriteOf
, rewriteOn
, rewriteOnOf
, rmapping
, runEq
, sans
, scanl1Of
, scanr1Of
, scribe
, seconding
, selfIndex
, sequenceAOf
, sequenceAOf_
, sequenceBy
, sequenceByOf
, sequenceOf
, sequenceOf_
, set
, set'
, sets
, setting
, simple
, simpleLenses
, simply
, singular
, snoc
, storing
, substEq
, sumOf
, taking
, takingWhile
, Control.Lens.to
, toListOf
, transform
, transformM
, transformMOf
, transformMOn
, transformMOnOf
, transformOf
, transformOn
, transformOnOf
, transposeOf
, traverseBy
, traverseByOf
, traverseOf
, traverseOf_
, traversed
, traversed1
, traversed64
, un
, uncons
, uncurried
, under
, underscoreFields
, underscoreNamer
, underscoreNoPrefixNamer
, unfolded
, united
, universe
, universeOf
, universeOn
, universeOnOf
, unsafePartsOf
, unsafePartsOf'
, unsafeSingular
, unsnoc
, unto
, use
, uses
, view
, views
, withIndex
, withIso
, withPrism
, without
, worded
, (|>)
, (||=)
, (||~)
, MonadTrans (..)
, MonadIO (..)
, MonadState(..)
, modify
, modify'
, gets
, State
, runState
, evalState
, execState
, mapState
, withState
, StateT(StateT)
, runStateT
, evalStateT
, execStateT
, mapStateT
, withStateT
, s
, ToString (..)
, FromString
, IsString (..)
, Text
, LText
, ByteString
, LByteString
, trim
, ltrim
, rtrim
, words
, lines
, Char
, isControl
, isSpace
, isLower
, isUpper
, isAlpha
, isAlphaNum
, isPrint
, isDigit
, isOctDigit
, isHexDigit
, isLetter
, isMark
, isNumber
, isPunctuation
, isSymbol
, isSeparator
, isAscii
, isLatin1
, isAsciiUpper
, isAsciiLower
, GeneralCategory(..)
, generalCategory
, toUpper
, toLower
, toTitle
, digitToInt
, intToDigit
, ord
, chr
, showLitChar
, lexLitChar
, readLitChar
, kebab, snake, pascal
, stderr
, stdout
, stdin
, Handle
, getArgs
, getProgName
, getExecutablePath
, getEnv
, lookupEnv
, setEnv
, unsetEnv
, withArgs
, withProgName
, getEnvironment
, StringIO (..)
, printf
, hPrintf
, PrintfArg(..)
, FieldFormatter
, FieldFormat(..)
, FormatAdjustment(..)
, FormatSign(..)
, vFmt
, ModifierParser
, FormatParse(..)
, formatString
, formatChar
, formatInt
, formatInteger
, formatRealFloat
, errorBadFormat
, errorShortFormat
, errorMissingArgument
, errorBadArgument
, perror
, PrintfType
, HPrintfType
, IsChar(..)
, (</>)
, FilePath
, addExtension
, addTrailingPathSeparator
, combine
, dropDrive
, dropExtension
, dropExtensions
, dropFileName
, dropTrailingPathSeparator
, equalFilePath
, extSeparator
, getSearchPath
, hasDrive
, hasExtension
, hasTrailingPathSeparator
, isAbsolute
, isDrive
, isExtSeparator
, isPathSeparator
, isRelative
, isSearchPathSeparator
, joinDrive
, joinPath
, makeRelative
, makeValid
, normalise
, pathSeparator
, pathSeparators
, replaceBaseName
, replaceDirectory
, replaceExtension
, replaceExtensions
, replaceFileName
, searchPathSeparator
, splitDirectories
, splitDrive
, splitExtension
, splitExtensions
, splitFileName
, splitPath
, splitSearchPath
, stripExtension
, takeBaseName
, takeDirectory
, takeDrive
, takeExtension
, takeExtensions
, takeFileName
, Permissions (..)
, XdgDirectory (..)
, canonicalizePath
, copyFile
, copyFileWithMetadata
, copyPermissions
, createDirectory
, createDirectoryIfMissing
, doesDirectoryExist
, doesFileExist
, emptyPermissions
, findExecutable
, findExecutables
, findExecutablesInDirectories
, findFile
, findFileWith
, findFiles
, findFilesWith
, getAccessTime
, getAppUserDataDirectory
, getCurrentDirectory
, getDirectoryContents
, getHomeDirectory
, getModificationTime
, getPermissions
, getTemporaryDirectory
, getUserDocumentsDirectory
, getXdgDirectory
, isSymbolicLink
, listDirectory
, makeAbsolute
, makeRelativeToCurrentDirectory
, removeDirectory
, removeDirectoryRecursive
, removeFile
, renameDirectory
, renameFile
, setAccessTime
, setCurrentDirectory
, setModificationTime
, setOwnerExecutable
, setOwnerReadable
, setOwnerSearchable
, setOwnerWritable
, setPermissions
, withCurrentDirectory
, exeExtension
, asString
, asText
, asLText
, asByteString
, asLByteString
, asHashMap
, Foldable(..)
, foldrM
, foldlM
, traverse_
, for_
, sequenceA_
, asum
, mapM_
, forM_
, sequence_
, msum
, concat
, concatMap
, and
, or
, any
, all
, maximumBy
, minimumBy
, notElem
, find
, AList (..)
, HashMap
, LHashMap
, HashSet
, Map
, Set
, Vector
, Hashable (..)
, Lookup (..)
, ListLike (..)
, DictLike (..)
, SetLike (..)
, Filterable (..)
, cull
, startsWith
, endsWith
, intercalate
, ToJSON (..)
, FromJSON (..)
, Value
, object
, prettyJsonOptions
, derivePrettyJSON
, deriveJSON
, encodeJSON
, decodeJSON
, encodeJSONStrict
, decodeJSONStrict
, (~>)
, encodeBase64
, decodeBase64
, threadDelay
, forkIO
, bracket
, bracket_
, throw
, catch
, catches
, Generic
, chain
, id
, const
, (.)
, flip
, ($)
, (&)
, fix
, on
, Day (..)
, TimeOfDay (..)
, UTCTime (..)
, LocalTime (..)
, TimeZone (..)
, ZonedTime (..)
, TimeLocale (..)
, DiffTime (..)
, NominalDiffTime (..)
, secondsToDiffTime
, picosecondsToDiffTime
, addUTCTime
, diffUTCTime
, getCurrentTime
, defaultTimeLocale
, toGregorian
, fromGregorian
, formatTime
)
where
import Prelude hiding ( putStr
, putStrLn
, readFile
, writeFile
, lookup
, getContents
, null
, elem
, concat
, filter
, take
, drop
, lines
, words
, length
)
import qualified Prelude
import System.FilePath hiding ( (<.>), isValid )
import System.Directory
import qualified System.IO as IO
import System.IO (stderr, stdout, stdin, Handle)
import Data.Maybe
import Control.Monad
import Control.Applicative hiding ( empty )
import Text.Printf
import Data.Monoid hiding ( (<>), Any, First )
import Data.Char
import Control.Arrow
import Data.Foldable hiding (null, elem, concat, length)
import System.Environment
import Control.Concurrent.MVar
import Control.Concurrent.Chan
import Data.IORef
import Control.Monad.State
import Text.Casing
import qualified Data.Text as Text
import qualified Data.Text.IO as Text
import qualified Data.Text.Lazy
import qualified Data.Text.Lazy as LText
import qualified Data.Text.Lazy.IO as LText
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as LBS
import qualified Data.HashMap.Strict as HashMap
import qualified Data.HashMap.Lazy as LHashMap
import qualified Data.HashSet as HashSet
import qualified Data.ByteString.Base64 as Base64
import qualified Data.Vector as Vector
import Data.Vector (Vector)
import qualified Data.Set as Set
import Data.Set (Set)
import qualified Data.Map as Map
import Data.Map (Map)
import Data.Hashable (Hashable (..))
import Text.StringConvert
import Data.Typeable
import GHC.Generics
import GHC.Exts hiding (toList, Any)
import Data.Data
import Data.Semigroup
import Control.DeepSeq
import qualified Data.List as List
import Control.Lens
import Control.Lens.TH (makeLenses)
import Data.Aeson (ToJSON (..), FromJSON (..), Value, object)
import Data.Aeson.TH (deriveJSON)
import qualified Data.Aeson as JSON
import qualified Data.Aeson.TH as JSON
import Data.Default
import Control.Concurrent
import Control.Exception
import Data.Function
import Data.Time
import Language.Haskell.TH.Syntax (Name, Q, Dec)
type Text = Text.Text
type LText = LText.Text
type ByteString = BS.ByteString
type LByteString = LBS.ByteString
empty :: Monoid a => a
empty = mempty
append :: Monoid a => a -> a -> a
append = mappend
concat :: Monoid a => [a] -> a
concat = mconcat
lines :: (FromString a, ToString a) => a -> [a]
lines = map s . Prelude.lines . s
words :: (FromString a, ToString a) => a -> [a]
words = map s . Prelude.words . s
trim :: (FromString a, ToString a) => a -> a
trim = ltrim . rtrim
ltrim :: (FromString a, ToString a) => a -> a
ltrim = s . dropWhile isSpace . s
rtrim :: (FromString a, ToString a) => a -> a
rtrim = s . List.dropWhileEnd isSpace . s
type HashMap = HashMap.HashMap
newtype LHashMap k v = LHashMap { unLHashMap :: LHashMap.HashMap k v }
deriving (Read, Show, Typeable, Generic, Functor, Foldable, Traversable, Eq, Data, Semigroup, Monoid, NFData)
type HashSet = HashSet.HashSet
class StringIO a where
putStr :: a -> IO ()
putStrLn :: a -> IO ()
hPutStr :: Handle -> a -> IO ()
hPutStrLn :: Handle -> a -> IO ()
readFile :: FilePath -> IO a
writeFile :: FilePath -> a -> IO ()
getContents :: IO a
hGetContents :: Handle -> IO a
putStrLn str = putStr str >> putStr "\n"
hPutStrLn h str = hPutStr h str >> hPutStr h "\n"
instance StringIO String where
putStr = IO.putStr
putStrLn = IO.putStrLn
hPutStr = IO.hPutStr
hPutStrLn = IO.hPutStrLn
readFile = IO.readFile
writeFile = IO.writeFile
getContents = IO.getContents
hGetContents = IO.hGetContents
instance StringIO Text where
putStr = Text.putStr
putStrLn = Text.putStrLn
hPutStr = Text.hPutStr
hPutStrLn = Text.hPutStrLn
readFile = Text.readFile
writeFile = Text.writeFile
getContents = Text.getContents
hGetContents = Text.hGetContents
instance StringIO LText where
putStr = LText.putStr
putStrLn = LText.putStrLn
hPutStr = LText.hPutStr
hPutStrLn = LText.hPutStrLn
readFile = LText.readFile
writeFile = LText.writeFile
getContents = LText.getContents
hGetContents = LText.hGetContents
instance StringIO ByteString where
putStr = BS.putStr
hPutStr = BS.hPutStr
readFile = BS.readFile
writeFile = BS.writeFile
getContents = BS.getContents
hGetContents = BS.hGetContents
instance StringIO LByteString where
putStr = LBS.putStr
hPutStr = LBS.hPutStr
readFile = LBS.readFile
writeFile = LBS.writeFile
getContents = LBS.getContents
hGetContents = LBS.hGetContents
class Lookup m k | m -> k where
lookup :: k -> m v -> Maybe v
lookupDef :: v -> k -> m v -> v
lookupDef d k = fromMaybe d . lookup k
newtype AList k v = AList { unAList :: [(k, v)] }
deriving (Show, Read, Eq, Ord, Generic, Functor)
instance Eq k => Lookup (AList k) k where
lookup k = Prelude.lookup k . unAList
class ListLike m a | m -> a where
intersperse :: a -> m -> m
take :: Int -> m -> m
takeEnd :: Int -> m -> m
drop :: Int -> m -> m
dropEnd :: Int -> m -> m
slice :: Int -> Int -> m -> m
slice offset len = take len . drop offset
listLength :: m -> Int
takeEnd n x = drop (listLength x n) x
dropEnd n x = take (listLength x n) x
instance ListLike [a] a where
intersperse = List.intersperse
take = List.take
drop = List.drop
listLength = List.length
instance ListLike (Vector a) a where
intersperse e = Vector.fromList . List.intersperse e . Vector.toList
take = Vector.take
drop = Vector.drop
slice = Vector.slice
listLength = Vector.length
instance ListLike Text Char where
intersperse = Text.intersperse
take = Text.take . fromIntegral
drop = Text.drop . fromIntegral
listLength = fromIntegral . Text.length
instance ListLike LText Char where
intersperse = LText.intersperse
take = LText.take . fromIntegral
drop = LText.drop . fromIntegral
listLength = fromIntegral . LText.length
startsWith :: (Eq a, ListLike a e) => a -> a -> Bool
startsWith haystack needle =
take (listLength needle) haystack == needle
endsWith :: (Eq a, ListLike a e) => a -> a -> Bool
endsWith haystack needle =
takeEnd (listLength needle) haystack == needle
intercalate :: (Monoid a, Foldable m, ListLike (m a) a) => a -> m a -> a
intercalate s = mconcat . toList . intersperse s
class SetLike m v | m -> v where
conj :: v -> m -> m
remove :: v -> m -> m
nullSet :: m -> Bool
items :: m -> [v]
fromItems :: [v] -> m
singleton :: v -> m
size :: m -> Int
size = List.length . items
nullSet = List.null . items
class Filterable m where
filter :: (v -> Bool) -> m v -> m v
cull :: Filterable m => (v -> Bool) -> m v -> m v
cull = filter . (not .)
class DictLike m k where
insert :: k -> v -> m k v -> m k v
delete :: k -> m k v -> m k v
adjust :: k -> (v -> v) -> m k v -> m k v
pairs :: m k v -> [(k, v)]
fromPairs :: [(k, v)] -> m k v
keys :: m k v -> [k]
elems :: m k v -> [v]
singletonMap :: k -> v -> m k v
member :: k -> m k v -> Bool
keys = map fst . pairs
elems = map snd . pairs
instance Eq k => DictLike AList k where
insert k v (AList xs) = AList $ (k,v):xs
delete k (AList xs) = AList $ filter ((/= k) . fst) xs
adjust k f (AList xs) = AList [ (k', if k == k' then f v else v) | (k', v) <- xs ]
pairs = unAList
fromPairs = AList
singletonMap k v = AList [(k, v)]
member k = not . nullSet . filter (== k) . keys
instance Lookup [] Int where
lookup i xs = case drop i xs of
[] -> Nothing
(x:_) -> Just x
instance Lookup Vector Int where
lookup = flip (Vector.!?)
instance (Eq a) => SetLike (Vector a) a where
conj = Vector.cons
remove x = Vector.filter (/= x)
nullSet = Vector.null
items = Vector.toList
fromItems = Vector.fromList
singleton = Vector.singleton
size = Vector.length
instance Filterable Vector where
filter = Vector.filter
instance (Eq a) => SetLike [a] a where
conj = (:)
remove x = filter (/= x)
nullSet = List.null
items = id
fromItems = id
singleton = (:[])
size = List.length
instance Filterable [] where
filter = List.filter
instance (Eq v, Hashable v) => SetLike (HashSet v) v where
conj = HashSet.insert
remove = HashSet.delete
nullSet = HashSet.null
items = HashSet.toList
fromItems = HashSet.fromList
singleton = HashSet.singleton
size = HashSet.size
instance Filterable HashSet where
filter = HashSet.filter
instance (Eq v, Ord v) => SetLike (Set v) v where
conj = Set.insert
remove = Set.delete
nullSet = Set.null
items = Set.toList
fromItems = Set.fromList
singleton = Set.singleton
size = Set.size
instance Filterable Set where
filter = Set.filter
instance (Eq k, Hashable k) => Lookup (HashMap.HashMap k) k where
lookup = HashMap.lookup
instance (Eq k, Hashable k) => DictLike HashMap.HashMap k where
insert = HashMap.insert
delete = HashMap.delete
adjust = flip HashMap.adjust
pairs = HashMap.toList
fromPairs = HashMap.fromList
keys = HashMap.keys
elems = HashMap.elems
singletonMap = HashMap.singleton
member = HashMap.member
instance (Eq k, Hashable k) => SetLike (HashMap k v) (k, v) where
conj = uncurry insert
remove = delete . fst
nullSet = HashMap.null
items = pairs
fromItems = fromPairs
singleton = uncurry singletonMap
instance Filterable (HashMap k) where
filter = HashMap.filter
instance (Eq k, Ord k) => Lookup (Map.Map k) k where
lookup = Map.lookup
instance (Eq k, Ord k) => DictLike Map.Map k where
insert = Map.insert
delete = Map.delete
adjust = flip Map.adjust
pairs = Map.toList
fromPairs = Map.fromList
keys = Map.keys
elems = Map.elems
singletonMap = Map.singleton
member = Map.member
instance (Eq k, Ord k) => SetLike (Map k v) (k, v) where
conj = uncurry insert
remove = delete . fst
nullSet = Map.null
items = pairs
fromItems = fromPairs
singleton = uncurry singletonMap
instance Filterable (Map k) where
filter = Map.filter
overLHashMap :: (HashMap k v -> HashMap k v) -> LHashMap k v -> LHashMap k v
overLHashMap f = LHashMap . f . unLHashMap
instance (Eq k, Hashable k) => DictLike LHashMap k where
insert k v = overLHashMap $ LHashMap.insert k v
delete k = overLHashMap $ LHashMap.delete k
adjust k f = overLHashMap $ LHashMap.adjust f k
pairs = LHashMap.toList . unLHashMap
fromPairs = LHashMap . LHashMap.fromList
keys = LHashMap.keys . unLHashMap
elems = LHashMap.elems . unLHashMap
singletonMap k v = LHashMap (LHashMap.singleton k v)
member k = LHashMap.member k . unLHashMap
instance (Eq k, Hashable k) => Lookup (LHashMap k) k where
lookup k = LHashMap.lookup k . unLHashMap
instance (Eq k, Hashable k) => SetLike (LHashMap k v) (k, v) where
conj = uncurry insert
remove = delete . fst
nullSet = LHashMap.null . unLHashMap
items = pairs
fromItems = fromPairs
singleton = uncurry singletonMap
instance Filterable (LHashMap k) where
filter p = overLHashMap $ LHashMap.filter p
prettyJsonOptions :: JSON.Options
prettyJsonOptions =
JSON.defaultOptions
{ JSON.fieldLabelModifier = kebab . dropWhile (== '_')
, JSON.constructorTagModifier = kebab
, JSON.omitNothingFields = True
, JSON.sumEncoding = JSON.defaultTaggedObject
{ JSON.tagFieldName = "what"
, JSON.contentsFieldName = "value"
}
}
derivePrettyJSON :: Name -> Q [Dec]
derivePrettyJSON = deriveJSON prettyJsonOptions
asString :: String -> String
asString = id
asText :: Text -> Text
asText = id
asLText :: LText -> LText
asLText = id
asByteString :: ByteString -> ByteString
asByteString = id
asLByteString :: LByteString -> LByteString
asLByteString = id
asHashMap :: HashMap k v -> HashMap k v
asHashMap = id
encodeJSON :: ToJSON a => a -> LByteString
encodeJSON = JSON.encode
decodeJSON :: FromJSON a => LByteString -> Maybe a
decodeJSON = JSON.decode
encodeJSONStrict :: ToJSON a => a -> ByteString
encodeJSONStrict = s . JSON.encode
decodeJSONStrict :: FromJSON a => ByteString -> Maybe a
decodeJSONStrict = JSON.decodeStrict
chain :: Traversable t => t (a -> a) -> a -> a
chain = foldl' (.) id
(~>) :: ToJSON a => Text -> a -> (Text, Value)
(~>) = (JSON..=)
decodeBase64 :: ByteString -> ByteString
decodeBase64 = Base64.decodeLenient
encodeBase64 :: ByteString -> ByteString
encodeBase64 = Base64.encode