-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Prelude based on protolude for GHC 8 and beyond.
--   
--   A Prelude relpacement for GHC 8 with a focus on building applications
--   with Lenses, Machines, and Applicatives.
@package liblawless
@version 0.17.2


module ByteString

module Tree

module Text

module Set

-- | A set of values <tt>a</tt>.
data Set a :: * -> *

-- | <i>O(1)</i>. Create a singleton set.
singleton :: a -> Set a

module Parser


-- | Network type library
module Networking

module Map

-- | A Map from keys <tt>k</tt> to values <tt>a</tt>.
data Map k a :: * -> * -> *

-- | <i>O(1)</i>. A map with a single element.
--   
--   <pre>
--   singleton 1 'a'        == fromList [(1, 'a')]
--   size (singleton 1 'a') == 1
--   </pre>
singleton :: k -> a -> Map k a

module Machine

module Lawless


module Text.IO
readFile :: (MonadIO m) => AbsRelFile -> m Text
writeFile :: (MonadIO m) => AbsRelFile -> Text -> m ()
appendFile :: (MonadIO m) => AbsRelFile -> Text -> m ()
hGetLine :: (MonadIO m) => Handle -> m Text
hPutStr :: (MonadIO m) => Handle -> Text -> m ()
hPutStrLn :: (MonadIO m) => Handle -> Text -> m ()
getLine :: (MonadIO m) => m Text
putStr :: (MonadIO m) => Text -> m ()
putStrLn :: (MonadIO m) => Text -> m ()

