Safe Haskell | None |
---|
- type Appname = Text
- data Plugin = Plugin {}
- type Plugins = [Plugin]
- class ToCurrent a where
- type Port = Int
- type Host = Text
- type HostBS = 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
- data FilePath
- 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.
Used for versioning data types.
type HostBS = ByteStringSource
getAppname :: FilePath -> TextSource
data LogMessage Source
data KeterException Source
data FilePath
data Text
A space efficient, packed, unboxed Unicode text type.
Eq Text | |
Data Text | |
Ord Text | |
Read Text | |
Show Text | |
Typeable Text | |
IsString Text | |
ToJSON Text | |
FromJSON Text | |
Monoid Text | |
Hashable Text | |
FoldCase Text | |
NFData 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) |
data ByteString
A space-efficient representation of a Word8 vector, supporting many
efficient operations. A ByteString
contains 8-bit characters only.
Instances of Eq, Ord, Read, Show, Data, Typeable
Eq ByteString | |
Data ByteString | |
Ord ByteString | |
Read ByteString | |
Show ByteString | |
Typeable ByteString | |
IsString ByteString | |
ToJSON ByteString | |
FromJSON ByteString | |
Monoid ByteString | |
Hashable ByteString | |
FoldCase ByteString | Note that |
NFData ByteString | |
Extract ByteString | |
RegexLike Regex ByteString | |
RegexLike Regex ByteString | |
RegexContext Regex ByteString ByteString | |
RegexContext Regex ByteString ByteString | |
RegexMaker Regex CompOption ExecOption ByteString | |
RegexMaker Regex CompOption ExecOption ByteString | |
~ * a ByteString => IsString (Parser a) | |
ToJSON v => ToJSON (HashMap ByteString v) | |
ToJSON v => ToJSON (Map ByteString v) | |
FromJSON v => FromJSON (HashMap ByteString v) | |
FromJSON v => FromJSON (Map ByteString v) |
data Set a
A set of values a
.
Typeable1 Set | |
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) | |
(ParseYamlFile a, Ord a) => ParseYamlFile (Set a) |
data Map k a
A Map from keys k
to values a
.
Typeable2 Map | |
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 ByteString v) | |
ToJSON v => ToJSON (Map ByteString v) | |
ToJSON v => ToJSON (Map Text v) | |
ToJSON v => ToJSON (Map Text v) | |
FromJSON v => FromJSON (Map String v) | |
FromJSON v => FromJSON (Map ByteString v) | |
FromJSON v => FromJSON (Map ByteString 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) |
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
.