Safe Haskell | None |
---|---|
Language | Haskell98 |
- type Appname = Text
- data Plugin = Plugin {}
- type Plugins = [Plugin]
- class ToCurrent a where
- type Port = Int
- type Host = CI Text
- type HostBS = CI ByteString
- getAppname :: FilePath -> Text
- data LogMessage
- = ProcessCreated FilePath
- | InvalidBundle FilePath SomeException
- | ProcessDidNotStart FilePath
- | ExceptionThrown Text SomeException
- | RemovingPort Int
- | UnpackingBundle FilePath
- | TerminatingApp Text
- | FinishedReloading Text
- | TerminatingOldProcess AppId
- | RemovingOldFolder FilePath
- | ReceivedInotifyEvent Text
- | ProcessWaiting FilePath
- | OtherMessage Text
- | ErrorStartingBundle Text SomeException
- | SanityChecksPassed
- | ReservingHosts AppId (Set Host)
- | ForgetingReservations AppId (Set Host)
- | ActivatingApp AppId (Set Host)
- | DeactivatingApp AppId (Set Host)
- | ReactivatingApp AppId (Set Host) (Set Host)
- | WatchedFile Text FilePath
- data KeterException
- logEx :: Q Exp
- data AppId
- type FilePath = String
- data Text :: *
- data ByteString :: *
- data Set a :: * -> *
- data Map k a :: * -> * -> *
- class (Typeable * e, Show e) => Exception e
- data SomeException :: *
Documentation
Name of the application. Should just be the basename of the application file.
type HostBS = CI ByteString Source
getAppname :: FilePath -> Text Source
data LogMessage Source
data KeterException Source
File and directory names are values of type String
, whose precise
meaning is operating system dependent. Files can be opened, yielding a
handle which can then be used to operate on the contents of that file.
data Text :: *
A space efficient, packed, unboxed Unicode text type.
IsList Text | |
Eq Text | |
Data Text | This instance preserves data abstraction at the cost of inefficiency. We omit reflection services for the sake of data abstraction. This instance was created by copying the updated behavior of
The original discussion is archived here: could we get a Data instance for Data.Text.Text? The followup discussion that changed the behavior of |
Ord Text | |
Read Text | |
Show Text | |
IsString Text | |
ToJSON Text | |
FromJSON Text | |
Chunk Text | |
Monoid Text | |
Binary Text | |
FoldCase Text | |
NFData Text | |
Hashable Text | |
Semigroup Text | |
Typeable * Text | |
(~) * a Text => IsString (Parser a) | |
ToJSON v => ToJSON (HashMap Text v) | |
ToJSON v => ToJSON (Map Text v) | |
FromJSON v => FromJSON (HashMap Text v) | |
FromJSON v => FromJSON (Map Text v) | |
type State Text = Buffer | |
type ChunkElem Text = Char | |
type Item Text = Char |
data ByteString :: *
A space-efficient representation of a Word8
vector, supporting many
efficient operations.
A ByteString
contains 8-bit bytes, or by using the operations from
Data.ByteString.Char8 it can be interpreted as containing 8-bit
characters.
Eq ByteString | |
Data ByteString | |
Ord ByteString | |
Read ByteString | |
Show ByteString | |
IsString ByteString | |
Chunk ByteString | |
Monoid ByteString | |
FoldCase ByteString | Note that |
NFData ByteString | |
Hashable ByteString | |
Extract ByteString | |
Semigroup ByteString | |
Typeable * ByteString | |
RegexLike Regex ByteString | |
RegexContext Regex ByteString ByteString | |
RegexMaker Regex CompOption ExecOption ByteString | |
(~) * a ByteString => IsString (Parser a) | |
type State ByteString = Buffer | |
type ChunkElem ByteString = Word8 |
data Set a :: * -> *
A set of values a
.
Foldable Set | |
Eq a => Eq (Set a) | |
(Data a, Ord a) => Data (Set a) | |
Ord a => Ord (Set a) | |
(Read a, Ord a) => Read (Set a) | |
Show a => Show (Set a) | |
ToJSON a => ToJSON (Set a) | |
(Ord a, FromJSON a) => FromJSON (Set a) | |
Ord a => Monoid (Set a) | |
Default (Set v) | |
NFData a => NFData (Set a) | |
Ord a => Semigroup (Set a) | |
(ParseYamlFile a, Ord a) => ParseYamlFile (Set a) | |
Typeable (* -> *) Set |
data Map k a :: * -> * -> *
A Map from keys k
to values a
.
Functor (Map k) | |
Foldable (Map k) | |
Traversable (Map k) | |
(Eq k, Eq a) => Eq (Map k a) | |
(Data k, Data a, Ord k) => Data (Map k a) | |
(Ord k, Ord v) => Ord (Map k v) | |
(Ord k, Read k, Read e) => Read (Map k e) | |
(Show k, Show a) => Show (Map k a) | |
ToJSON v => ToJSON (Map String v) | |
ToJSON v => ToJSON (Map Text v) | |
ToJSON v => ToJSON (Map Text v) | |
FromJSON v => FromJSON (Map String v) | |
FromJSON v => FromJSON (Map Text v) | |
FromJSON v => FromJSON (Map Text v) | |
Ord k => Monoid (Map k v) | |
Default (Map k v) | |
(NFData k, NFData a) => NFData (Map k a) | |
Ord k => Semigroup (Map k v) | |
Typeable (* -> * -> *) Map |
class (Typeable * e, Show e) => Exception e
Any type that you wish to throw or catch as an exception must be an
instance of the Exception
class. The simplest case is a new exception
type directly below the root:
data MyException = ThisException | ThatException deriving (Show, Typeable) instance Exception MyException
The default method definitions in the Exception
class do what we need
in this case. You can now throw and catch ThisException
and
ThatException
as exceptions:
*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException)) Caught ThisException
In more complicated examples, you may wish to define a whole hierarchy of exceptions:
--------------------------------------------------------------------- -- Make the root exception type for all the exceptions in a compiler data SomeCompilerException = forall e . Exception e => SomeCompilerException e deriving Typeable instance Show SomeCompilerException where show (SomeCompilerException e) = show e instance Exception SomeCompilerException compilerExceptionToException :: Exception e => e -> SomeException compilerExceptionToException = toException . SomeCompilerException compilerExceptionFromException :: Exception e => SomeException -> Maybe e compilerExceptionFromException x = do SomeCompilerException a <- fromException x cast a --------------------------------------------------------------------- -- Make a subhierarchy for exceptions in the frontend of the compiler data SomeFrontendException = forall e . Exception e => SomeFrontendException e deriving Typeable instance Show SomeFrontendException where show (SomeFrontendException e) = show e instance Exception SomeFrontendException where toException = compilerExceptionToException fromException = compilerExceptionFromException frontendExceptionToException :: Exception e => e -> SomeException frontendExceptionToException = toException . SomeFrontendException frontendExceptionFromException :: Exception e => SomeException -> Maybe e frontendExceptionFromException x = do SomeFrontendException a <- fromException x cast a --------------------------------------------------------------------- -- Make an exception type for a particular frontend compiler exception data MismatchedParentheses = MismatchedParentheses deriving (Typeable, Show) instance Exception MismatchedParentheses where toException = frontendExceptionToException fromException = frontendExceptionFromException
We can now catch a MismatchedParentheses
exception as
MismatchedParentheses
, SomeFrontendException
or
SomeCompilerException
, but not other types, e.g. IOException
:
*Main> throw MismatchedParenthesescatch
e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses)) Caught MismatchedParentheses *Main> throw MismatchedParenthesescatch
e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException)) Caught MismatchedParentheses *Main> throw MismatchedParenthesescatch
e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException)) Caught MismatchedParentheses *Main> throw MismatchedParenthesescatch
e -> putStrLn ("Caught " ++ show (e :: IOException)) *** Exception: MismatchedParentheses
data SomeException :: *
The SomeException
type is the root of the exception type hierarchy.
When an exception of type e
is thrown, behind the scenes it is
encapsulated in a SomeException
.