module Textual.SepList
type SepList a = SepList' (NonEmpty a)
sepList :: forall a. (Ord a, Binary a, Printable a) => a -> SepList a
slItems :: Lens' (SepList' (NonEmpty a)) (NonEmpty a)
instance Data.Foldable.Foldable Textual.SepList.SepList'
instance GHC.Classes.Eq (Textual.SepList.SepList' (Data.List.NonEmpty.NonEmpty a))
instance GHC.Classes.Ord (Textual.SepList.SepList' (Data.List.NonEmpty.NonEmpty a))
instance Data.Semigroup.Semigroup (Textual.SepList.SepList' (Data.List.NonEmpty.NonEmpty a))
instance (GHC.Classes.Ord a, Data.Binary.Class.Binary a, Data.Textual.Printable a) => Data.Binary.Class.Binary (Textual.SepList.SepList' (Data.List.NonEmpty.NonEmpty a))
instance Data.Textual.Printable a => Data.Textual.Printable (Textual.SepList.SepList' (Data.List.NonEmpty.NonEmpty a))
instance Data.Textual.Printable a => GHC.Show.Show (Textual.SepList.SepList a)

module Textual

module Generics

module Time
data Time

-- | The class of types which can be parsed given a UNIX-style time format
--   string.
class ParseTime t

-- | Builds a time value from a parsed input string. If the input does not
--   include all the information needed to construct a complete value, any
--   missing parts should be taken from 1970-01-01 00:00:00 +0000 (which
--   was a Thursday). In the absence of <tt>%C</tt> or <tt>%Y</tt>, century
--   is 1969 - 2068.
buildTime :: TimeLocale -> [(Char, String)] -> Maybe t
class FormatTime t
formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> t -> String)
_Time :: Iso' Time UTCTime
day :: Lens' Time Day
time :: Lens' Time DiffTime
now :: IO Time
instance Data.Binary.Class.Binary Time.Time
instance Data.Textual.Printable Time.Time
instance GHC.Generics.Generic Time.Time
instance Data.Time.Format.FormatTime Time.Time
instance Data.Time.Format.Parse.ParseTime Time.Time
instance GHC.Classes.Ord Time.Time
instance GHC.Classes.Eq Time.Time
instance GHC.Show.Show Time.Time

module Exception

module Boomerang
type TextsBoomerang a b = Boomerang TextsError [Text] a b
(∘) :: forall (b :: k) (c :: k) (a :: k) (cat :: k -> k -> *). Category cat => cat b c -> cat a b -> cat a c
infix 9 ∘


module Arbitrary
instance Test.QuickCheck.Arbitrary.Arbitrary (Textual.SepList.SepList GHC.Types.Char)
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Text.Internal.Text
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Time.Calendar.Days.Day
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Time.Clock.Scale.DiffTime
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Time.Clock.UTC.UTCTime
instance Test.QuickCheck.Arbitrary.Arbitrary Time.Time

module Aeson
lawlessJSONOptions :: Options
lawlessToJSONEncoding :: forall a. (GToEncoding (Rep a), Generic a) => a -> Encoding
lawlessParseJSON :: forall a. (GFromJSON (Rep a), Generic a) => Value -> Parser a


module Path
toString :: (AbsRel ar, FileDir fd) => Path ar fd -> String
rootDir :: AbsDir
currentDir :: RelDir
emptyFile :: RelFile
parse :: (IsText t, AbsRel ar, FileDir fd) => t -> Either Text (Path ar fd)
toText :: (AbsRel ar, FileDir fd) => Path ar fd -> Text
type AbsFile = AbsFile System
type RelFile = RelFile System
type AbsDir = AbsDir System
type RelDir = RelDir System
type AbsRelFile = AbsRelFile System
type AbsRelDir = AbsRelDir System
absFile :: (IsText t) => t -> AbsFile
relFile :: (IsText t) => t -> RelFile
absDir :: (IsText t) => t -> AbsDir
relDir :: (IsText t) => t -> RelDir
absRelFile :: (IsText t) => t -> AbsRelFile
absRelDir :: (IsText t) => t -> AbsRelDir
(</>) :: DirPath os ar -> RelPath os fd -> Path os ar fd
(<.>) :: FilePath os ar -> String -> FilePath os ar
instance Data.Aeson.Types.Class.FromJSON System.Path.Posix.AbsFile
instance Data.Aeson.Types.Class.ToJSON System.Path.Posix.AbsFile
instance Data.Aeson.Types.Class.FromJSON System.Path.Posix.AbsDir
instance Data.Aeson.Types.Class.ToJSON System.Path.Posix.AbsDir
instance Data.Aeson.Types.Class.ToJSON System.Path.Posix.RelFile
instance Data.Aeson.Types.Class.FromJSON System.Path.Posix.RelDir
instance Data.Aeson.Types.Class.ToJSON System.Path.Posix.RelDir
instance Data.Aeson.Types.Class.FromJSON System.Path.Posix.AbsRelDir
instance Data.Aeson.Types.Class.ToJSON System.Path.Posix.AbsRelDir
instance Data.Aeson.Types.Class.FromJSON System.Path.Posix.AbsRelFile
instance Data.Aeson.Types.Class.ToJSON System.Path.Posix.AbsRelFile


module IO
putStr :: (MonadIO m, Printable p) => p -> m ()
putStrLn :: (MonadIO m, Printable p) => p -> m ()
managed :: (forall r. (a -> IO r) -> IO r) -> Managed a
data Managed a :: * -> *
class MonadIO m => MonadManaged (m :: * -> *)
using :: Managed a -> m a
runManaged :: Managed () -> IO ()
data TempFile
tfPath :: Lens' TempFile AbsFile
tfHandle :: Lens' TempFile Handle
tempFile :: AbsDir -> RelFile -> Managed TempFile

-- | Monads in which <a>IO</a> computations may be embedded. Any monad
--   built by applying a sequence of monad transformers to the <a>IO</a>
--   monad will be an instance of this class.
--   
--   Instances should satisfy the following laws, which state that
--   <a>liftIO</a> is a transformer of monads:
--   
--   <ul>
--   <li><pre><a>liftIO</a> . <a>return</a> = <a>return</a></pre></li>
--   <li><pre><a>liftIO</a> (m &gt;&gt;= f) = <a>liftIO</a> m &gt;&gt;=
--   (<a>liftIO</a> . f)</pre></li>
--   </ul>
class Monad m => MonadIO (m :: * -> *)

-- | Lift a computation from the <a>IO</a> monad.
liftIO :: IO a -> m a

-- | Lift a computation from the <a>IO</a> monad.
liftIO :: MonadIO m => forall a. IO a -> m a

-- | Computation <a>hSeek</a> <tt>hdl mode i</tt> sets the position of
--   handle <tt>hdl</tt> depending on <tt>mode</tt>. The offset <tt>i</tt>
--   is given in terms of 8-bit bytes.
--   
--   If <tt>hdl</tt> is block- or line-buffered, then seeking to a position
--   which is not in the current buffer will first cause any items in the
--   output buffer to be written to the device, and then cause the input
--   buffer to be discarded. Some handles may not be seekable (see
--   <a>hIsSeekable</a>), or only support a subset of the possible
--   positioning operations (for instance, it may only be possible to seek
--   to the end of a tape, or to a positive offset from the beginning or
--   current position). It is not possible to set a negative I/O position,
--   or for a physical file, an I/O position beyond the current
--   end-of-file.
--   
--   This operation may fail with:
--   
--   <ul>
--   <li><tt>isIllegalOperationError</tt> if the Handle is not seekable, or
--   does not support the requested seek mode.</li>
--   <li><tt>isPermissionError</tt> if a system resource limit would be
--   exceeded.</li>
--   </ul>
hSeek :: Handle -> SeekMode -> Integer -> IO ()

-- | A mode that determines the effect of <tt>hSeek</tt> <tt>hdl mode
--   i</tt>.
data SeekMode :: *

-- | the position of <tt>hdl</tt> is set to <tt>i</tt>.
AbsoluteSeek :: SeekMode

-- | the position of <tt>hdl</tt> is set to offset <tt>i</tt> from the
--   current position.
RelativeSeek :: SeekMode

-- | the position of <tt>hdl</tt> is set to offset <tt>i</tt> from the end
--   of the file.
SeekFromEnd :: SeekMode
file :: AbsRelFile -> IOMode -> Managed Handle