| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Quaalude
Contents
- Miscellaneous
- System.Process.Ext reëxports
- Data.Text.Lazy reëxports
- Control.Composition reëxports
- Dhall reëxports
- Shake reëxports
- Network.HTTP.Client.TLS reëxports
- System.FilePath reëxports
- ByteString reëxports
- Helpers for pretty-printing
- Text.PrettyPrint.ANSI.Leijen reëxports
Synopsis
- hex :: Int -> String
- bool :: a -> a -> Bool -> a
- intersperse :: a -> [a] -> [a]
- transpose :: [[a]] -> [[a]]
- sortBy :: (a -> a -> Ordering) -> [a] -> [a]
- void :: Functor f => f a -> f ()
- unless :: Applicative f => Bool -> f () -> f ()
- when :: Applicative f => Bool -> f () -> f ()
- join :: Monad m => m (m a) -> m a
- fold :: (Foldable t, Monoid m) => t m -> m
- zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
- zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
- encode :: Binary a => a -> ByteString
- decode :: Binary a => ByteString -> a
- fromMaybe :: a -> Maybe a -> a
- isNothing :: Maybe a -> Bool
- isPrefixOf :: Eq a => [a] -> [a] -> Bool
- isSuffixOf :: Eq a => [a] -> [a] -> Bool
- on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- (***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c')
- (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- ($>) :: Functor f => f a -> b -> f b
- first :: Arrow a => a b c -> a (b, d) (c, d)
- second :: Arrow a => a b c -> a (d, b) (d, c)
- getEnv :: String -> IO String
- exitWith :: ExitCode -> IO a
- showVersion :: Version -> String
- traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
- nubSpecial :: Ord a => [[a]] -> [[a]]
- (<>) :: Semigroup a => a -> a -> a
- data ExitCode = ExitSuccess
- class Monad m => MonadIO (m :: Type -> Type) where
- makeExe :: String
- shouldWrite :: (MonadIO m, Binary a) => a -> FilePath -> m Bool
- silentCreateProcess :: Verbosity -> CreateProcess -> IO ()
- data Text
- pack :: String -> Text
- unpack :: Text -> String
- biaxe :: (Traversable t, Applicative f) => t (a -> b -> f ()) -> a -> b -> f ()
- (.*) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
- (.**) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
- thread :: Foldable t => t (a -> a) -> a -> a
- bisequence' :: (Traversable t, Applicative f) => t (a -> b -> f c) -> a -> b -> t (f c)
- class FromDhall a
- class ToDhall a
- class Generic a
- class Binary t
- input :: Decoder a -> Text -> IO a
- auto :: FromDhall a => Decoder a
- detailed :: IO a -> IO a
- data Rules a
- data Action a
- command :: (Partial, CmdResult r) => [CmdOption] -> String -> [String] -> Action r
- command_ :: Partial -> [CmdOption] -> String -> [String] -> Action ()
- (%>) :: Located -> FilePattern -> (FilePath -> Action ()) -> Rules ()
- need :: Partial -> [FilePath] -> Action ()
- want :: Partial -> [FilePath] -> Rules ()
- shake :: ShakeOptions -> Rules () -> IO ()
- data Rebuild
- (~>) :: Located -> String -> Action () -> Rules ()
- cmd :: (Partial, CmdArguments args) => args :-> Action r
- cmd_ :: (Partial, CmdArguments args, Unit args) => args :-> Action ()
- data ShakeOptions = ShakeOptions {
- shakeFiles :: FilePath
- shakeThreads :: Int
- shakeVersion :: String
- shakeVerbosity :: Verbosity
- shakeStaunch :: Bool
- shakeReport :: [FilePath]
- shakeLint :: Maybe Lint
- shakeLintInside :: [FilePath]
- shakeLintIgnore :: [FilePattern]
- shakeLintWatch :: [FilePattern]
- shakeCommandOptions :: [CmdOption]
- shakeFlush :: Maybe Seconds
- shakeRebuild :: [(Rebuild, FilePattern)]
- shakeAbbreviations :: [(String, String)]
- shakeStorageLog :: Bool
- shakeLineBuffering :: Bool
- shakeTimings :: Bool
- shakeRunCommands :: Bool
- shakeChange :: Change
- shakeCreationCheck :: Bool
- shakeLiveFiles :: [FilePath]
- shakeVersionIgnore :: Bool
- shakeColor :: Bool
- shakeShare :: Maybe FilePath
- shakeCloud :: [String]
- shakeSymlink :: Bool
- shakeProgress :: IO Progress -> IO ()
- shakeOutput :: Verbosity -> String -> IO ()
- shakeTrace :: String -> String -> Bool -> IO ()
- shakeExtra :: HashMap TypeRep Dynamic
- shakeOptions :: ShakeOptions
- copyFile' :: Partial -> FilePath -> FilePath -> Action ()
- data Change
- data Verbosity
- removeFilesAfter :: FilePath -> [FilePattern] -> Action ()
- data Lint
- takeBaseName :: FilePath -> String
- takeFileName :: FilePath -> FilePath
- takeDirectory :: FilePath -> FilePath
- (-<.>) :: FilePath -> String -> FilePath
- makeExecutable :: FilePath -> IO ()
- tlsManagerSettings :: ManagerSettings
- newManager :: ManagerSettings -> IO Manager
- parseRequest :: MonadThrow m => String -> m Request
- httpLbs :: Request -> Manager -> IO (Response ByteString)
- data Response body
- data Request
- (</>) :: FilePath -> FilePath -> FilePath
- pathSeparator :: Char
- data ByteString
- (<#>) :: Doc -> Doc -> Doc
- (<+>) :: Doc -> Doc -> Doc
- text :: String -> Doc
- punctuate :: Doc -> [Doc] -> [Doc]
- dullred :: Doc -> Doc
- linebreak :: Doc
- dullyellow :: Doc -> Doc
- hardline :: Doc
- hang :: Int -> Doc -> Doc
- indent :: Int -> Doc -> Doc
- putDoc :: Doc -> IO ()
- class Pretty a where
- module System.Process
- module System.Directory
- type Lens' s a = Lens s s a a
- over :: ASetter s t a b -> (a -> b) -> s -> t
- _Just :: Traversal (Maybe a) (Maybe a') a a'
- view :: Getting a s a -> s -> a
- _1 :: Field1 s t a b => Lens s t a b
- _2 :: Field2 s t a b => Lens s t a b
- _4 :: Field4 s t a b => Lens s t a b
- each :: Each s t a b => Traversal s t a b
- (&) :: a -> (a -> b) -> b
- (%~) :: ASetter s t a b -> (a -> b) -> s -> t
Documentation
Case analysis for the Bool type. bool x y px
when p is False, and evaluates to y when p is True.
This is equivalent to if p then y else x; that is, one can
think of it as an if-then-else construct with its arguments
reordered.
Examples
Basic usage:
>>>bool "foo" "bar" True"bar">>>bool "foo" "bar" False"foo"
Confirm that bool x y pif p then y else x are
equivalent:
>>>let p = True; x = "bar"; y = "foo">>>bool x y p == if p then y else xTrue>>>let p = False>>>bool x y p == if p then y else xTrue
Since: base-4.7.0.0
intersperse :: a -> [a] -> [a] #
The intersperse function takes an element and a list and
`intersperses' that element between the elements of the list.
For example,
>>>intersperse ',' "abcde""a,b,c,d,e"
The transpose function transposes the rows and columns of its argument.
For example,
>>>transpose [[1,2,3],[4,5,6]][[1,4],[2,5],[3,6]]
If some of the rows are shorter than the following rows, their elements are skipped:
>>>transpose [[10,11],[20],[],[30,31,32]][[10,20,30],[11,31],[32]]
void :: Functor f => f a -> f () #
void valueIO action.
Examples
Replace the contents of a Maybe Int
>>>void NothingNothing>>>void (Just 3)Just ()
Replace the contents of an Either Int IntEither Int '()'
>>>void (Left 8675309)Left 8675309>>>void (Right 8675309)Right ()
Replace every element of a list with unit:
>>>void [1,2,3][(),(),()]
Replace the second element of a pair with unit:
>>>void (1,2)(1,())
Discard the result of an IO action:
>>>mapM print [1,2]1 2 [(),()]>>>void $ mapM print [1,2]1 2
unless :: Applicative f => Bool -> f () -> f () #
The reverse of when.
when :: Applicative f => Bool -> f () -> f () #
Conditional execution of Applicative expressions. For example,
when debug (putStrLn "Debugging")
will output the string Debugging if the Boolean value debug
is True, and otherwise do nothing.
join :: Monad m => m (m a) -> m a #
The join function is the conventional monad join operator. It
is used to remove one level of monadic structure, projecting its
bound argument into the outer level.
Examples
A common use of join is to run an IO computation returned from
an STM transaction, since STM transactions
can't perform IO directly. Recall that
atomically :: STM a -> IO a
is used to run STM transactions atomically. So, by
specializing the types of atomically and join to
atomically:: STM (IO b) -> IO (IO b)join:: IO (IO b) -> IO b
we can compose them as
join.atomically:: STM (IO b) -> IO b
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () #
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] #
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] #
This generalizes the list-based filter function.
encode :: Binary a => a -> ByteString #
Encode a value using binary serialisation to a lazy ByteString.
decode :: Binary a => ByteString -> a #
Decode a value from a lazy ByteString, reconstructing the original structure.
fromMaybe :: a -> Maybe a -> a #
The fromMaybe function takes a default value and and Maybe
value. If the Maybe is Nothing, it returns the default values;
otherwise, it returns the value contained in the Maybe.
Examples
Basic usage:
>>>fromMaybe "" (Just "Hello, World!")"Hello, World!"
>>>fromMaybe "" Nothing""
Read an integer from a string using readMaybe. If we fail to
parse an integer, we want to return 0 by default:
>>>import Text.Read ( readMaybe )>>>fromMaybe 0 (readMaybe "5")5>>>fromMaybe 0 (readMaybe "")0
isPrefixOf :: Eq a => [a] -> [a] -> Bool #
The isPrefixOf function takes two lists and returns True
iff the first list is a prefix of the second.
>>>"Hello" `isPrefixOf` "Hello World!"True
>>>"Hello" `isPrefixOf` "Wello Horld!"False
isSuffixOf :: Eq a => [a] -> [a] -> Bool #
The isSuffixOf function takes two lists and returns True iff
the first list is a suffix of the second. The second list must be
finite.
>>>"ld!" `isSuffixOf` "Hello World!"True
>>>"World" `isSuffixOf` "Hello World!"False
(***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c') infixr 3 #
Split the input between the two argument arrows and combine their output. Note that this is in general not a functor.
The default definition may be overridden with a more efficient version if desired.
(&&&) :: Arrow a => a b c -> a b c' -> a b (c, c') infixr 3 #
Fanout: send the input to both argument arrows and combine their output.
The default definition may be overridden with a more efficient version if desired.
($>) :: Functor f => f a -> b -> f b infixl 4 #
Flipped version of <$.
Examples
Replace the contents of a Maybe IntString:
>>>Nothing $> "foo"Nothing>>>Just 90210 $> "foo"Just "foo"
Replace the contents of an Either Int IntString, resulting in an Either Int String
>>>Left 8675309 $> "foo"Left 8675309>>>Right 8675309 $> "foo"Right "foo"
Replace each element of a list with a constant String:
>>>[1,2,3] $> "foo"["foo","foo","foo"]
Replace the second element of a pair with a constant String:
>>>(1,2) $> "foo"(1,"foo")
Since: base-4.7.0.0
first :: Arrow a => a b c -> a (b, d) (c, d) #
Send the first component of the input through the argument arrow, and copy the rest unchanged to the output.
second :: Arrow a => a b c -> a (d, b) (d, c) #
A mirror image of first.
The default definition may be overridden with a more efficient version if desired.
getEnv :: String -> IO String #
Computation getEnv var returns the value
of the environment variable var. For the inverse, the
setEnv function can be used.
This computation may fail with:
isDoesNotExistErrorif the environment variable does not exist.
exitWith :: ExitCode -> IO a #
Computation exitWith code throws ExitCode code.
Normally this terminates the program, returning code to the
program's caller.
On program termination, the standard Handles stdout and
stderr are flushed automatically; any other buffered Handles
need to be flushed manually, otherwise the buffered data will be
discarded.
A program that fails in any other way is treated as if it had
called exitFailure.
A program that terminates successfully without calling exitWith
explicitly is treated as if it had called exitWith ExitSuccess.
As an ExitCode is not an IOException, exitWith bypasses
the error handling in the IO monad and cannot be intercepted by
catch from the Prelude. However it is a SomeException, and can
be caught using the functions of Control.Exception. This means
that cleanup computations added with bracket
(from Control.Exception) are also executed properly on exitWith.
Note: in GHC, exitWith should be called from the main program
thread in order to exit the process. When called from another
thread, exitWith will throw an ExitException as normal, but the
exception will not cause the process itself to exit.
showVersion :: Version -> String #
Provides one possible concrete representation for Version. For
a version with versionBranch = [1,2,3] and versionTags
= ["tag1","tag2"], the output will be 1.2.3-tag1-tag2.
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f () #
Map each element of a structure to an action, evaluate these
actions from left to right, and ignore the results. For a version
that doesn't ignore the results see traverse.
nubSpecial :: Ord a => [[a]] -> [[a]] Source #
Defines the exit codes that a program can return.
Constructors
| ExitSuccess | indicates successful termination; |
Instances
| Eq ExitCode | |
| Ord ExitCode | |
Defined in GHC.IO.Exception | |
| Read ExitCode | |
| Show ExitCode | |
| Generic ExitCode | |
| Exception ExitCode | Since: base-4.1.0.0 |
Defined in GHC.IO.Exception Methods toException :: ExitCode -> SomeException # fromException :: SomeException -> Maybe ExitCode # displayException :: ExitCode -> String # | |
| CmdResult ExitCode | |
Defined in Development.Shake.Command | |
| type Rep ExitCode | |
Defined in GHC.IO.Exception | |
class Monad m => MonadIO (m :: Type -> Type) where #
Monads in which IO computations may be embedded.
Any monad built by applying a sequence of monad transformers to the
IO monad will be an instance of this class.
Instances should satisfy the following laws, which state that liftIO
is a transformer of monads:
Instances
| MonadIO IO | Since: base-4.9.0.0 |
Defined in Control.Monad.IO.Class | |
| MonadIO Q | |
Defined in Language.Haskell.TH.Syntax | |
| MonadIO Rules | |
Defined in Development.Shake.Internal.Core.Rules | |
| MonadIO Action | |
Defined in Development.Shake.Internal.Core.Types | |
| MonadIO m => MonadIO (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
| (Error e, MonadIO m) => MonadIO (ErrorT e m) | |
Defined in Control.Monad.Trans.Error | |
| MonadIO (RAW k v ro rw) | |
Defined in Development.Shake.Internal.Core.Monad | |
Miscellaneous
System.Process.Ext reëxports
silentCreateProcess :: Verbosity -> CreateProcess -> IO () Source #
Data.Text.Lazy reëxports
Instances
Control.Composition reëxports
biaxe :: (Traversable t, Applicative f) => t (a -> b -> f ()) -> a -> b -> f () #
bisequence' :: (Traversable t, Applicative f) => t (a -> b -> f c) -> a -> b -> t (f c) #
Dhall reëxports
Any value that implements FromDhall can be automatically decoded based on
the inferred return type of input
>>>input auto "[1, 2, 3]" :: IO (Vector Natural)[1,2,3]>>>input auto "toMap { a = False, b = True }" :: IO (Map Text Bool)fromList [("a",False),("b",True)]
This class auto-generates a default implementation for records that
implement Generic. This does not auto-generate an instance for recursive
types.
Instances
| FromDhall Bool | |
| FromDhall Double | |
| FromDhall Integer | |
| FromDhall Natural | |
| FromDhall () | |
Defined in Dhall Methods autoWith :: InterpretOptions -> Decoder () # | |
| FromDhall Scientific | |
Defined in Dhall Methods | |
| FromDhall Text | |
| FromDhall Text | |
| FromDhall Void | |
| FromDhall [Char] | |
| FromDhall a => FromDhall [a] | |
Defined in Dhall Methods autoWith :: InterpretOptions -> Decoder [a] # | |
| FromDhall a => FromDhall (Maybe a) | |
| FromDhall a => FromDhall (Seq a) | |
| (FromDhall a, Ord a, Show a) => FromDhall (Set a) | Note that this instance will throw errors in the presence of duplicates in
the list. To ignore duplicates, use |
| (Functor f, FromDhall (f (Result f))) => FromDhall (Fix f) | You can use this instance to marshal recursive types from Dhall to Haskell. Here is an example use of this instance: {-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TemplateHaskell #-}
import Data.Fix (Fix(..))
import Data.Text (Text)
import Dhall (FromDhall)
import GHC.Generics (Generic)
import Numeric.Natural (Natural)
import qualified Data.Fix as Fix
import qualified Data.Functor.Foldable as Foldable
import qualified Data.Functor.Foldable.TH as TH
import qualified Dhall
import qualified NeatInterpolation
data Expr
= Lit Natural
| Add Expr Expr
| Mul Expr Expr
deriving (Show)
TH.makeBaseFunctor ''Expr
deriving instance Generic (ExprF a)
deriving instance FromDhall a => FromDhall (ExprF a)
example :: Text
example = [NeatInterpolation.text|
\(Expr : Type)
-> let ExprF =
< LitF :
{ _1 : Natural }
| AddF :
{ _1 : Expr, _2 : Expr }
| MulF :
{ _1 : Expr, _2 : Expr }
>
in \(Fix : ExprF -> Expr)
-> let Lit = \(x : Natural) -> Fix (ExprF.LitF { _1 = x })
let Add =
\(x : Expr)
-> \(y : Expr)
-> Fix (ExprF.AddF { _1 = x, _2 = y })
let Mul =
\(x : Expr)
-> \(y : Expr)
-> Fix (ExprF.MulF { _1 = x, _2 = y })
in Add (Mul (Lit 3) (Lit 7)) (Add (Lit 1) (Lit 2))
|]
convert :: Fix ExprF -> Expr
convert = Fix.cata Foldable.embed
main :: IO ()
main = do
x <- Dhall.input Dhall.auto example :: IO (Fix ExprF)
print (convert x :: Expr) |
| FromDhall (f (Result f)) => FromDhall (Result f) | |
Defined in Dhall Methods autoWith :: InterpretOptions -> Decoder (Result f) # | |
| FromDhall a => FromDhall (Vector a) | |
| (FromDhall a, Hashable a, Ord a, Show a) => FromDhall (HashSet a) | Note that this instance will throw errors in the presence of duplicates in
the list. To ignore duplicates, use |
| (ToDhall a, FromDhall b) => FromDhall (a -> b) | |
Defined in Dhall Methods autoWith :: InterpretOptions -> Decoder (a -> b) # | |
| (FromDhall a, FromDhall b) => FromDhall (a, b) | |
Defined in Dhall Methods autoWith :: InterpretOptions -> Decoder (a, b) # | |
| (Eq k, Hashable k, FromDhall k, FromDhall v) => FromDhall (HashMap k v) | |
| (Ord k, FromDhall k, FromDhall v) => FromDhall (Map k v) | |
This class is used by FromDhall instance for functions:
instance (ToDhall a, FromDhall b) => FromDhall (a -> b)
You can convert Dhall functions with "simple" inputs (i.e. instances of this class) into Haskell functions. This works by:
- Marshaling the input to the Haskell function into a Dhall expression (i.e.
x :: Expr Src Void) - Applying the Dhall function (i.e.
f :: Expr Src Void) to the Dhall input (i.e.App f x) - Normalizing the syntax tree (i.e.
normalize (App f x)) - Marshaling the resulting Dhall expression back into a Haskell value
Instances
| ToDhall Bool | |
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder Bool # | |
| ToDhall Double | |
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder Double # | |
| ToDhall Int | |
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder Int # | |
| ToDhall Integer | |
Defined in Dhall Methods | |
| ToDhall Natural | |
Defined in Dhall Methods | |
| ToDhall Word |
|
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder Word # | |
| ToDhall Word8 |
|
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder Word8 # | |
| ToDhall Word16 |
|
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder Word16 # | |
| ToDhall Word32 |
|
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder Word32 # | |
| ToDhall Word64 |
|
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder Word64 # | |
| ToDhall () | |
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder () # | |
| ToDhall Scientific | |
Defined in Dhall Methods | |
| ToDhall Text | |
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder Text # | |
| ToDhall String | |
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder String # | |
| ToDhall Text | |
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder Text # | |
| ToDhall Void | |
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder Void # | |
| ToDhall a => ToDhall [a] | |
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder [a] # | |
| ToDhall a => ToDhall (Maybe a) | |
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder (Maybe a) # | |
| ToDhall a => ToDhall (Seq a) | |
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder (Seq a) # | |
| ToDhall a => ToDhall (Set a) | Note that the ouput list will be sorted
|
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder (Set a) # | |
| ToDhall a => ToDhall (Vector a) | |
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder (Vector a) # | |
| ToDhall a => ToDhall (HashSet a) | Note that the ouput list may not be sorted
|
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder (HashSet a) # | |
| (ToDhall a, ToDhall b) => ToDhall (a, b) | |
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder (a, b) # | |
| (ToDhall k, ToDhall v) => ToDhall (HashMap k v) | Embed a
|
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder (HashMap k v) # | |
| (ToDhall k, ToDhall v) => ToDhall (Map k v) | Embed a
|
Defined in Dhall Methods injectWith :: InterpretOptions -> Encoder (Map k v) # | |
Representable types of kind *.
This class is derivable in GHC with the DeriveGeneric flag on.
A Generic instance must satisfy the following laws:
from.to≡idto.from≡id
Instances
The Binary class provides put and get, methods to encode and
decode a Haskell value to a lazy ByteString. It mirrors the Read and
Show classes for textual representation of Haskell types, and is
suitable for serialising Haskell values to disk, over the network.
For decoding and generating simple external binary formats (e.g. C
structures), Binary may be used, but in general is not suitable
for complex protocols. Instead use the PutM and Get primitives
directly.
Instances of Binary should satisfy the following property:
decode . encode == id
That is, the get and put methods should be the inverse of each
other. A range of instances are provided for basic Haskell types.
Instances
Arguments
| :: Decoder a | The decoder for the Dhall value |
| -> Text | The Dhall program |
| -> IO a | The decoded value in Haskell |
Type-check and evaluate a Dhall program, decoding the result into Haskell
The first argument determines the type of value that you decode:
>>>input integer "+2"2>>>input (vector double) "[1.0, 2.0]"[1.0,2.0]
Use auto to automatically select which type to decode based on the
inferred return type:
>>>input auto "True" :: IO BoolTrue
This uses the settings from defaultInputSettings.
auto :: FromDhall a => Decoder a #
Use the default options for interpreting a configuration file
auto = autoWith defaultInterpretOptions
Use this to provide more detailed error messages
> input auto "True" :: IO Integer *** Exception: Error: Expression doesn't match annotation True : Integer (input):1:1
> detailed (input auto "True") :: IO Integer
*** Exception: Error: Expression doesn't match annotation
Explanation: You can annotate an expression with its type or kind using the
❰:❱ symbol, like this:
┌───────┐
│ x : t │ ❰x❱ is an expression and ❰t❱ is the annotated type or kind of ❰x❱
└───────┘
The type checker verifies that the expression's type or kind matches the
provided annotation
For example, all of the following are valid annotations that the type checker
accepts:
┌─────────────┐
│ 1 : Natural │ ❰1❱ is an expression that has type ❰Natural❱, so the type
└─────────────┘ checker accepts the annotation
┌───────────────────────┐
│ Natural/even 2 : Bool │ ❰Natural/even 2❱ has type ❰Bool❱, so the type
└───────────────────────┘ checker accepts the annotation
┌────────────────────┐
│ List : Type → Type │ ❰List❱ is an expression that has kind ❰Type → Type❱,
└────────────────────┘ so the type checker accepts the annotation
┌──────────────────┐
│ List Text : Type │ ❰List Text❱ is an expression that has kind ❰Type❱, so
└──────────────────┘ the type checker accepts the annotation
However, the following annotations are not valid and the type checker will
reject them:
┌──────────┐
│ 1 : Text │ The type checker rejects this because ❰1❱ does not have type
└──────────┘ ❰Text❱
┌─────────────┐
│ List : Type │ ❰List❱ does not have kind ❰Type❱
└─────────────┘
You or the interpreter annotated this expression:
↳ True
... with this type or kind:
↳ Integer
... but the inferred type or kind of the expression is actually:
↳ Bool
Some common reasons why you might get this error:
● The Haskell Dhall interpreter implicitly inserts a top-level annotation
matching the expected type
For example, if you run the following Haskell code:
┌───────────────────────────────┐
│ >>> input auto "1" :: IO Text │
└───────────────────────────────┘
... then the interpreter will actually type check the following annotated
expression:
┌──────────┐
│ 1 : Text │
└──────────┘
... and then type-checking will fail
────────────────────────────────────────────────────────────────────────────────
True : Integer
(input):1:1Shake reëxports
Define a set of rules. Rules can be created with calls to functions such as %> or action.
Rules are combined with either the Monoid instance, or (more commonly) the Monad instance and do notation.
To define your own custom types of rule, see Development.Shake.Rule.
Instances
| Monad Rules | |
| Functor Rules | |
| MonadFix Rules | |
Defined in Development.Shake.Internal.Core.Rules | |
| MonadFail Rules | |
Defined in Development.Shake.Internal.Core.Rules | |
| Applicative Rules | |
| MonadIO Rules | |
Defined in Development.Shake.Internal.Core.Rules | |
| Semigroup a => Semigroup (Rules a) | |
| (Semigroup a, Monoid a) => Monoid (Rules a) | |
The Action monad, use liftIO to raise IO actions into it, and need to execute files.
Action values are used by addUserRule and action. The Action monad tracks the dependencies of a rule.
To raise an exception call error, MonadFail or liftIO . throwIO
Instances
| Monad Action | |
| Functor Action | |
| MonadFail Action | |
Defined in Development.Shake.Internal.Core.Types | |
| Applicative Action | |
| MonadIO Action | |
Defined in Development.Shake.Internal.Core.Types | |
| MonadTempDir Action | |
Defined in Development.Shake.Command Methods runWithTempDir :: (FilePath -> Action a) -> Action a | |
| Semigroup a => Semigroup (Action a) | |
| Monoid a => Monoid (Action a) | |
| CmdResult r => CmdArguments (Action r) | |
Defined in Development.Shake.Command Methods cmdArguments :: CmdArgument -> Action r # | |
command :: (Partial, CmdResult r) => [CmdOption] -> String -> [String] -> Action r #
Execute a system command. Before running command make sure you need any files
that are used by the command.
This function takes a list of options (often just [], see CmdOption for the available
options), the name of the executable (either a full name, or a program on the $PATH) and
a list of arguments. The result is often (), but can be a tuple containg any of Stdout,
Stderr and Exit. Some examples:
command_[] "gcc" ["-c","myfile.c"] -- compile a file, throwing an exception on failureExitc <-command[] "gcc" ["-c",myfile] -- run a command, recording the exit code (Exitc,Stderrerr) <-command[] "gcc" ["-c","myfile.c"] -- run a command, recording the exit code and error outputStdoutout <-command[] "gcc" ["-MM","myfile.c"] -- run a command, recording the outputcommand_[Cwd"generated"] "gcc" ["-c",myfile] -- run a command in a directory
Unless you retrieve the ExitCode using Exit, any ExitFailure will throw an error, including
the Stderr in the exception message. If you capture the Stdout or Stderr, that stream will not be echoed to the console,
unless you use the option EchoStdout or EchoStderr.
If you use command inside a do block and do not use the result, you may get a compile-time error about being
unable to deduce CmdResult. To avoid this error, use command_.
By default the stderr stream will be captured for use in error messages, and also echoed. To only echo
pass WithStderr Falsegcc)
to detect they are running in a terminal.
(%>) :: Located -> FilePattern -> (FilePath -> Action ()) -> Rules () infix 1 #
Define a rule that matches a FilePattern, see ?== for the pattern rules.
Patterns with no wildcards have higher priority than those with wildcards, and no file
required by the system may be matched by more than one pattern at the same priority
(see priority and alternatives to modify this behaviour).
This function will create the directory for the result file, if necessary.
"*.asm.o"%>\out -> do let src =dropExtensionoutneed[src]cmd"as" [src] "-o" [out]
To define a build system for multiple compiled languages, we recommend using .asm.o,
.cpp.o, .hs.o, to indicate which language produces an object file.
I.e., the file foo.cpp produces object file foo.cpp.o.
Note that matching is case-sensitive, even on Windows.
If the Action completes successfully the file is considered up-to-date, even if the file
has not changed.
need :: Partial -> [FilePath] -> Action () #
Add a dependency on the file arguments, ensuring they are built before continuing.
The file arguments may be built in parallel, in any order. This function is particularly
necessary when calling cmd or command. As an example:
"//*.rot13"%>\out -> do let src =dropExtensionoutneed[src]cmd"rot13" [src] "-o" [out]
Usually need [foo,bar] is preferable to need [foo] >> need [bar] as the former allows greater
parallelism, while the latter requires foo to finish building before starting to build bar.
This function should not be called with wildcards (e.g. *.txt - use getDirectoryFiles to expand them),
environment variables (e.g. $HOME - use getEnv to expand them) or directories (directories cannot be
tracked directly - track files within the directory instead).
want :: Partial -> [FilePath] -> Rules () #
Require that the argument files are built by the rules, used to specify the target.
main =shakeshakeOptions$ dowant["Main.exe"] ...
This program will build Main.exe, given sufficient rules. All arguments to all want calls
may be built in parallel, in any order.
This function is defined in terms of action and need, use action if you need more complex
targets than want allows.
shake :: ShakeOptions -> Rules () -> IO () #
Main entry point for running Shake build systems. For an example see the top of the module Development.Shake.
Use ShakeOptions to specify how the system runs, and Rules to specify what to build. The function will throw
an exception if the build fails.
To use command line flags to modify ShakeOptions see shakeArgs.
The current assumptions made by the build system, used by shakeRebuild. These options
allow the end user to specify that any rules run are either to be treated as clean, or as
dirty, regardless of what the build system thinks.
These assumptions only operate on files reached by the current action commands. Any
other files in the database are left unchanged.
Constructors
| RebuildNow | Assume these files are dirty and require rebuilding. for benchmarking rebuild speed and for rebuilding if untracked dependencies have changed. This flag is safe, but may cause more rebuilding than necessary. |
| RebuildNormal | Useful to reset the rebuild status to how it was before, equivalent to passing no |
| RebuildLater | This assumption is unsafe, and may lead to incorrect build results in this run. Assume these files are clean in this run, but test them normally in future runs. |
Instances
| Bounded Rebuild | |
| Enum Rebuild | |
| Eq Rebuild | |
| Data Rebuild | |
Defined in Development.Shake.Internal.Options Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rebuild -> c Rebuild # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Rebuild # toConstr :: Rebuild -> Constr # dataTypeOf :: Rebuild -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Rebuild) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rebuild) # gmapT :: (forall b. Data b => b -> b) -> Rebuild -> Rebuild # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rebuild -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rebuild -> r # gmapQ :: (forall d. Data d => d -> u) -> Rebuild -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Rebuild -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rebuild -> m Rebuild # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rebuild -> m Rebuild # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rebuild -> m Rebuild # | |
| Ord Rebuild | |
Defined in Development.Shake.Internal.Options | |
| Read Rebuild | |
| Show Rebuild | |
(~>) :: Located -> String -> Action () -> Rules () infix 1 #
Infix operator alias for phony, for sake of consistency with normal
rules.
cmd :: (Partial, CmdArguments args) => args :-> Action r #
Execute a system command. Before running cmd make sure you need any files
that are used by the command.
Stringarguments are treated as a list of whitespace separated arguments.[String]arguments are treated as a list of literal arguments.CmdOptionarguments are used as options.
Typically only string literals should be passed as String arguments. When using variables
prefer [myvar] so that if myvar contains spaces they are properly escaped.
As some examples, here are some calls, and the resulting command string:
cmd_"git log --pretty=" "oneline" -- git log --pretty= onelinecmd_"git log --pretty=" ["oneline"] -- git log --pretty= onelinecmd_"git log" ("--pretty=" ++ "oneline") -- git log --pretty=onelinecmd_"git log" ("--pretty=" ++ "one line") -- git log --pretty=one linecmd_"git log" ["--pretty=" ++ "one line"] -- git log "--pretty=one line"
More examples, including return values, see this translation of the examples given for the command function:
cmd_"gcc -c myfile.c" -- compile a file, throwing an exception on failureExitc <-cmd"gcc -c" [myfile] -- run a command, recording the exit code (Exitc,Stderrerr) <-cmd"gcc -c myfile.c" -- run a command, recording the exit code and error outputStdoutout <-cmd"gcc -MM myfile.c" -- run a command, recording the outputcmd(Cwd"generated") "gcc -c" [myfile] ::Action() -- run a command in a directory
If you use cmd inside a do block and do not use the result, you may get a compile-time error about being
unable to deduce CmdResult. To avoid this error, use cmd_. If you enable OverloadedStrings or OverloadedLists
you may have to give type signatures to the arguments, or use the more constrained command instead.
The cmd function can also be run in the IO monad, but then Traced is ignored and command lines are not echoed.
As an example:
cmd(Cwd"generated")Shell"gcc -c myfile.c" :: IO ()
data ShakeOptions #
Options to control the execution of Shake, usually specified by overriding fields in
shakeOptions:
shakeOptions{shakeThreads=4,shakeReport=["report.html"]}
The Data instance for this type reports the shakeProgress and shakeOutput fields as having the abstract type Hidden,
because Data cannot be defined for functions or TypeReps.
Constructors
| ShakeOptions | |
Fields
| |
Instances
| Data ShakeOptions | |
Defined in Development.Shake.Internal.Options Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ShakeOptions -> c ShakeOptions # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ShakeOptions # toConstr :: ShakeOptions -> Constr # dataTypeOf :: ShakeOptions -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ShakeOptions) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ShakeOptions) # gmapT :: (forall b. Data b => b -> b) -> ShakeOptions -> ShakeOptions # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ShakeOptions -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ShakeOptions -> r # gmapQ :: (forall d. Data d => d -> u) -> ShakeOptions -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ShakeOptions -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ShakeOptions -> m ShakeOptions # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ShakeOptions -> m ShakeOptions # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ShakeOptions -> m ShakeOptions # | |
| Show ShakeOptions | |
Defined in Development.Shake.Internal.Options Methods showsPrec :: Int -> ShakeOptions -> ShowS # show :: ShakeOptions -> String # showList :: [ShakeOptions] -> ShowS # | |
shakeOptions :: ShakeOptions #
The default set of ShakeOptions.
copyFile' :: Partial -> FilePath -> FilePath -> Action () #
copyFile' old new copies the existing file from old to new.
The old file will be tracked as a dependency.
Also creates the new directory if necessary.
How should you determine if a file has changed, used by shakeChange. The most common values are
ChangeModtime (the default, very fast, touch causes files to rebuild) and ChangeModtimeAndDigestInput
(slightly slower, touch and switching git branches does not cause input files to rebuild).
Constructors
| ChangeModtime | Compare equality of modification timestamps, a file has changed if its last modified time changes.
A |
| ChangeDigest | Compare equality of file contents digests, a file has changed if its digest changes.
A |
| ChangeModtimeAndDigest | A file is rebuilt if both its modification time and digest have changed. For efficiency reasons, the modification time is checked first, and if that has changed, the digest is checked. |
| ChangeModtimeAndDigestInput | Use |
| ChangeModtimeOrDigest | A file is rebuilt if either its modification time or its digest has changed. A |
Instances
| Bounded Change | |
| Enum Change | |
Defined in Development.Shake.Internal.Options | |
| Eq Change | |
| Data Change | |
Defined in Development.Shake.Internal.Options Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Change -> c Change # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Change # toConstr :: Change -> Constr # dataTypeOf :: Change -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Change) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Change) # gmapT :: (forall b. Data b => b -> b) -> Change -> Change # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Change -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Change -> r # gmapQ :: (forall d. Data d => d -> u) -> Change -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Change -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Change -> m Change # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Change -> m Change # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Change -> m Change # | |
| Ord Change | |
| Read Change | |
| Show Change | |
The verbosity data type, used by shakeVerbosity.
Constructors
| Silent | Don't print any messages. |
| Error | Only print error messages. |
| Warn | Print errors and warnings. |
| Info | Print errors, warnings and |
| Verbose | Print errors, warnings, full command lines when running a |
| Diagnostic | Print messages for virtually everything (mostly for debugging). |
Instances
removeFilesAfter :: FilePath -> [FilePattern] -> Action () #
Remove files, like removeFiles, but executed after the build completes successfully using runAfter.
Useful for implementing clean actions that delete files Shake may have open for building, e.g. shakeFiles.
Where possible, delete the files as a normal part of the build, e.g. using liftIO $ removeFiles dir pats
Which lint checks to perform, used by shakeLint.
Constructors
| LintBasic | The most basic form of linting. Checks that the current directory does not change and that results do not change after they
are first written. Any calls to |
| LintFSATrace | Track which files are accessed by command line programs using fsatrace. |
Instances
| Bounded Lint | |
| Enum Lint | |
Defined in Development.Shake.Internal.Options | |
| Eq Lint | |
| Data Lint | |
Defined in Development.Shake.Internal.Options Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Lint -> c Lint # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Lint # dataTypeOf :: Lint -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Lint) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lint) # gmapT :: (forall b. Data b => b -> b) -> Lint -> Lint # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lint -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lint -> r # gmapQ :: (forall d. Data d => d -> u) -> Lint -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Lint -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Lint -> m Lint # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Lint -> m Lint # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Lint -> m Lint # | |
| Ord Lint | |
| Read Lint | |
| Show Lint | |
takeBaseName :: FilePath -> String #
Get the base name, without an extension or path.
takeBaseName "/directory/file.ext" == "file" takeBaseName "file/test.txt" == "test" takeBaseName "dave.ext" == "dave" takeBaseName "" == "" takeBaseName "test" == "test" takeBaseName (addTrailingPathSeparator x) == "" takeBaseName "file/file.tar.gz" == "file.tar"
takeFileName :: FilePath -> FilePath #
Get the file name.
takeFileName "/directory/file.ext" == "file.ext" takeFileName "test/" == "" takeFileName x `isSuffixOf` x takeFileName x == snd (splitFileName x) Valid x => takeFileName (replaceFileName x "fred") == "fred" Valid x => takeFileName (x </> "fred") == "fred" Valid x => isRelative (takeFileName x)
takeDirectory :: FilePath -> FilePath #
Get the directory name, move up one level.
takeDirectory "/directory/other.ext" == "/directory"
takeDirectory x `isPrefixOf` x || takeDirectory x == "."
takeDirectory "foo" == "."
takeDirectory "/" == "/"
takeDirectory "/foo" == "/"
takeDirectory "/foo/bar/baz" == "/foo/bar"
takeDirectory "/foo/bar/baz/" == "/foo/bar/baz"
takeDirectory "foo/bar/baz" == "foo/bar"
Windows: takeDirectory "foo\\bar" == "foo"
Windows: takeDirectory "foo\\bar\\\\" == "foo\\bar"
Windows: takeDirectory "C:\\" == "C:\\"(-<.>) :: FilePath -> String -> FilePath infixr 7 #
Remove the current extension and add another, equivalent to replaceExtension.
"/directory/path.txt" -<.> "ext" == "/directory/path.ext" "/directory/path.txt" -<.> ".ext" == "/directory/path.ext" "foo.o" -<.> "c" == "foo.c"
makeExecutable :: FilePath -> IO () Source #
Network.HTTP.Client.TLS reëxports
tlsManagerSettings :: ManagerSettings #
Default TLS-enabled manager settings
newManager :: ManagerSettings -> IO Manager #
Create a Manager. The Manager will be shut down automatically via
garbage collection.
Creating a new Manager is a relatively expensive operation, you are
advised to share a single Manager between requests instead.
The first argument to this function is often defaultManagerSettings,
though add-on libraries may provide a recommended replacement.
Since 0.1.0
parseRequest :: MonadThrow m => String -> m Request #
Convert a URL into a Request.
This function defaults some of the values in Request, such as setting method to
GET and requestHeaders to [].
Since this function uses MonadThrow, the return monad can be anything that is
an instance of MonadThrow, such as IO or Maybe.
You can place the request method at the beginning of the URL separated by a space, e.g.:
@@
parseRequest "POST http://httpbin.org/post"
@@
Note that the request method must be provided as all capital letters.
A Request created by this function won't cause exceptions on non-2XX
response status codes.
To create a request which throws on non-2XX status codes, see parseUrlThrow
Since: http-client-0.4.30
httpLbs :: Request -> Manager -> IO (Response ByteString) #
A convenience wrapper around withResponse which reads in the entire
response body and immediately closes the connection. Note that this function
performs fully strict I/O, and only uses a lazy ByteString in its response
for memory efficiency. If you are anticipating a large response body, you
are encouraged to use withResponse and brRead instead.
Since 0.1.0
A simple representation of the HTTP response.
Since 0.1.0
Instances
| Functor Response | |
| Foldable Response | |
Defined in Network.HTTP.Client.Types Methods fold :: Monoid m => Response m -> m # foldMap :: Monoid m => (a -> m) -> Response a -> m # foldr :: (a -> b -> b) -> b -> Response a -> b # foldr' :: (a -> b -> b) -> b -> Response a -> b # foldl :: (b -> a -> b) -> b -> Response a -> b # foldl' :: (b -> a -> b) -> b -> Response a -> b # foldr1 :: (a -> a -> a) -> Response a -> a # foldl1 :: (a -> a -> a) -> Response a -> a # elem :: Eq a => a -> Response a -> Bool # maximum :: Ord a => Response a -> a # minimum :: Ord a => Response a -> a # | |
| Traversable Response | |
Defined in Network.HTTP.Client.Types | |
| Eq body => Eq (Response body) | |
| Show body => Show (Response body) | |
All information on how to connect to a host and what should be sent in the HTTP request.
If you simply wish to download from a URL, see parseRequest.
The constructor for this data type is not exposed. Instead, you should use
either the defaultRequest value, or parseRequest to
construct from a URL, and then use the records below to make modifications.
This approach allows http-client to add configuration options without
breaking backwards compatibility.
For example, to construct a POST request, you could do something like:
initReq <- parseRequest "http://www.example.com/path"
let req = initReq
{ method = "POST"
}For more information, please see http://www.yesodweb.com/book/settings-types.
Since 0.1.0
System.FilePath reëxports
(</>) :: FilePath -> FilePath -> FilePath infixr 5 #
Combine two paths with a path separator.
If the second path starts with a path separator or a drive letter, then it returns the second.
The intention is that readFile (dir will access the same file as
</> file)setCurrentDirectory dir; readFile file.
Posix: "/directory" </> "file.ext" == "/directory/file.ext"
Windows: "/directory" </> "file.ext" == "/directory\\file.ext"
"directory" </> "/file.ext" == "/file.ext"
Valid x => (takeDirectory x </> takeFileName x) `equalFilePath` xCombined:
Posix: "/" </> "test" == "/test" Posix: "home" </> "bob" == "home/bob" Posix: "x:" </> "foo" == "x:/foo" Windows: "C:\\foo" </> "bar" == "C:\\foo\\bar" Windows: "home" </> "bob" == "home\\bob"
Not combined:
Posix: "home" </> "/bob" == "/bob" Windows: "home" </> "C:\\bob" == "C:\\bob"
Not combined (tricky):
On Windows, if a filepath starts with a single slash, it is relative to the
root of the current drive. In [1], this is (confusingly) referred to as an
absolute path.
The current behavior of </> is to never combine these forms.
Windows: "home" </> "/bob" == "/bob" Windows: "home" </> "\\bob" == "\\bob" Windows: "C:\\home" </> "\\bob" == "\\bob"
On Windows, from [1]: "If a file name begins with only a disk designator
but not the backslash after the colon, it is interpreted as a relative path
to the current directory on the drive with the specified letter."
The current behavior of </> is to never combine these forms.
Windows: "D:\\foo" </> "C:bar" == "C:bar" Windows: "C:\\foo" </> "C:bar" == "C:bar"
pathSeparator :: Char #
The character that separates directories. In the case where more than
one character is possible, pathSeparator is the 'ideal' one.
Windows: pathSeparator == '\\' Posix: pathSeparator == '/' isPathSeparator pathSeparator
ByteString reëxports
data ByteString #
A space-efficient representation of a Word8 vector, supporting many
efficient operations.
A lazy ByteString contains 8-bit bytes, or by using the operations
from Data.ByteString.Lazy.Char8 it can be interpreted as containing
8-bit characters.
Instances
Helpers for pretty-printing
(<#>) :: Doc -> Doc -> Doc infixr 5 Source #
Same as Text.PrettyPrint.ANSI.Leijen's $, but doesn't clash with the
prelude.
Text.PrettyPrint.ANSI.Leijen reëxports
(<+>) :: Doc -> Doc -> Doc infixr 6 #
The document (x <+> y) concatenates document x and y with a
space in between. (infixr 6)
The document (text s) contains the literal string s. The
string shouldn't contain any newline ('\n') characters. If the
string contains newline characters, the function string should be
used.
punctuate :: Doc -> [Doc] -> [Doc] #
(punctuate p xs) concatenates all documents in xs with
document p except for the last document.
someText = map text ["words","in","a","tuple"] test = parens (align (cat (punctuate comma someText)))
This is layed out on a page width of 20 as:
(words,in,a,tuple)
But when the page width is 15, it is layed out as:
(words, in, a, tuple)
(If you want put the commas in front of their elements instead of
at the end, you should use tupled or, in general, encloseSep.)
dullyellow :: Doc -> Doc #
Displays a document with the dull yellow forecolor
The hang combinator implements hanging indentation. The document
(hang i x) renders document x with a nesting level set to the
current column plus i. The following example uses hanging
indentation for some text:
test = hang 4 (fillSep (map text
(words "the hang combinator indents these words !")))Which lays out on a page with a width of 20 characters as:
the hang combinator
indents these
words !
The hang combinator is implemented as:
hang i x = align (nest i x)
The document (indent i x) indents document x with i spaces.
test = indent 4 (fillSep (map text
(words "the indent combinator indents these words !")))Which lays out with a page width of 20 as:
the indent
combinator
indents these
words !
The action (putDoc doc) pretty prints document doc to the
standard output, with a page width of 80 characters and a ribbon
width of 32 characters.
main :: IO ()
main = do{ putDoc (text "hello" <+> text "world") }Which would output
hello world
Any ANSI colorisation in doc will be output.
The member prettyList is only used to define the instance Pretty
a => Pretty [a]. In normal circumstances only the pretty function
is used.
Instances
| Pretty Bool | |
Defined in Text.PrettyPrint.ANSI.Leijen.Internal | |
| Pretty Char | |
Defined in Text.PrettyPrint.ANSI.Leijen.Internal | |
| Pretty Double | |
Defined in Text.PrettyPrint.ANSI.Leijen.Internal | |
| Pretty Float | |
Defined in Text.PrettyPrint.ANSI.Leijen.Internal | |
| Pretty Int | |
Defined in Text.PrettyPrint.ANSI.Leijen.Internal | |
| Pretty Integer | |
Defined in Text.PrettyPrint.ANSI.Leijen.Internal | |
| Pretty () | |
Defined in Text.PrettyPrint.ANSI.Leijen.Internal | |
| Pretty Doc | |
Defined in Text.PrettyPrint.ANSI.Leijen.Internal | |
| Pretty a => Pretty [a] | |
Defined in Text.PrettyPrint.ANSI.Leijen.Internal | |
| Pretty a => Pretty (Maybe a) | |
Defined in Text.PrettyPrint.ANSI.Leijen.Internal | |
| (Pretty a, Pretty b) => Pretty (a, b) | |
Defined in Text.PrettyPrint.ANSI.Leijen.Internal | |
| (Pretty a, Pretty b, Pretty c) => Pretty (a, b, c) | |
Defined in Text.PrettyPrint.ANSI.Leijen.Internal | |
module System.Process
module System.Directory
type Lens' s a = Lens s s a a #
This is a type alias for monomorphic lenses which don't change the type of the container (or of the value inside).
over :: ASetter s t a b -> (a -> b) -> s -> t #
Getting fmap in a roundabout way:
overmapped::Functorf => (a -> b) -> f a -> f bovermapped=fmap
Applying a function to both components of a pair:
overboth:: (a -> b) -> (a, a) -> (b, b)overboth= \f t -> (f (fst t), f (snd t))
Using over _2second:
>>>over _2 show (10,20)(10,"20")
_Just :: Traversal (Maybe a) (Maybe a') a a' #
_Just targets the value contained in a Maybe, provided it's a Just.
See documentation for _Left (as these 2 are pretty similar). In particular, it can be used to write these:
- Unsafely extracting a value from a
Just:
fromJust= (^?!_Just)
- Checking whether a value is a
Just:
isJust=has_Just
- Converting a
Maybeto a list (empty or consisting of a single element):
maybeToList= (^.._Just)
- Gathering all
Justs in a list:
catMaybes= (^..each._Just)
view :: Getting a s a -> s -> a #
>>>view _1 (1, 2)1
The reason it's not in Lens.Micro is that view in lens has a more general signature:
view :: MonadReader s m => Getting a s a -> m a
So, you would be able to use this view with functions, but not in various reader monads. For most people this shouldn't be an issue; if it is for you, use view from microlens-mtl.
_1 :: Field1 s t a b => Lens s t a b #
Gives access to the 1st field of a tuple (up to 5-tuples).
Getting the 1st component:
>>>(1,2,3,4,5) ^. _11
Setting the 1st component:
>>>(1,2,3) & _1 .~ 10(10,2,3)
Note that this lens is lazy, and can set fields even of undefined:
>>>set _1 10 undefined :: (Int, Int)(10,*** Exception: Prelude.undefined
This is done to avoid violating a lens law stating that you can get back what you put:
>>>view _1 . set _1 10 $ (undefined :: (Int, Int))10
The implementation (for 2-tuples) is:
_1f t = (,)<$>f (fstt)<*>pure(sndt)
or, alternatively,
_1f ~(a,b) = (\a' -> (a',b))<$>f a
(where ~ means a lazy pattern).
each :: Each s t a b => Traversal s t a b #
each tries to be a universal Traversal – it behaves like traversed in most situations, but also adds support for e.g. tuples with same-typed values:
>>>(1,2) & each %~ succ(2,3)
>>>["x", "y", "z"] ^. each"xyz"
However, note that each doesn't work on every instance of Traversable. If you have a Traversable which isn't supported by each, you can use traversed instead. Personally, I like using each instead of traversed whenever possible – it's shorter and more descriptive.
You can use each with these things:
each::Traversal[a] [b] a beach::Traversal(Maybea) (Maybeb) a beach::Traversal(Eithera a) (Eitherb b) a b -- since 0.4.11each::Traversal(a,a) (b,b) a beach::Traversal(a,a,a) (b,b,b) a beach::Traversal(a,a,a,a) (b,b,b,b) a beach::Traversal(a,a,a,a,a) (b,b,b,b,b) a beach:: (RealFloata,RealFloatb) =>Traversal(Complexa) (Complexb) a b
You can also use each with types from array, bytestring, and containers by using microlens-ghc, or additionally with types from vector, text, and unordered-containers by using microlens-platform.
(%~) :: ASetter s t a b -> (a -> b) -> s -> t infixr 4 #
(%~) applies a function to the target; an alternative explanation is that it is an inverse of sets, which turns a setter into an ordinary function. mapped %~ reversefmap reverse
See over if you want a non-operator synonym.
Negating the 1st element of a pair:
>>>(1,2) & _1 %~ negate(-1,2)
Turning all Lefts in a list to upper case:
>>>(mapped._Left.mapped %~ toUpper) [Left "foo", Right "bar"][Left "FOO",Right "bar"]