| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Hledger.Web.Import
Synopsis
- (++) :: [a] -> [a] -> [a]
- seq :: a -> b -> b
- filter :: (a -> Bool) -> [a] -> [a]
- zip :: [a] -> [b] -> [(a, b)]
- print :: Show a => a -> IO ()
- fst :: (a, b) -> a
- snd :: (a, b) -> b
- otherwise :: Bool
- map :: (a -> b) -> [a] -> [b]
- ($) :: (a -> b) -> a -> b
- fromIntegral :: (Integral a, Num b) => a -> b
- realToFrac :: (Real a, Fractional b) => a -> b
- guard :: Alternative f => Bool -> f ()
- join :: Monad m => m (m a) -> m a
- class Bounded a where
- class Enum a where
- class Eq a where
- class Fractional a => Floating a where
- class Num a => Fractional a where
- class (Real a, Enum a) => Integral a where
- class Applicative m => Monad (m :: * -> *) where
- class Functor (f :: * -> *) where
- class Num a where
- class Eq a => Ord a where
- class Read a where
- class (Num a, Ord a) => Real a where
- class (RealFrac a, Floating a) => RealFloat a where
- class (Real a, Fractional a) => RealFrac a where
- class Show a where
- class Functor f => Applicative (f :: * -> *) where
- class Foldable (t :: * -> *) where
- class (Functor t, Foldable t) => Traversable (t :: * -> *) where
- class Semigroup a where
- class Semigroup a => Monoid a where
- data Bool
- data Char
- data Double
- data Float
- data Int
- data Integer
- data Maybe a
- data Ordering
- type Rational = Ratio Integer
- data IO a
- data Word
- data Either a b
- type String = [Char]
- type ShowS = String -> String
- data ByteString
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- data Text
- data UTCTime = UTCTime {
- utctDay :: Day
- utctDayTime :: DiffTime
- class ToJSON a where
- (.=) :: (KeyValue kv, ToJSON v) => Text -> v -> kv
- (.:) :: FromJSON a => Object -> Text -> Parser a
- class FromJSON a where
- object :: [Pair] -> Value
- data Value
- read :: Read a => String -> a
- class (Alternative m, Monad m) => MonadPlus (m :: * -> *) where
- data Void
- class Bifunctor (p :: * -> * -> *) where
- class Monad m => MonadIO (m :: * -> *) where
- mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
- (<$!>) :: Monad m => (a -> b) -> m a -> m b
- unless :: Applicative f => Bool -> f () -> f ()
- replicateM_ :: Applicative m => Int -> m a -> m ()
- replicateM :: Applicative m => Int -> m a -> m [a]
- foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
- foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
- zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
- forever :: Applicative f => f a -> f b
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
- foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m
- fmapDefault :: Traversable t => (a -> b) -> t a -> t b
- mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
- mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
- forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
- readIO :: Read a => String -> IO a
- readLn :: Read a => IO a
- appendFile :: FilePath -> String -> IO ()
- interact :: (String -> String) -> IO ()
- getContents :: IO String
- getLine :: IO String
- getChar :: IO Char
- putStrLn :: String -> IO ()
- putStr :: String -> IO ()
- putChar :: Char -> IO ()
- ioError :: IOError -> IO a
- type FilePath = String
- userError :: String -> IOError
- type IOError = IOException
- find :: Foldable t => (a -> Bool) -> t a -> Maybe a
- notElem :: (Foldable t, Eq a) => a -> t a -> Bool
- minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
- maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
- all :: Foldable t => (a -> Bool) -> t a -> Bool
- any :: Foldable t => (a -> Bool) -> t a -> Bool
- or :: Foldable t => t Bool -> Bool
- and :: Foldable t => t Bool -> Bool
- concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
- concat :: Foldable t => t [a] -> [a]
- msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
- asum :: (Foldable t, Alternative f) => t (f a) -> f a
- sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
- forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
- mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
- traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
- foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
- unwords :: [String] -> String
- words :: String -> [String]
- unlines :: [String] -> String
- lines :: String -> [String]
- unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
- reads :: Read a => ReadS a
- fromRight :: b -> Either a b -> b
- fromLeft :: a -> Either a b -> a
- isRight :: Either a b -> Bool
- isLeft :: Either a b -> Bool
- partitionEithers :: [Either a b] -> ([a], [b])
- rights :: [Either a b] -> [b]
- lefts :: [Either a b] -> [a]
- either :: (a -> c) -> (b -> c) -> Either a b -> c
- lex :: ReadS String
- readParen :: Bool -> ReadS a -> ReadS a
- type ReadS a = String -> [(a, String)]
- void :: Functor f => f a -> f ()
- lcm :: Integral a => a -> a -> a
- gcd :: Integral a => a -> a -> a
- (^^) :: (Fractional a, Integral b) => a -> b -> a
- (^) :: (Num a, Integral b) => a -> b -> a
- odd :: Integral a => a -> Bool
- even :: Integral a => a -> Bool
- showParen :: Bool -> ShowS -> ShowS
- showString :: String -> ShowS
- showChar :: Char -> ShowS
- shows :: Show a => a -> ShowS
- unzip3 :: [(a, b, c)] -> ([a], [b], [c])
- unzip :: [(a, b)] -> ([a], [b])
- zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- (!!) :: [a] -> Int -> a
- lookup :: Eq a => a -> [(a, b)] -> Maybe b
- reverse :: [a] -> [a]
- break :: (a -> Bool) -> [a] -> ([a], [a])
- span :: (a -> Bool) -> [a] -> ([a], [a])
- splitAt :: Int -> [a] -> ([a], [a])
- drop :: Int -> [a] -> [a]
- take :: Int -> [a] -> [a]
- dropWhile :: (a -> Bool) -> [a] -> [a]
- takeWhile :: (a -> Bool) -> [a] -> [a]
- cycle :: [a] -> [a]
- replicate :: Int -> a -> [a]
- repeat :: a -> [a]
- iterate :: (a -> a) -> a -> [a]
- scanr1 :: (a -> a -> a) -> [a] -> [a]
- scanr :: (a -> b -> b) -> b -> [a] -> [b]
- scanl1 :: (a -> a -> a) -> [a] -> [a]
- scanl :: (b -> a -> b) -> b -> [a] -> [b]
- mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- catMaybes :: [Maybe a] -> [a]
- listToMaybe :: [a] -> Maybe a
- maybeToList :: Maybe a -> [a]
- fromMaybe :: a -> Maybe a -> a
- fromJust :: Maybe a -> a
- isNothing :: Maybe a -> Bool
- isJust :: Maybe a -> Bool
- maybe :: b -> (a -> b) -> Maybe a -> b
- uncurry :: (a -> b -> c) -> (a, b) -> c
- curry :: ((a, b) -> c) -> a -> b -> c
- subtract :: Num a => a -> a -> a
- asTypeOf :: a -> a -> a
- until :: (a -> Bool) -> (a -> a) -> a -> a
- ($!) :: (a -> b) -> a -> b
- flip :: (a -> b -> c) -> b -> a -> c
- (.) :: (b -> c) -> (a -> b) -> a -> c
- const :: a -> b -> a
- id :: a -> a
- ap :: Monad m => m (a -> b) -> m a -> m b
- liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
- liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
- liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
- liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
- liftM :: Monad m => (a1 -> r) -> m a1 -> m r
- when :: Applicative f => Bool -> f () -> f ()
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- undefined :: HasCallStack => a
- errorWithoutStackTrace :: [Char] -> a
- error :: HasCallStack => [Char] -> a
- (&&) :: Bool -> Bool -> Bool
- (||) :: Bool -> Bool -> Bool
- not :: Bool -> Bool
- type Markup = MarkupM ()
- preEscapedToMarkup :: ToMarkup a => a -> Markup
- toHtml :: ToMarkup a => a -> Html
- type Html = Markup
- class MonadIO m => MonadUnliftIO (m :: * -> *) where
- class MonadIO m => MonadResource (m :: * -> *) where
- class MonadTrans (t :: (* -> *) -> * -> *) where
- data DiffTime
- class Default a where
- logOtherS :: Q Exp
- logErrorS :: Q Exp
- logWarnS :: Q Exp
- logInfoS :: Q Exp
- logDebugS :: Q Exp
- logOther :: Text -> Q Exp
- logError :: Q Exp
- logWarn :: Q Exp
- logInfo :: Q Exp
- logDebug :: Q Exp
- data LogLevel
- class Monad m => MonadLogger (m :: * -> *)
- class PathPiece s where
- class PathMultiPiece s where
- limitOffsetOrder :: PersistEntity val => [SelectOpt val] -> (Int, Int, [SelectOpt val])
- toJsonText :: ToJSON j => j -> Text
- mapToJSON :: [(Text, PersistValue)] -> Text
- listToJSON :: [PersistValue] -> Text
- (||.) :: [Filter v] -> [Filter v] -> [Filter v]
- (/<-.) :: PersistField typ => EntityField v typ -> [typ] -> Filter v
- (<-.) :: PersistField typ => EntityField v typ -> [typ] -> Filter v
- (>=.) :: PersistField typ => EntityField v typ -> typ -> Filter v
- (>.) :: PersistField typ => EntityField v typ -> typ -> Filter v
- (<=.) :: PersistField typ => EntityField v typ -> typ -> Filter v
- (<.) :: PersistField typ => EntityField v typ -> typ -> Filter v
- (!=.) :: PersistField typ => EntityField v typ -> typ -> Filter v
- (==.) :: PersistField typ => EntityField v typ -> typ -> Filter v
- (/=.) :: PersistField typ => EntityField v typ -> typ -> Update v
- (*=.) :: PersistField typ => EntityField v typ -> typ -> Update v
- (-=.) :: PersistField typ => EntityField v typ -> typ -> Update v
- (+=.) :: PersistField typ => EntityField v typ -> typ -> Update v
- (=.) :: PersistField typ => EntityField v typ -> typ -> Update v
- type PersistUnique a = PersistUniqueWrite a
- type PersistQuery a = PersistQueryWrite a
- type PersistStore a = PersistStoreWrite a
- deleteCascadeWhere :: (MonadIO m, DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> ReaderT backend m ()
- class (PersistStoreWrite backend, PersistEntity record, BaseBackend backend ~ PersistEntityBackend record) => DeleteCascade record backend where
- selectKeysList :: (MonadIO m, PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m [Key record]
- selectList :: (MonadIO m, PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m [Entity record]
- selectKeys :: (PersistQueryRead (BaseBackend backend), MonadResource m, PersistEntity record, BaseBackend (BaseBackend backend) ~ PersistEntityBackend record, MonadReader backend m, HasPersistBackend backend) => [Filter record] -> [SelectOpt record] -> ConduitM () (Key record) m ()
- selectSource :: (PersistQueryRead (BaseBackend backend), MonadResource m, PersistEntity record, PersistEntityBackend record ~ BaseBackend (BaseBackend backend), MonadReader backend m, HasPersistBackend backend) => [Filter record] -> [SelectOpt record] -> ConduitM () (Entity record) m ()
- class (PersistCore backend, PersistStoreRead backend) => PersistQueryRead backend where
- class (PersistQueryRead backend, PersistStoreWrite backend) => PersistQueryWrite backend where
- checkUnique :: (MonadIO m, PersistRecordBackend record backend, PersistUniqueRead backend) => record -> ReaderT backend m (Maybe (Unique record))
- replaceUnique :: (MonadIO m, Eq record, Eq (Unique record), PersistRecordBackend record backend, PersistUniqueWrite backend) => Key record -> record -> ReaderT backend m (Maybe (Unique record))
- getByValue :: (MonadIO m, PersistUniqueRead backend, PersistRecordBackend record backend) => record -> ReaderT backend m (Maybe (Entity record))
- onlyUnique :: (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ReaderT backend m (Unique record)
- insertUniqueEntity :: (MonadIO m, PersistRecordBackend record backend, PersistUniqueWrite backend) => record -> ReaderT backend m (Maybe (Entity record))
- insertBy :: (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ReaderT backend m (Either (Entity record) (Key record))
- class (PersistCore backend, PersistStoreRead backend) => PersistUniqueRead backend where
- class (PersistUniqueRead backend, PersistStoreWrite backend) => PersistUniqueWrite backend where
- insertRecord :: (PersistEntityBackend record ~ BaseBackend backend, PersistEntity record, MonadIO m, PersistStoreWrite backend) => record -> ReaderT backend m record
- getEntity :: (PersistStoreRead backend, PersistRecordBackend e backend, MonadIO m) => Key e -> ReaderT backend m (Maybe (Entity e))
- insertEntity :: (PersistStoreWrite backend, PersistRecordBackend e backend, MonadIO m) => e -> ReaderT backend m (Entity e)
- belongsToJust :: (PersistStoreRead backend, PersistEntity ent1, PersistRecordBackend ent2 backend, MonadIO m) => (ent1 -> Key ent2) -> ent1 -> ReaderT backend m ent2
- belongsTo :: (PersistStoreRead backend, PersistEntity ent1, PersistRecordBackend ent2 backend, MonadIO m) => (ent1 -> Maybe (Key ent2)) -> ent1 -> ReaderT backend m (Maybe ent2)
- getJustEntity :: (PersistEntityBackend record ~ BaseBackend backend, MonadIO m, PersistEntity record, PersistStoreRead backend) => Key record -> ReaderT backend m (Entity record)
- getJust :: (PersistStoreRead backend, Show (Key record), PersistRecordBackend record backend, MonadIO m) => Key record -> ReaderT backend m record
- liftPersist :: (MonadIO m, MonadReader backend m, HasPersistBackend backend) => ReaderT (BaseBackend backend) IO b -> m b
- class HasPersistBackend backend where
- type BaseBackend backend :: *
- class HasPersistBackend backend => IsPersistBackend backend
- class BackendCompatible sup sub where
- type PersistRecordBackend record backend = (PersistEntity record, PersistEntityBackend record ~ BaseBackend backend)
- class (PersistEntity record, PersistEntityBackend record ~ backend, PersistCore backend) => ToBackendKey backend record where
- class PersistCore backend where
- data BackendKey backend :: *
- class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistCore backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreRead backend where
- class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistStoreRead backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreWrite backend where
- fromPersistValueJSON :: FromJSON a => PersistValue -> Either Text a
- toPersistValueJSON :: ToJSON a => a -> PersistValue
- entityIdFromJSON :: (PersistEntity record, FromJSON record, FromJSON (Key record)) => Value -> Parser (Entity record)
- entityIdToJSON :: (PersistEntity record, ToJSON record, ToJSON (Key record)) => Entity record -> Value
- keyValueEntityFromJSON :: (PersistEntity record, FromJSON record, FromJSON (Key record)) => Value -> Parser (Entity record)
- keyValueEntityToJSON :: (PersistEntity record, ToJSON record, ToJSON (Key record)) => Entity record -> Value
- entityValues :: PersistEntity record => Entity record -> [PersistValue]
- class (PersistField (Key record), ToJSON (Key record), FromJSON (Key record), Show (Key record), Read (Key record), Eq (Key record), Ord (Key record)) => PersistEntity record where
- type PersistEntityBackend record :: *
- data Key record :: *
- data EntityField record a :: *
- data Unique record :: *
- type family BackendSpecificUpdate backend record :: *
- data Update record where
- Update :: Update record
- BackendUpdate :: Update record
- data SelectOpt record where
- type family BackendSpecificFilter backend record :: *
- data Filter record where
- data Entity record = Entity {}
- getPersistMap :: PersistValue -> Either Text [(Text, PersistValue)]
- class PersistField a where
- data SomePersistField where
- fromPersistValueText :: PersistValue -> Either Text Text
- toEmbedEntityDef :: EntityDef -> EmbedEntityDef
- keyAndEntityFields :: EntityDef -> [FieldDef]
- entityKeyFields :: EntityDef -> [FieldDef]
- entityPrimary :: EntityDef -> Maybe CompositeDef
- data Checkmark
- data IsNullable
- data WhyNullable
- data EntityDef = EntityDef {
- entityHaskell :: !HaskellName
- entityDB :: !DBName
- entityId :: !FieldDef
- entityAttrs :: ![Attr]
- entityFields :: ![FieldDef]
- entityUniques :: ![UniqueDef]
- entityForeigns :: ![ForeignDef]
- entityDerives :: ![Text]
- entityExtra :: !(Map Text [ExtraLine])
- entitySum :: !Bool
- type ExtraLine = [Text]
- newtype HaskellName = HaskellName {}
- newtype DBName = DBName {}
- type Attr = Text
- data FieldType
- data FieldDef = FieldDef {
- fieldHaskell :: !HaskellName
- fieldDB :: !DBName
- fieldType :: !FieldType
- fieldSqlType :: !SqlType
- fieldAttrs :: ![Attr]
- fieldStrict :: !Bool
- fieldReference :: !ReferenceDef
- data ReferenceDef
- data EmbedEntityDef = EmbedEntityDef {}
- data EmbedFieldDef = EmbedFieldDef {}
- data UniqueDef = UniqueDef {
- uniqueHaskell :: !HaskellName
- uniqueDBName :: !DBName
- uniqueFields :: ![(HaskellName, DBName)]
- uniqueAttrs :: ![Attr]
- data CompositeDef = CompositeDef {
- compositeFields :: ![FieldDef]
- compositeAttrs :: ![Attr]
- type ForeignFieldDef = (HaskellName, DBName)
- data ForeignDef = ForeignDef {}
- data PersistException
- data PersistValue
- = PersistText Text
- | PersistByteString ByteString
- | PersistInt64 Int64
- | PersistDouble Double
- | PersistRational Rational
- | PersistBool Bool
- | PersistDay Day
- | PersistTimeOfDay TimeOfDay
- | PersistUTCTime UTCTime
- | PersistNull
- | PersistList [PersistValue]
- | PersistMap [(Text, PersistValue)]
- | PersistObjectId ByteString
- | PersistDbSpecific ByteString
- data SqlType
- data PersistFilter
- data UpdateException
- data OnlyUniqueException = OnlyUniqueException String
- data PersistUpdate
- class PersistConfig c where
- type PersistConfigBackend c :: (* -> *) -> * -> *
- type PersistConfigPool c :: *
- packPTH :: String -> Text
- mkMigrate :: String -> [EntityDef] -> Q [Dec]
- derivePersistFieldJSON :: String -> Q [Dec]
- derivePersistField :: String -> Q [Dec]
- mkDeleteCascade :: MkPersistSettings -> [EntityDef] -> Q [Dec]
- mkSave :: String -> [EntityDef] -> Q [Dec]
- share :: [[EntityDef] -> Q [Dec]] -> [EntityDef] -> Q [Dec]
- persistFieldFromEntity :: MkPersistSettings -> EntityDef -> Q [Dec]
- lensPTH :: (s -> a) -> (s -> b -> t) -> Lens s t a b
- sqlOnlySettings :: MkPersistSettings
- sqlSettings :: MkPersistSettings
- mkPersistSettings :: Type -> MkPersistSettings
- mkPersist :: MkPersistSettings -> [EntityDef] -> Q [Dec]
- parseReferences :: PersistSettings -> Text -> Q Exp
- persistManyFileWith :: PersistSettings -> [FilePath] -> Q Exp
- persistFileWith :: PersistSettings -> FilePath -> Q Exp
- persistLowerCase :: QuasiQuoter
- persistUpperCase :: QuasiQuoter
- persistWith :: PersistSettings -> QuasiQuoter
- data MkPersistSettings
- data EntityJSON = EntityJSON {}
- mkMessageVariant :: String -> String -> FilePath -> Lang -> Q [Dec]
- mkMessageFor :: String -> String -> FilePath -> Lang -> Q [Dec]
- mkMessage :: String -> FilePath -> Lang -> Q [Dec]
- class ToMessage a where
- class RenderMessage master message where
- type Lang = Text
- data SomeMessage master where
- SomeMessage :: SomeMessage master
- cassius :: QuasiQuoter
- xhamlet :: QuasiQuoter
- hamlet :: QuasiQuoter
- shamlet :: QuasiQuoter
- type HtmlUrl url = Render url -> Html
- lucius :: QuasiQuoter
- renderCssUrl :: (url -> [(Text, Text)] -> Text) -> CssUrl url -> Text
- type CssUrl url = (url -> [(Text, Text)] -> Text) -> Css
- julius :: QuasiQuoter
- renderJavascriptUrl :: (url -> [(Text, Text)] -> Text) -> JavascriptUrl url -> Text
- type JavascriptUrl url = (url -> [(Text, Text)] -> Text) -> Javascript
- formatTime :: FormatTime t => TimeLocale -> String -> t -> String
- type NumericPadOption = Maybe Char
- class FormatTime t where
- readsTime :: ParseTime t => TimeLocale -> String -> ReadS t
- readTime :: ParseTime t => TimeLocale -> String -> String -> t
- readPTime :: ParseTime t => Bool -> TimeLocale -> String -> ReadP t
- readSTime :: ParseTime t => Bool -> TimeLocale -> String -> ReadS t
- parseTimeOrError :: ParseTime t => Bool -> TimeLocale -> String -> String -> t
- parseTimeM :: (Monad m, ParseTime t) => Bool -> TimeLocale -> String -> String -> m t
- class ParseTime t where
- utcToLocalZonedTime :: UTCTime -> IO ZonedTime
- getZonedTime :: IO ZonedTime
- zonedTimeToUTC :: ZonedTime -> UTCTime
- utcToZonedTime :: TimeZone -> UTCTime -> ZonedTime
- data ZonedTime = ZonedTime {}
- rfc822DateFormat :: String
- iso8601DateFormat :: Maybe String -> String
- defaultTimeLocale :: TimeLocale
- data TimeLocale = TimeLocale {}
- localTimeToUT1 :: Rational -> LocalTime -> UniversalTime
- ut1ToLocalTime :: Rational -> UniversalTime -> LocalTime
- localTimeToUTC :: TimeZone -> LocalTime -> UTCTime
- utcToLocalTime :: TimeZone -> UTCTime -> LocalTime
- data LocalTime = LocalTime {}
- timeOfDayToDayFraction :: TimeOfDay -> Rational
- dayFractionToTimeOfDay :: Rational -> TimeOfDay
- timeOfDayToTime :: TimeOfDay -> DiffTime
- timeToTimeOfDay :: DiffTime -> TimeOfDay
- localToUTCTimeOfDay :: TimeZone -> TimeOfDay -> (Integer, TimeOfDay)
- utcToLocalTimeOfDay :: TimeZone -> TimeOfDay -> (Integer, TimeOfDay)
- makeTimeOfDayValid :: Int -> Int -> Pico -> Maybe TimeOfDay
- midday :: TimeOfDay
- midnight :: TimeOfDay
- data TimeOfDay = TimeOfDay {}
- getCurrentTimeZone :: IO TimeZone
- getTimeZone :: UTCTime -> IO TimeZone
- utc :: TimeZone
- timeZoneOffsetString :: TimeZone -> String
- timeZoneOffsetString' :: Maybe Char -> TimeZone -> String
- hoursToTimeZone :: Int -> TimeZone
- minutesToTimeZone :: Int -> TimeZone
- data TimeZone = TimeZone {}
- diffUTCTime :: UTCTime -> UTCTime -> NominalDiffTime
- addUTCTime :: NominalDiffTime -> UTCTime -> UTCTime
- getCurrentTime :: IO UTCTime
- newtype UniversalTime = ModJulianDate {}
- getTime_resolution :: DiffTime
- nominalDay :: NominalDiffTime
- data NominalDiffTime
- diffTimeToPicoseconds :: DiffTime -> Integer
- picosecondsToDiffTime :: Integer -> DiffTime
- secondsToDiffTime :: Integer -> DiffTime
- addGregorianYearsRollOver :: Integer -> Day -> Day
- addGregorianYearsClip :: Integer -> Day -> Day
- addGregorianMonthsRollOver :: Integer -> Day -> Day
- addGregorianMonthsClip :: Integer -> Day -> Day
- gregorianMonthLength :: Integer -> Int -> Int
- showGregorian :: Day -> String
- fromGregorianValid :: Integer -> Int -> Int -> Maybe Day
- fromGregorian :: Integer -> Int -> Int -> Day
- toGregorian :: Day -> (Integer, Int, Int)
- isLeapYear :: Integer -> Bool
- diffDays :: Day -> Day -> Integer
- addDays :: Integer -> Day -> Day
- newtype Day = ModifiedJulianDay {}
- type Application = Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived
- newtype DBRunner site = DBRunner {
- runDBRunner :: forall a. YesodDB site a -> HandlerFor site a
- class YesodPersist site => YesodPersistRunner site where
- class Monad (YesodDB site) => YesodPersist site where
- type YesodPersistBackend site :: *
- type YesodDB site = ReaderT (YesodPersistBackend site) (HandlerFor site)
- defaultRunDB :: PersistConfig c => (site -> c) -> (site -> PersistConfigPool c) -> PersistConfigBackend c (HandlerFor site) a -> HandlerFor site a
- defaultGetDBRunner :: (IsSqlBackend backend, YesodPersistBackend site ~ backend) => (site -> Pool backend) -> HandlerFor site (DBRunner site, HandlerFor site ())
- runDBSource :: YesodPersistRunner site => ConduitT () a (YesodDB site) () -> ConduitT () a (HandlerFor site) ()
- respondSourceDB :: YesodPersistRunner site => ContentType -> ConduitT () (Flush Builder) (YesodDB site) () -> HandlerFor site TypedContent
- get404 :: (MonadIO m, PersistStoreRead backend, PersistRecordBackend val backend) => Key val -> ReaderT backend m val
- getBy404 :: (PersistUniqueRead backend, PersistRecordBackend val backend, MonadIO m) => Unique val -> ReaderT backend m (Entity val)
- insert400 :: (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend val backend) => val -> ReaderT backend m (Key val)
- insert400_ :: (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend val backend) => val -> ReaderT backend m ()
- data FormMessage
- = MsgInvalidInteger Text
- | MsgInvalidNumber Text
- | MsgInvalidEntry Text
- | MsgInvalidUrl Text
- | MsgInvalidEmail Text
- | MsgInvalidTimeFormat
- | MsgInvalidHour Text
- | MsgInvalidMinute Text
- | MsgInvalidSecond Text
- | MsgInvalidDay
- | MsgCsrfWarning
- | MsgValueRequired
- | MsgInputNotFound Text
- | MsgSelectNone
- | MsgInvalidBool Text
- | MsgBoolYes
- | MsgBoolNo
- | MsgDelete
- data Field (m :: * -> *) a = Field {
- fieldParse :: [Text] -> [FileInfo] -> m (Either (SomeMessage (HandlerSite m)) (Maybe a))
- fieldView :: FieldViewFunc m a
- fieldEnctype :: Enctype
- type FieldViewFunc (m :: * -> *) a = Text -> Text -> [(Text, Text)] -> Either Text a -> Bool -> WidgetFor (HandlerSite m) ()
- data FieldView site = FieldView {}
- data FieldSettings master = FieldSettings {}
- newtype AForm (m :: * -> *) a = AForm {
- unAForm :: (HandlerSite m, [Text]) -> Maybe (Env, FileEnv) -> Ints -> m (FormResult a, [FieldView (HandlerSite m)] -> [FieldView (HandlerSite m)], Ints, Enctype)
- type MForm (m :: * -> *) a = RWST (Maybe (Env, FileEnv), HandlerSite m, [Lang]) Enctype Ints m a
- type WForm (m :: * -> *) a = MForm (WriterT [FieldView (HandlerSite m)] m) a
- type FileEnv = Map Text [FileInfo]
- type Env = Map Text [Text]
- data Ints
- data Enctype
- data FormResult a
- = FormMissing
- | FormFailure [Text]
- | FormSuccess a
- newtype FormInput (m :: * -> *) a = FormInput {
- unFormInput :: HandlerSite m -> [Text] -> Env -> FileEnv -> m (Either DText a)
- ireq :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m a -> Text -> FormInput m a
- iopt :: Monad m => Field m a -> Text -> FormInput m (Maybe a)
- runInputGet :: MonadHandler m => FormInput m a -> m a
- runInputGetResult :: MonadHandler m => FormInput m a -> m (FormResult a)
- runInputPost :: MonadHandler m => FormInput m a -> m a
- runInputPostResult :: MonadHandler m => FormInput m a -> m (FormResult a)
- type FormRender (m :: * -> *) a = AForm m a -> Markup -> MForm m (FormResult a, WidgetFor (HandlerSite m) ())
- newFormIdent :: Monad m => MForm m Text
- formToAForm :: (HandlerSite m ~ site, Monad m) => MForm m (FormResult a, [FieldView site]) -> AForm m a
- aFormToForm :: (Monad m, HandlerSite m ~ site) => AForm m a -> MForm m (FormResult a, [FieldView site] -> [FieldView site])
- askParams :: Monad m => MForm m (Maybe Env)
- askFiles :: Monad m => MForm m (Maybe FileEnv)
- wreq :: (RenderMessage site FormMessage, HandlerSite m ~ site, MonadHandler m) => Field m a -> FieldSettings site -> Maybe a -> WForm m (FormResult a)
- wopt :: (MonadHandler m, HandlerSite m ~ site) => Field m a -> FieldSettings site -> Maybe (Maybe a) -> WForm m (FormResult (Maybe a))
- wFormToAForm :: MonadHandler m => WForm m (FormResult a) -> AForm m a
- wFormToMForm :: (MonadHandler m, HandlerSite m ~ site) => WForm m a -> MForm m (a, [FieldView site])
- mFormToWForm :: (MonadHandler m, HandlerSite m ~ site) => MForm m (a, FieldView site) -> WForm m a
- mreq :: (RenderMessage site FormMessage, HandlerSite m ~ site, MonadHandler m) => Field m a -> FieldSettings site -> Maybe a -> MForm m (FormResult a, FieldView site)
- mopt :: (site ~ HandlerSite m, MonadHandler m) => Field m a -> FieldSettings site -> Maybe (Maybe a) -> MForm m (FormResult (Maybe a), FieldView site)
- areq :: (RenderMessage site FormMessage, HandlerSite m ~ site, MonadHandler m) => Field m a -> FieldSettings site -> Maybe a -> AForm m a
- aopt :: MonadHandler m => Field m a -> FieldSettings (HandlerSite m) -> Maybe (Maybe a) -> AForm m (Maybe a)
- runFormPost :: (RenderMessage (HandlerSite m) FormMessage, MonadResource m, MonadHandler m) => (Markup -> MForm m (FormResult a, xml)) -> m ((FormResult a, xml), Enctype)
- generateFormPost :: (RenderMessage (HandlerSite m) FormMessage, MonadHandler m) => (Markup -> MForm m (FormResult a, xml)) -> m (xml, Enctype)
- runFormPostNoToken :: MonadHandler m => (Markup -> MForm m a) -> m (a, Enctype)
- runFormGet :: MonadHandler m => (Markup -> MForm m a) -> m (a, Enctype)
- generateFormGet' :: MonadHandler m => (Markup -> MForm m (FormResult a, xml)) -> m (xml, Enctype)
- generateFormGet :: MonadHandler m => (Markup -> MForm m a) -> m (a, Enctype)
- identifyForm :: Monad m => Text -> (Markup -> MForm m (FormResult a, WidgetFor (HandlerSite m) ())) -> Markup -> MForm m (FormResult a, WidgetFor (HandlerSite m) ())
- renderTable :: Monad m => FormRender m a
- renderDivs :: Monad m => FormRender m a
- renderDivsNoLabels :: Monad m => FormRender m a
- renderBootstrap2 :: Monad m => FormRender m a
- renderBootstrap :: Monad m => FormRender m a
- check :: (Monad m, RenderMessage (HandlerSite m) msg) => (a -> Either msg a) -> Field m a -> Field m a
- checkBool :: (Monad m, RenderMessage (HandlerSite m) msg) => (a -> Bool) -> msg -> Field m a -> Field m a
- checkM :: (Monad m, RenderMessage (HandlerSite m) msg) => (a -> m (Either msg a)) -> Field m a -> Field m a
- checkMMap :: (Monad m, RenderMessage (HandlerSite m) msg) => (a -> m (Either msg b)) -> (b -> a) -> Field m a -> Field m b
- customErrorMessage :: Monad m => SomeMessage (HandlerSite m) -> Field m a -> Field m a
- fieldSettingsLabel :: RenderMessage site msg => msg -> FieldSettings site
- parseHelper :: (Monad m, RenderMessage site FormMessage) => (Text -> Either FormMessage a) -> [Text] -> [FileInfo] -> m (Either (SomeMessage site) (Maybe a))
- parseHelperGen :: (Monad m, RenderMessage site msg) => (Text -> Either msg a) -> [Text] -> [FileInfo] -> m (Either (SomeMessage site) (Maybe a))
- convertField :: Functor m => (a -> b) -> (b -> a) -> Field m a -> Field m b
- data Option a = Option {}
- data OptionList a = OptionList {
- olOptions :: [Option a]
- olReadExternal :: Text -> Maybe a
- type AutoFocus = Bool
- newtype Textarea = Textarea {
- unTextarea :: Text
- defaultFormMessage :: FormMessage -> Text
- intField :: (Monad m, Integral i, RenderMessage (HandlerSite m) FormMessage) => Field m i
- doubleField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Double
- dayField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Day
- timeField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m TimeOfDay
- timeFieldTypeTime :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m TimeOfDay
- timeFieldTypeText :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m TimeOfDay
- htmlField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Html
- textareaField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Textarea
- hiddenField :: (Monad m, PathPiece p, RenderMessage (HandlerSite m) FormMessage) => Field m p
- textField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Text
- passwordField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Text
- parseDate :: String -> Either FormMessage Day
- parseTime :: Text -> Either FormMessage TimeOfDay
- emailField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Text
- multiEmailField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m [Text]
- searchField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => AutoFocus -> Field m Text
- urlField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Text
- selectFieldList :: (Eq a, RenderMessage site FormMessage, RenderMessage site msg) => [(msg, a)] -> Field (HandlerFor site) a
- selectField :: (Eq a, RenderMessage site FormMessage) => HandlerFor site (OptionList a) -> Field (HandlerFor site) a
- multiSelectFieldList :: (Eq a, RenderMessage site msg) => [(msg, a)] -> Field (HandlerFor site) [a]
- multiSelectField :: Eq a => HandlerFor site (OptionList a) -> Field (HandlerFor site) [a]
- radioFieldList :: (Eq a, RenderMessage site FormMessage, RenderMessage site msg) => [(msg, a)] -> Field (HandlerFor site) a
- checkboxesFieldList :: (Eq a, RenderMessage site msg) => [(msg, a)] -> Field (HandlerFor site) [a]
- checkboxesField :: Eq a => HandlerFor site (OptionList a) -> Field (HandlerFor site) [a]
- radioField :: (Eq a, RenderMessage site FormMessage) => HandlerFor site (OptionList a) -> Field (HandlerFor site) a
- boolField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Bool
- checkBoxField :: Monad m => Field m Bool
- mkOptionList :: [Option a] -> OptionList a
- optionsPairs :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => [(msg, a)] -> m (OptionList a)
- optionsEnum :: (MonadHandler m, Show a, Enum a, Bounded a) => m (OptionList a)
- optionsPersist :: (YesodPersist site, PersistQueryRead backend, PathPiece (Key a), RenderMessage site msg, YesodPersistBackend site ~ backend, PersistRecordBackend a backend) => [Filter a] -> [SelectOpt a] -> (a -> msg) -> HandlerFor site (OptionList (Entity a))
- optionsPersistKey :: (YesodPersist site, PersistQueryRead backend, PathPiece (Key a), RenderMessage site msg, backend ~ YesodPersistBackend site, PersistRecordBackend a backend) => [Filter a] -> [SelectOpt a] -> (a -> msg) -> HandlerFor site (OptionList (Key a))
- fileField :: Monad m => Field m FileInfo
- fileAFormReq :: (MonadHandler m, RenderMessage (HandlerSite m) FormMessage) => FieldSettings (HandlerSite m) -> AForm m FileInfo
- fileAFormOpt :: MonadHandler m => FieldSettings (HandlerSite m) -> AForm m (Maybe FileInfo)
- formatW3 :: UTCTime -> Text
- formatRFC1123 :: UTCTime -> Text
- formatRFC822 :: UTCTime -> Text
- class RenderRoute a => RouteAttrs a where
- class RenderRoute a => ParseRoute a where
- data family Route a :: *
- data SubHandlerFor sub master a
- data Header
- data ErrorResponse
- newtype DontFullyEvaluate a = DontFullyEvaluate {
- unDontFullyEvaluate :: a
- type ContentType = ByteString
- newtype RepXml = RepXml Content
- newtype RepPlain = RepPlain Content
- newtype RepJson = RepJson Content
- type RepHtml = Html
- data TypedContent = TypedContent !ContentType !Content
- data Content
- = ContentBuilder !Builder !(Maybe Int)
- | ContentSource !(ConduitT () (Flush Builder) (ResourceT IO) ())
- | ContentFile !FilePath !(Maybe FilePart)
- | ContentDontEvaluate !Content
- data PageContent url = PageContent {}
- newtype CssBuilder = CssBuilder {}
- data WidgetFor site a
- data HandlerFor site a
- newtype WaiSubsiteWithAuth = WaiSubsiteWithAuth {}
- newtype WaiSubsite = WaiSubsite {}
- type Texts = [Text]
- type BottomOfHeadAsync master = [Text] -> Maybe (HtmlUrl (Route master)) -> HtmlUrl (Route master)
- data ScriptLoadPosition master
- = BottomOfBody
- | BottomOfHeadBlocking
- | BottomOfHeadAsync !(BottomOfHeadAsync master)
- data AuthResult
- data Approot master
- = ApprootRelative
- | ApprootStatic !Text
- | ApprootMaster !(master -> Text)
- | ApprootRequest !(master -> Request -> Text)
- data FileUpload
- = FileUploadMemory !(BackEnd ByteString)
- | FileUploadDisk !(InternalState -> BackEnd FilePath)
- | FileUploadSource !(BackEnd (ConduitT () ByteString (ResourceT IO) ()))
- data FileInfo
- type RequestBodyContents = ([(Text, Text)], [(Text, FileInfo)])
- data YesodRequest = YesodRequest {
- reqGetParams :: ![(Text, Text)]
- reqCookies :: ![(Text, Text)]
- reqWaiRequest :: !Request
- reqLangs :: ![Text]
- reqToken :: !(Maybe Text)
- reqSession :: !SessionMap
- reqAccept :: ![ContentType]
- newtype SessionBackend = SessionBackend {
- sbLoadSession :: Request -> IO (SessionMap, SaveSession)
- type SessionMap = Map Text ByteString
- clientSessionDateCacher :: NominalDiffTime -> IO (IO ClientSessionDateCache, IO ())
- class ToContent a => ToTypedContent a where
- class ToTypedContent a => HasContentType a where
- class ToFlushBuilder a where
- class ToContent a where
- emptyContent :: Content
- repJson :: ToContent a => a -> RepJson
- repPlain :: ToContent a => a -> RepPlain
- repXml :: ToContent a => a -> RepXml
- typeHtml :: ContentType
- typePlain :: ContentType
- typeJson :: ContentType
- typeXml :: ContentType
- typeAtom :: ContentType
- typeRss :: ContentType
- typeJpeg :: ContentType
- typePng :: ContentType
- typeGif :: ContentType
- typeSvg :: ContentType
- typeJavascript :: ContentType
- typeCss :: ContentType
- typeFlv :: ContentType
- typeOgv :: ContentType
- typeOctet :: ContentType
- simpleContentType :: ContentType -> ContentType
- contentTypeTypes :: ContentType -> (ByteString, ByteString)
- class MonadHandler m => MonadWidget (m :: * -> *) where
- class (MonadResource m, MonadLogger m) => MonadHandler (m :: * -> *) where
- type HandlerSite (m :: * -> *) :: *
- type SubHandlerSite (m :: * -> *) :: *
- data ProvidedRep (m :: * -> *)
- data Fragment a b = a :#: b
- class RedirectUrl master a where
- type HandlerT site (m :: * -> *) = HandlerFor site
- getRequest :: MonadHandler m => m YesodRequest
- runRequestBody :: MonadHandler m => m RequestBodyContents
- getYesod :: MonadHandler m => m (HandlerSite m)
- getsYesod :: MonadHandler m => (HandlerSite m -> a) -> m a
- getUrlRender :: MonadHandler m => m (Route (HandlerSite m) -> Text)
- getUrlRenderParams :: MonadHandler m => m (Route (HandlerSite m) -> [(Text, Text)] -> Text)
- getPostParams :: MonadHandler m => m [(Text, Text)]
- getCurrentRoute :: MonadHandler m => m (Maybe (Route (HandlerSite m)))
- handlerToIO :: MonadIO m => HandlerFor site (HandlerFor site a -> m a)
- forkHandler :: (SomeException -> HandlerFor site ()) -> HandlerFor site () -> HandlerFor site ()
- redirect :: (MonadHandler m, RedirectUrl (HandlerSite m) url) => url -> m a
- redirectWith :: (MonadHandler m, RedirectUrl (HandlerSite m) url) => Status -> url -> m a
- setUltDest :: (MonadHandler m, RedirectUrl (HandlerSite m) url) => url -> m ()
- setUltDestCurrent :: MonadHandler m => m ()
- setUltDestReferer :: MonadHandler m => m ()
- redirectUltDest :: (RedirectUrl (HandlerSite m) url, MonadHandler m) => url -> m a
- clearUltDest :: MonadHandler m => m ()
- addMessage :: MonadHandler m => Text -> Html -> m ()
- addMessageI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => Text -> msg -> m ()
- getMessages :: MonadHandler m => m [(Text, Html)]
- setMessage :: MonadHandler m => Html -> m ()
- setMessageI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => msg -> m ()
- getMessage :: MonadHandler m => m (Maybe Html)
- sendFile :: MonadHandler m => ContentType -> FilePath -> m a
- sendFilePart :: MonadHandler m => ContentType -> FilePath -> Integer -> Integer -> m a
- sendResponse :: (MonadHandler m, ToTypedContent c) => c -> m a
- sendResponseStatus :: (MonadHandler m, ToTypedContent c) => Status -> c -> m a
- sendStatusJSON :: (MonadHandler m, ToJSON c) => Status -> c -> m a
- sendResponseCreated :: MonadHandler m => Route (HandlerSite m) -> m a
- sendWaiResponse :: MonadHandler m => Response -> m b
- sendWaiApplication :: MonadHandler m => Application -> m b
- sendRawResponseNoConduit :: (MonadHandler m, MonadUnliftIO m) => (IO ByteString -> (ByteString -> IO ()) -> m ()) -> m a
- sendRawResponse :: (MonadHandler m, MonadUnliftIO m) => (ConduitT () ByteString IO () -> ConduitT ByteString Void IO () -> m ()) -> m a
- notModified :: MonadHandler m => m a
- notFound :: MonadHandler m => m a
- badMethod :: MonadHandler m => m a
- notAuthenticated :: MonadHandler m => m a
- permissionDenied :: MonadHandler m => Text -> m a
- permissionDeniedI :: (RenderMessage (HandlerSite m) msg, MonadHandler m) => msg -> m a
- invalidArgs :: MonadHandler m => [Text] -> m a
- invalidArgsI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => [msg] -> m a
- setCookie :: MonadHandler m => SetCookie -> m ()
- getExpires :: MonadIO m => Int -> m UTCTime
- deleteCookie :: MonadHandler m => Text -> Text -> m ()
- setLanguage :: MonadHandler m => Text -> m ()
- addContentDispositionFileName :: MonadHandler m => Text -> m ()
- addHeader :: MonadHandler m => Text -> Text -> m ()
- setHeader :: MonadHandler m => Text -> Text -> m ()
- replaceOrAddHeader :: MonadHandler m => Text -> Text -> m ()
- cacheSeconds :: MonadHandler m => Int -> m ()
- neverExpires :: MonadHandler m => m ()
- alreadyExpired :: MonadHandler m => m ()
- expiresAt :: MonadHandler m => UTCTime -> m ()
- setEtag :: MonadHandler m => Text -> m ()
- setWeakEtag :: MonadHandler m => Text -> m ()
- setSession :: MonadHandler m => Text -> Text -> m ()
- setSessionBS :: MonadHandler m => Text -> ByteString -> m ()
- deleteSession :: MonadHandler m => Text -> m ()
- clearSession :: MonadHandler m => m ()
- lookupSession :: MonadHandler m => Text -> m (Maybe Text)
- lookupSessionBS :: MonadHandler m => Text -> m (Maybe ByteString)
- getSession :: MonadHandler m => m SessionMap
- newIdent :: MonadHandler m => m Text
- redirectToPost :: (MonadHandler m, RedirectUrl (HandlerSite m) url) => url -> m a
- hamletToRepHtml :: MonadHandler m => HtmlUrl (Route (HandlerSite m)) -> m Html
- giveUrlRenderer :: MonadHandler m => ((Route (HandlerSite m) -> [(Text, Text)] -> Text) -> output) -> m output
- withUrlRenderer :: MonadHandler m => ((Route (HandlerSite m) -> [(Text, Text)] -> Text) -> output) -> m output
- waiRequest :: MonadHandler m => m Request
- getMessageRender :: (MonadHandler m, RenderMessage (HandlerSite m) message) => m (message -> Text)
- cached :: (MonadHandler m, Typeable a) => m a -> m a
- cachedBy :: (MonadHandler m, Typeable a) => ByteString -> m a -> m a
- languages :: MonadHandler m => m [Text]
- lookupHeader :: MonadHandler m => CI ByteString -> m (Maybe ByteString)
- lookupHeaders :: MonadHandler m => CI ByteString -> m [ByteString]
- lookupBasicAuth :: MonadHandler m => m (Maybe (Text, Text))
- lookupBearerAuth :: MonadHandler m => m (Maybe Text)
- lookupGetParams :: MonadHandler m => Text -> m [Text]
- lookupGetParam :: MonadHandler m => Text -> m (Maybe Text)
- lookupPostParams :: (MonadResource m, MonadHandler m) => Text -> m [Text]
- lookupPostParam :: (MonadResource m, MonadHandler m) => Text -> m (Maybe Text)
- lookupFile :: MonadHandler m => Text -> m (Maybe FileInfo)
- lookupFiles :: MonadHandler m => Text -> m [FileInfo]
- lookupCookie :: MonadHandler m => Text -> m (Maybe Text)
- lookupCookies :: MonadHandler m => Text -> m [Text]
- selectRep :: MonadHandler m => Writer (Endo [ProvidedRep m]) () -> m TypedContent
- provideRep :: (Monad m, HasContentType a) => m a -> Writer (Endo [ProvidedRep m]) ()
- provideRepType :: (Monad m, ToContent a) => ContentType -> m a -> Writer (Endo [ProvidedRep m]) ()
- rawRequestBody :: MonadHandler m => ConduitT i ByteString m ()
- fileSource :: MonadResource m => FileInfo -> ConduitT () ByteString m ()
- fileSourceByteString :: MonadResource m => FileInfo -> m ByteString
- respond :: (Monad m, ToContent a) => ContentType -> a -> m TypedContent
- respondSource :: ContentType -> ConduitT () (Flush Builder) (HandlerFor site) () -> HandlerFor site TypedContent
- sendChunk :: (Monad m, ToFlushBuilder a) => a -> ConduitT i (Flush Builder) m ()
- sendFlush :: Monad m => ConduitT i (Flush Builder) m ()
- sendChunkBS :: Monad m => ByteString -> ConduitT i (Flush Builder) m ()
- sendChunkLBS :: Monad m => ByteString -> ConduitT i (Flush Builder) m ()
- sendChunkText :: Monad m => Text -> ConduitT i (Flush Builder) m ()
- sendChunkLazyText :: Monad m => Text -> ConduitT i (Flush Builder) m ()
- sendChunkHtml :: Monad m => Html -> ConduitT i (Flush Builder) m ()
- defaultCsrfCookieName :: ByteString
- setCsrfCookie :: MonadHandler m => m ()
- setCsrfCookieWithCookie :: MonadHandler m => SetCookie -> m ()
- defaultCsrfHeaderName :: CI ByteString
- checkCsrfHeaderNamed :: MonadHandler m => CI ByteString -> m ()
- hasValidCsrfHeaderNamed :: MonadHandler m => CI ByteString -> m Bool
- defaultCsrfParamName :: Text
- checkCsrfParamNamed :: MonadHandler m => Text -> m ()
- hasValidCsrfParamNamed :: MonadHandler m => Text -> m Bool
- checkCsrfHeaderOrParam :: (MonadHandler m, MonadLogger m) => CI ByteString -> Text -> m ()
- getSubYesod :: MonadHandler m => m (SubHandlerSite m)
- getRouteToParent :: MonadHandler m => m (Route (SubHandlerSite m) -> Route (HandlerSite m))
- getSubCurrentRoute :: MonadHandler m => m (Maybe (Route (SubHandlerSite m)))
- class ToWidgetHead site a where
- class ToWidgetBody site a where
- class ToWidgetMedia site a where
- class ToWidget site a where
- type WidgetT site (m :: * -> *) = WidgetFor site
- setTitle :: MonadWidget m => Html -> m ()
- setTitleI :: (MonadWidget m, RenderMessage (HandlerSite m) msg) => msg -> m ()
- addStylesheet :: MonadWidget m => Route (HandlerSite m) -> m ()
- addStylesheetAttrs :: MonadWidget m => Route (HandlerSite m) -> [(Text, Text)] -> m ()
- addStylesheetRemote :: MonadWidget m => Text -> m ()
- addStylesheetRemoteAttrs :: MonadWidget m => Text -> [(Text, Text)] -> m ()
- addStylesheetEither :: MonadWidget m => Either (Route (HandlerSite m)) Text -> m ()
- addScriptEither :: MonadWidget m => Either (Route (HandlerSite m)) Text -> m ()
- addScript :: MonadWidget m => Route (HandlerSite m) -> m ()
- addScriptAttrs :: MonadWidget m => Route (HandlerSite m) -> [(Text, Text)] -> m ()
- addScriptRemote :: MonadWidget m => Text -> m ()
- addScriptRemoteAttrs :: MonadWidget m => Text -> [(Text, Text)] -> m ()
- whamlet :: QuasiQuoter
- whamletFile :: FilePath -> Q Exp
- whamletFileWithSettings :: HamletSettings -> FilePath -> Q Exp
- asWidgetT :: WidgetT site m () -> WidgetT site m ()
- ihamletToRepHtml :: (MonadHandler m, RenderMessage (HandlerSite m) message) => HtmlUrlI18n message (Route (HandlerSite m)) -> m Html
- ihamletToHtml :: (MonadHandler m, RenderMessage (HandlerSite m) message) => HtmlUrlI18n message (Route (HandlerSite m)) -> m Html
- handlerToWidget :: HandlerFor site a -> WidgetFor site a
- class RenderRoute site => Yesod site where
- defaultMakeLogger :: IO Logger
- defaultMessageLoggerSource :: (LogSource -> LogLevel -> IO Bool) -> Logger -> Loc -> LogSource -> LogLevel -> LogStr -> IO ()
- defaultShouldLogIO :: LogSource -> LogLevel -> IO Bool
- defaultYesodMiddleware :: Yesod site => HandlerFor site res -> HandlerFor site res
- sslOnlySessions :: IO (Maybe SessionBackend) -> IO (Maybe SessionBackend)
- laxSameSiteSessions :: IO (Maybe SessionBackend) -> IO (Maybe SessionBackend)
- strictSameSiteSessions :: IO (Maybe SessionBackend) -> IO (Maybe SessionBackend)
- sslOnlyMiddleware :: Int -> HandlerFor site res -> HandlerFor site res
- authorizationCheck :: Yesod site => HandlerFor site ()
- defaultCsrfCheckMiddleware :: Yesod site => HandlerFor site res -> HandlerFor site res
- csrfCheckMiddleware :: HandlerFor site res -> HandlerFor site Bool -> CI ByteString -> Text -> HandlerFor site res
- defaultCsrfSetCookieMiddleware :: HandlerFor site res -> HandlerFor site res
- csrfSetCookieMiddleware :: HandlerFor site res -> SetCookie -> HandlerFor site res
- defaultCsrfMiddleware :: Yesod site => HandlerFor site res -> HandlerFor site res
- widgetToPageContent :: Yesod site => WidgetFor site () -> HandlerFor site (PageContent (Route site))
- defaultErrorHandler :: Yesod site => ErrorResponse -> HandlerFor site TypedContent
- formatLogMessage :: IO ZonedDate -> Loc -> LogSource -> LogLevel -> LogStr -> IO LogStr
- customizeSessionCookies :: (SetCookie -> SetCookie) -> SessionBackend -> SessionBackend
- defaultClientSessionBackend :: Int -> FilePath -> IO SessionBackend
- envClientSessionBackend :: Int -> String -> IO SessionBackend
- clientSessionBackend :: Key -> IO ClientSessionDateCache -> SessionBackend
- loadClientSession :: Key -> IO ClientSessionDateCache -> ByteString -> Request -> IO (SessionMap, SaveSession)
- guessApproot :: Approot site
- guessApprootOr :: Approot site -> Approot site
- getApprootText :: Approot site -> site -> Request -> Text
- defaultLayoutJson :: (Yesod site, ToJSON a) => WidgetFor site () -> HandlerFor site a -> HandlerFor site TypedContent
- jsonToRepJson :: (Monad m, ToJSON a) => a -> m Value
- returnJson :: (Monad m, ToJSON a) => a -> m Value
- returnJsonEncoding :: (Monad m, ToJSON a) => a -> m Encoding
- provideJson :: (Monad m, ToJSON a) => a -> Writer (Endo [ProvidedRep m]) ()
- parseJsonBody :: (MonadHandler m, FromJSON a) => m (Result a)
- parseCheckJsonBody :: (MonadHandler m, FromJSON a) => m (Result a)
- parseJsonBody_ :: (MonadHandler m, FromJSON a) => m a
- requireJsonBody :: (MonadHandler m, FromJSON a) => m a
- requireCheckJsonBody :: (MonadHandler m, FromJSON a) => m a
- array :: ToJSON a => [a] -> Value
- jsonOrRedirect :: (MonadHandler m, ToJSON a) => Route (HandlerSite m) -> a -> m Value
- jsonEncodingOrRedirect :: (MonadHandler m, ToJSON a) => Route (HandlerSite m) -> a -> m Encoding
- acceptsJson :: MonadHandler m => m Bool
- yesodRunner :: (ToTypedContent res, Yesod site) => HandlerFor site res -> YesodRunnerEnv site -> Maybe (Route site) -> Application
- yesodRender :: Yesod y => y -> ResolvedApproot -> Route y -> [(Text, Text)] -> Text
- class YesodSubDispatch sub master where
- class Yesod site => YesodDispatch site where
- type LiteWidget = WidgetFor LiteApp
- type LiteHandler = HandlerFor LiteApp
- newtype LiteApp = LiteApp {
- unLiteApp :: Method -> [Text] -> Maybe (LiteHandler TypedContent)
- liteApp :: Writer LiteApp () -> LiteApp
- dispatchTo :: ToTypedContent a => LiteHandler a -> Writer LiteApp ()
- onMethod :: Method -> Writer LiteApp () -> Writer LiteApp ()
- onStatic :: Text -> Writer LiteApp () -> Writer LiteApp ()
- withDynamic :: PathPiece p => (p -> Writer LiteApp ()) -> Writer LiteApp ()
- withDynamicMulti :: PathMultiPiece ps => (ps -> Writer LiteApp ()) -> Writer LiteApp ()
- class YesodBreadcrumbs site where
- breadcrumbs :: YesodBreadcrumbs site => HandlerFor site (Text, [(Route site, Text)])
- parseRoutes :: QuasiQuoter
- parseRoutesFile :: FilePath -> Q Exp
- parseRoutesFileNoCheck :: FilePath -> Q Exp
- parseRoutesNoCheck :: QuasiQuoter
- mkYesod :: String -> [ResourceTree String] -> Q [Dec]
- mkYesodWith :: [[String]] -> String -> [String] -> [ResourceTree String] -> Q [Dec]
- mkYesodData :: String -> [ResourceTree String] -> Q [Dec]
- mkYesodSubData :: String -> [ResourceTree String] -> Q [Dec]
- mkYesodDispatch :: String -> [ResourceTree String] -> Q [Dec]
- mkYesodSubDispatch :: [ResourceTree a] -> Q Exp
- toWaiAppPlain :: YesodDispatch site => site -> IO Application
- toWaiAppYre :: YesodDispatch site => YesodRunnerEnv site -> Application
- toWaiApp :: YesodDispatch site => site -> IO Application
- warp :: YesodDispatch site => Int -> site -> IO ()
- mkDefaultMiddlewares :: Logger -> IO Middleware
- defaultMiddlewaresNoLogging :: Middleware
- warpDebug :: YesodDispatch site => Int -> site -> IO ()
- warpEnv :: YesodDispatch site => site -> IO ()
- getGetMaxExpires :: IO (IO Text)
- runFakeHandler :: (Yesod site, MonadIO m) => SessionMap -> (site -> Logger) -> site -> HandlerT site IO a -> m (Either ErrorResponse a)
- unauthorizedI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => msg -> m AuthResult
- yesodVersion :: String
- maybeAuthorized :: Yesod site => Route site -> Bool -> HandlerT site IO (Maybe (Route site))
- showIntegral :: Integral a => a -> String
- readIntegral :: Num a => String -> Maybe a
- data Extra = Extra {}
- development :: Bool
- production :: Bool
- hledgerorgurl :: Text
- manualurl :: Text
- defhost :: String
- defport :: Int
- defbaseurl :: String -> Int -> String
- staticDir :: FilePath
- staticRoot :: AppConfig DefaultEnv Extra -> Text
- widgetFileSettings :: WidgetFileSettings
- widgetFile :: String -> Q Exp
- parseExtra :: DefaultEnv -> Object -> Parser Extra
- staticSite :: IO Static
- hledger_js :: StaticRoute
- hledger_css :: StaticRoute
- css_bootstrap_min_css :: StaticRoute
- css_bootstrap_theme_css :: StaticRoute
- css_bootstrap_theme_min_css :: StaticRoute
- css_bootstrap_theme_css_map :: StaticRoute
- css_bootstrap_css_map :: StaticRoute
- css_bootstrap_datepicker_standalone_min_css :: StaticRoute
- css_bootstrap_css :: StaticRoute
- js_jquery_flot_categories_js :: StaticRoute
- js_jquery_flot_errorbars_min_js :: StaticRoute
- js_jquery_flot_canvas_js :: StaticRoute
- js_jquery_flot_image_js :: StaticRoute
- js_jquery_cookie_js :: StaticRoute
- js_jquery_flot_stack_min_js :: StaticRoute
- js_jquery_flot_image_min_js :: StaticRoute
- js_excanvas_js :: StaticRoute
- js_excanvas_min_js :: StaticRoute
- js_jquery_flot_time_js :: StaticRoute
- js_bootstrap_datepicker_min_js :: StaticRoute
- js_jquery_flot_categories_min_js :: StaticRoute
- js_jquery_flot_js :: StaticRoute
- js_jquery_flot_threshold_js :: StaticRoute
- js_jquery_hotkeys_js :: StaticRoute
- js_jquery_flot_fillbetween_js :: StaticRoute
- js_jquery_flot_tooltip_min_js :: StaticRoute
- js_typeahead_bundle_min_js :: StaticRoute
- js_jquery_flot_threshold_min_js :: StaticRoute
- js_jquery_flot_navigate_min_js :: StaticRoute
- js_jquery_flot_resize_js :: StaticRoute
- js_jquery_flot_symbol_min_js :: StaticRoute
- js_bootstrap_js :: StaticRoute
- js_jquery_flot_selection_js :: StaticRoute
- js_jquery_flot_crosshair_js :: StaticRoute
- js_jquery_js :: StaticRoute
- js_bootstrap_min_js :: StaticRoute
- js_jquery_flot_selection_min_js :: StaticRoute
- js_jquery_flot_resize_min_js :: StaticRoute
- js_jquery_min_js :: StaticRoute
- js_typeahead_bundle_js :: StaticRoute
- js_jquery_flot_time_min_js :: StaticRoute
- js_jquery_flot_tooltip_js :: StaticRoute
- js_jquery_flot_min_js :: StaticRoute
- js_jquery_flot_pie_min_js :: StaticRoute
- js_jquery_flot_canvas_min_js :: StaticRoute
- js_jquery_flot_crosshair_min_js :: StaticRoute
- js_jquery_flot_errorbars_js :: StaticRoute
- js_jquery_flot_navigate_js :: StaticRoute
- js_jquery_url_js :: StaticRoute
- js_jquery_flot_fillbetween_min_js :: StaticRoute
- js_jquery_flot_symbol_js :: StaticRoute
- js_jquery_flot_stack_js :: StaticRoute
- js_jquery_flot_pie_js :: StaticRoute
- fonts_glyphicons_halflings_regular_woff :: StaticRoute
- fonts_glyphicons_halflings_regular_eot :: StaticRoute
- fonts_glyphicons_halflings_regular_ttf :: StaticRoute
- fonts_glyphicons_halflings_regular_svg :: StaticRoute
- data Capability
- data App = App {}
- data ViewData = VD {}
- type Form x = Html -> MForm (HandlerFor App) (FormResult x, Widget)
- type AppRoute = Route App
- type Widget = WidgetFor App ()
- type Handler = HandlerFor App
- resourcesApp :: [ResourceTree String]
- getViewData :: Handler ViewData
- shouldShowSidebar :: Handler Bool
- getCurrentJournal :: IORef Journal -> CliOpts -> Day -> Handler (Journal, Maybe String)
Documentation
(++) :: [a] -> [a] -> [a] infixr 5 #
Append two lists, i.e.,
[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn] [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
If the first list is not finite, the result is the first list.
The value of seq a b is bottom if a is bottom, and
otherwise equal to b. In other words, it evaluates the first
argument a to weak head normal form (WHNF). seq is usually
introduced to improve performance by avoiding unneeded laziness.
A note on evaluation order: the expression seq a b does
not guarantee that a will be evaluated before b.
The only guarantee given by seq is that the both a
and b will be evaluated before seq returns a value.
In particular, this means that b may be evaluated before
a. If you need to guarantee a specific order of evaluation,
you must use the function pseq from the "parallel" package.
filter :: (a -> Bool) -> [a] -> [a] #
filter, applied to a predicate and a list, returns the list of
those elements that satisfy the predicate; i.e.,
filter p xs = [ x | x <- xs, p x]
print :: Show a => a -> IO () #
The print function outputs a value of any printable type to the
standard output device.
Printable types are those that are instances of class Show; print
converts values to strings for output using the show operation and
adds a newline.
For example, a program to print the first 20 integers and their powers of 2 could be written as:
main = print ([(n, 2^n) | n <- [0..19]])
map :: (a -> b) -> [a] -> [b] #
map f xs is the list obtained by applying f to each element
of xs, i.e.,
map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn] map f [x1, x2, ...] == [f x1, f x2, ...]
($) :: (a -> b) -> a -> b infixr 0 #
Application operator. This operator is redundant, since ordinary
application (f x) means the same as (f . However, $ x)$ has
low, right-associative binding precedence, so it sometimes allows
parentheses to be omitted; for example:
f $ g $ h x = f (g (h x))
It is also useful in higher-order situations, such as map ($ 0) xszipWith ($) fs xs
fromIntegral :: (Integral a, Num b) => a -> b #
general coercion from integral types
realToFrac :: (Real a, Fractional b) => a -> b #
general coercion to fractional types
guard :: Alternative f => Bool -> f () #
Conditional failure of Alternative computations. Defined by
guard True =pure() guard False =empty
Examples
Common uses of guard include conditionally signaling an error in
an error monad and conditionally rejecting the current choice in an
Alternative-based parser.
As an example of signaling an error in the error monad Maybe,
consider a safe division function safeDiv x y that returns
Nothing when the denominator y is zero and Just (x `div`
y)
>>> safeDiv 4 0 Nothing >>> safeDiv 4 2 Just 2
A definition of safeDiv using guards, but not guard:
safeDiv :: Int -> Int -> Maybe Int
safeDiv x y | y /= 0 = Just (x `div` y)
| otherwise = Nothing
A definition of safeDiv using guard and Monad do-notation:
safeDiv :: Int -> Int -> Maybe Int safeDiv x y = do guard (y /= 0) return (x `div` y)
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.
The Bounded class is used to name the upper and lower limits of a
type. Ord is not a superclass of Bounded since types that are not
totally ordered may also have upper and lower bounds.
The Bounded class may be derived for any enumeration type;
minBound is the first constructor listed in the data declaration
and maxBound is the last.
Bounded may also be derived for single-constructor datatypes whose
constituent types are in Bounded.
Instances
Class Enum defines operations on sequentially ordered types.
The enumFrom... methods are used in Haskell's translation of
arithmetic sequences.
Instances of Enum may be derived for any enumeration type (types
whose constructors have no fields). The nullary constructors are
assumed to be numbered left-to-right by fromEnum from 0 through n-1.
See Chapter 10 of the Haskell Report for more details.
For any type that is an instance of class Bounded as well as Enum,
the following should hold:
- The calls
succmaxBoundpredminBound fromEnumandtoEnumshould give a runtime error if the result value is not representable in the result type. For example,toEnum7 ::BoolenumFromandenumFromThenshould be defined with an implicit bound, thus:
enumFrom x = enumFromTo x maxBound
enumFromThen x y = enumFromThenTo x y bound
where
bound | fromEnum y >= fromEnum x = maxBound
| otherwise = minBoundMethods
the successor of a value. For numeric types, succ adds 1.
the predecessor of a value. For numeric types, pred subtracts 1.
Convert from an Int.
Convert to an Int.
It is implementation-dependent what fromEnum returns when
applied to a value that is too large to fit in an Int.
Used in Haskell's translation of [n..].
enumFromThen :: a -> a -> [a] #
Used in Haskell's translation of [n,n'..].
enumFromTo :: a -> a -> [a] #
Used in Haskell's translation of [n..m].
enumFromThenTo :: a -> a -> a -> [a] #
Used in Haskell's translation of [n,n'..m].
Instances
The Eq class defines equality (==) and inequality (/=).
All the basic datatypes exported by the Prelude are instances of Eq,
and Eq may be derived for any datatype whose constituents are also
instances of Eq.
Instances
class Fractional a => Floating a where #
Trigonometric and hyperbolic functions and related functions.
Minimal complete definition
pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh
Instances
class Num a => Fractional a where #
Fractional numbers, supporting real division.
Minimal complete definition
fromRational, (recip | (/))
Methods
fractional division
reciprocal fraction
fromRational :: Rational -> a #
Conversion from a Rational (that is Ratio IntegerfromRational
to a value of type Rational, so such literals have type
(.Fractional a) => a
Instances
class (Real a, Enum a) => Integral a where #
Integral numbers, supporting integer division.
Methods
quot :: a -> a -> a infixl 7 #
integer division truncated toward zero
integer remainder, satisfying
(x `quot` y)*y + (x `rem` y) == x
integer division truncated toward negative infinity
integer modulus, satisfying
(x `div` y)*y + (x `mod` y) == x
conversion to Integer
Instances
class Applicative m => Monad (m :: * -> *) where #
The Monad class defines the basic operations over a monad,
a concept from a branch of mathematics known as category theory.
From the perspective of a Haskell programmer, however, it is best to
think of a monad as an abstract datatype of actions.
Haskell's do expressions provide a convenient syntax for writing
monadic expressions.
Instances of Monad should satisfy the following laws:
Furthermore, the Monad and Applicative operations should relate as follows:
The above laws imply:
and that pure and (<*>) satisfy the applicative functor laws.
The instances of Monad for lists, Maybe and IO
defined in the Prelude satisfy these laws.
Minimal complete definition
Methods
(>>=) :: m a -> (a -> m b) -> m b infixl 1 #
Sequentially compose two actions, passing any value produced by the first as an argument to the second.
(>>) :: m a -> m b -> m b infixl 1 #
Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.
Inject a value into the monadic type.
Fail with a message. This operation is not part of the
mathematical definition of a monad, but is invoked on pattern-match
failure in a do expression.
As part of the MonadFail proposal (MFP), this function is moved
to its own class MonadFail (see Control.Monad.Fail for more
details). The definition here will be removed in a future
release.
Instances
| Monad [] | Since: base-2.1 |
| Monad Maybe | Since: base-2.1 |
| Monad IO | Since: base-2.1 |
| Monad Par1 | Since: base-4.9.0.0 |
| Monad Q | |
| Monad IResult | |
| Monad Result | |
| Monad Parser | |
| Monad Complex | Since: base-4.9.0.0 |
| Monad Min | Since: base-4.9.0.0 |
| Monad Max | Since: base-4.9.0.0 |
| Monad First | Since: base-4.9.0.0 |
| Monad Last | Since: base-4.9.0.0 |
| Monad Option | Since: base-4.9.0.0 |
| Monad Identity | Since: base-4.8.0.0 |
| Monad First | |
| Monad Last | |
| Monad Dual | Since: base-4.8.0.0 |
| Monad Sum | Since: base-4.8.0.0 |
| Monad Product | Since: base-4.8.0.0 |
| Monad ReadPrec | Since: base-2.1 |
| Monad ReadP | Since: base-2.1 |
| Monad NonEmpty | Since: base-4.9.0.0 |
| Monad MarkupM | |
| Monad Put | |
| Monad Tree | |
| Monad Seq | |
| Monad CryptoFailable | |
Defined in Crypto.Error.Types Methods (>>=) :: CryptoFailable a -> (a -> CryptoFailable b) -> CryptoFailable b # (>>) :: CryptoFailable a -> CryptoFailable b -> CryptoFailable b # return :: a -> CryptoFailable a # fail :: String -> CryptoFailable a # | |
| Monad DList | |
| Monad Result | |
| Monad SmallArray | |
Defined in Data.Primitive.SmallArray Methods (>>=) :: SmallArray a -> (a -> SmallArray b) -> SmallArray b # (>>) :: SmallArray a -> SmallArray b -> SmallArray b # return :: a -> SmallArray a # fail :: String -> SmallArray a # | |
| Monad Array | |
| Monad Result | |
| Monad Vector | |
| Monad Id | |
| Monad Box | |
| Monad Stream | |
| Monad P | Since: base-2.1 |
| Monad (Either e) | Since: base-4.4.0.0 |
| Monad (U1 :: * -> *) | Since: base-4.9.0.0 |
| Monoid a => Monad ((,) a) | Since: base-4.9.0.0 |
| Monad (ST s) | Since: base-2.1 |
| Monad (Parser i) | |
| Monad m => Monad (WrappedMonad m) | |
Defined in Control.Applicative Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # return :: a -> WrappedMonad m a # fail :: String -> WrappedMonad m a # | |
| Monad (Proxy :: * -> *) | Since: base-4.7.0.0 |
| Monad m => Monad (MaybeT m) | |
| Monad m => Monad (ResourceT m) | |
| Functor f => Monad (Free f) | |
| Monad m => Monad (ListT m) | |
| Monad m => Monad (NoLoggingT m) | |
Defined in Control.Monad.Logger Methods (>>=) :: NoLoggingT m a -> (a -> NoLoggingT m b) -> NoLoggingT m b # (>>) :: NoLoggingT m a -> NoLoggingT m b -> NoLoggingT m b # return :: a -> NoLoggingT m a # fail :: String -> NoLoggingT m a # | |
| Monad m => Monad (WriterLoggingT m) | |
Defined in Control.Monad.Logger Methods (>>=) :: WriterLoggingT m a -> (a -> WriterLoggingT m b) -> WriterLoggingT m b # (>>) :: WriterLoggingT m a -> WriterLoggingT m b -> WriterLoggingT m b # return :: a -> WriterLoggingT m a # fail :: String -> WriterLoggingT m a # | |
| Monad m => Monad (LoggingT m) | |
| Monad (WidgetFor site) | |
| Monad (HandlerFor site) | |
Defined in Yesod.Core.Types Methods (>>=) :: HandlerFor site a -> (a -> HandlerFor site b) -> HandlerFor site b # (>>) :: HandlerFor site a -> HandlerFor site b -> HandlerFor site b # return :: a -> HandlerFor site a # fail :: String -> HandlerFor site a # | |
| Monad m => Monad (PErrorT m) | |
| Monad f => Monad (Rec1 f) | Since: base-4.9.0.0 |
| Monad f => Monad (Alt f) | |
| (Monoid w, Monad m) => Monad (WriterT w m) | |
| (Monoid w, Monad m) => Monad (WriterT w m) | |
| Monad m => Monad (StateT s m) | |
| Monad m => Monad (StateT s m) | |
| Monad m => Monad (ExceptT e m) | |
| (Applicative f, Monad f) => Monad (WhenMissing f x) | Equivalent to Since: containers-0.5.9 |
Defined in Data.IntMap.Internal Methods (>>=) :: WhenMissing f x a -> (a -> WhenMissing f x b) -> WhenMissing f x b # (>>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # return :: a -> WhenMissing f x a # fail :: String -> WhenMissing f x a # | |
| (Functor f, Monad m) => Monad (FreeT f m) | |
| (Monad m, Error e) => Monad (ErrorT e m) | |
| Monad m => Monad (IdentityT m) | |
| Monad (Tagged s) | |
| Monad (SubHandlerFor child master) | |
Defined in Yesod.Core.Types Methods (>>=) :: SubHandlerFor child master a -> (a -> SubHandlerFor child master b) -> SubHandlerFor child master b # (>>) :: SubHandlerFor child master a -> SubHandlerFor child master b -> SubHandlerFor child master b # return :: a -> SubHandlerFor child master a # fail :: String -> SubHandlerFor child master a # | |
| Monad ((->) r :: * -> *) | Since: base-2.1 |
| (Monad f, Monad g) => Monad (f :*: g) | Since: base-4.9.0.0 |
| (Monad f, Monad g) => Monad (Product f g) | Since: base-4.9.0.0 |
| Monad m => Monad (ReaderT r m) | |
| Monad (ConduitT i o m) | |
| (Monad f, Applicative f) => Monad (WhenMatched f x y) | Equivalent to Since: containers-0.5.9 |
Defined in Data.IntMap.Internal Methods (>>=) :: WhenMatched f x y a -> (a -> WhenMatched f x y b) -> WhenMatched f x y b # (>>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # return :: a -> WhenMatched f x y a # fail :: String -> WhenMatched f x y a # | |
| (Applicative f, Monad f) => Monad (WhenMissing f k x) | Equivalent to Since: containers-0.5.9 |
Defined in Data.Map.Internal Methods (>>=) :: WhenMissing f k x a -> (a -> WhenMissing f k x b) -> WhenMissing f k x b # (>>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # return :: a -> WhenMissing f k x a # fail :: String -> WhenMissing f k x a # | |
| Stream s => Monad (ParsecT e s m) |
|
| Monad f => Monad (M1 i c f) | Since: base-4.9.0.0 |
| (Monoid w, Monad m) => Monad (RWST r w s m) | |
| (Monoid w, Monad m) => Monad (RWST r w s m) | |
| (Monad f, Applicative f) => Monad (WhenMatched f k x y) | Equivalent to Since: containers-0.5.9 |
Defined in Data.Map.Internal Methods (>>=) :: WhenMatched f k x y a -> (a -> WhenMatched f k x y b) -> WhenMatched f k x y b # (>>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # return :: a -> WhenMatched f k x y a # fail :: String -> WhenMatched f k x y a # | |
| Monad state => Monad (Builder collection mutCollection step state err) | |
Defined in Basement.MutableBuilder Methods (>>=) :: Builder collection mutCollection step state err a -> (a -> Builder collection mutCollection step state err b) -> Builder collection mutCollection step state err b # (>>) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err b # return :: a -> Builder collection mutCollection step state err a # fail :: String -> Builder collection mutCollection step state err a # | |
| Monad m => Monad (Pipe l i o u m) | |
class Functor (f :: * -> *) where #
The Functor class is used for types that can be mapped over.
Instances of Functor should satisfy the following laws:
fmap id == id fmap (f . g) == fmap f . fmap g
The instances of Functor for lists, Maybe and IO
satisfy these laws.
Minimal complete definition
Instances
Basic numeric class.
Methods
Unary negation.
Absolute value.
Sign of a number.
The functions abs and signum should satisfy the law:
abs x * signum x == x
For real numbers, the signum is either -1 (negative), 0 (zero)
or 1 (positive).
fromInteger :: Integer -> a #
Conversion from an Integer.
An integer literal represents the application of the function
fromInteger to the appropriate value of type Integer,
so such literals have type (.Num a) => a
Instances
The Ord class is used for totally ordered datatypes.
Instances of Ord can be derived for any user-defined
datatype whose constituent types are in Ord. The declared order
of the constructors in the data declaration determines the ordering
in derived Ord instances. The Ordering datatype allows a single
comparison to determine the precise ordering of two objects.
Minimal complete definition: either compare or <=.
Using compare can be more efficient for complex types.
Methods
compare :: a -> a -> Ordering #
(<) :: a -> a -> Bool infix 4 #
(<=) :: a -> a -> Bool infix 4 #
(>) :: a -> a -> Bool infix 4 #
Instances
Parsing of Strings, producing values.
Derived instances of Read make the following assumptions, which
derived instances of Show obey:
- If the constructor is defined to be an infix operator, then the
derived
Readinstance will parse only infix applications of the constructor (not the prefix form). - Associativity is not used to reduce the occurrence of parentheses, although precedence may be.
- If the constructor is defined using record syntax, the derived
Readwill parse only the record-syntax form, and furthermore, the fields must be given in the same order as the original declaration. - The derived
Readinstance allows arbitrary Haskell whitespace between tokens of the input string. Extra parentheses are also allowed.
For example, given the declarations
infixr 5 :^: data Tree a = Leaf a | Tree a :^: Tree a
the derived instance of Read in Haskell 2010 is equivalent to
instance (Read a) => Read (Tree a) where
readsPrec d r = readParen (d > app_prec)
(\r -> [(Leaf m,t) |
("Leaf",s) <- lex r,
(m,t) <- readsPrec (app_prec+1) s]) r
++ readParen (d > up_prec)
(\r -> [(u:^:v,w) |
(u,s) <- readsPrec (up_prec+1) r,
(":^:",t) <- lex s,
(v,w) <- readsPrec (up_prec+1) t]) r
where app_prec = 10
up_prec = 5Note that right-associativity of :^: is unused.
The derived instance in GHC is equivalent to
instance (Read a) => Read (Tree a) where
readPrec = parens $ (prec app_prec $ do
Ident "Leaf" <- lexP
m <- step readPrec
return (Leaf m))
+++ (prec up_prec $ do
u <- step readPrec
Symbol ":^:" <- lexP
v <- step readPrec
return (u :^: v))
where app_prec = 10
up_prec = 5
readListPrec = readListPrecDefaultWhy do both readsPrec and readPrec exist, and why does GHC opt to
implement readPrec in derived Read instances instead of readsPrec?
The reason is that readsPrec is based on the ReadS type, and although
ReadS is mentioned in the Haskell 2010 Report, it is not a very efficient
parser data structure.
readPrec, on the other hand, is based on a much more efficient ReadPrec
datatype (a.k.a "new-style parsers"), but its definition relies on the use
of the RankNTypes language extension. Therefore, readPrec (and its
cousin, readListPrec) are marked as GHC-only. Nevertheless, it is
recommended to use readPrec instead of readsPrec whenever possible
for the efficiency improvements it brings.
As mentioned above, derived Read instances in GHC will implement
readPrec instead of readsPrec. The default implementations of
readsPrec (and its cousin, readList) will simply use readPrec under
the hood. If you are writing a Read instance by hand, it is recommended
to write it like so:
instanceReadT wherereadPrec= ...readListPrec=readListPrecDefault
Methods
Arguments
| :: Int | the operator precedence of the enclosing
context (a number from |
| -> ReadS a |
attempts to parse a value from the front of the string, returning a list of (parsed value, remaining string) pairs. If there is no successful parse, the returned list is empty.
Derived instances of Read and Show satisfy the following:
That is, readsPrec parses the string produced by
showsPrec, and delivers the value that
showsPrec started with.
Instances
class (Num a, Ord a) => Real a where #
Minimal complete definition
Methods
toRational :: a -> Rational #
the rational equivalent of its real argument with full precision
Instances
| Real Int | Since: base-2.0.1 |
Defined in GHC.Real Methods toRational :: Int -> Rational # | |
| Real Int8 | Since: base-2.1 |
Defined in GHC.Int Methods toRational :: Int8 -> Rational # | |
| Real Int16 | Since: base-2.1 |
Defined in GHC.Int Methods toRational :: Int16 -> Rational # | |
| Real Int32 | Since: base-2.1 |
Defined in GHC.Int Methods toRational :: Int32 -> Rational # | |
| Real Int64 | Since: base-2.1 |
Defined in GHC.Int Methods toRational :: Int64 -> Rational # | |
| Real Integer | Since: base-2.0.1 |
Defined in GHC.Real Methods toRational :: Integer -> Rational # | |
| Real Natural | Since: base-4.8.0.0 |
Defined in GHC.Natural Methods toRational :: Natural -> Rational # | |
| Real Word | Since: base-2.1 |
Defined in GHC.Real Methods toRational :: Word -> Rational # | |
| Real Word8 | Since: base-2.1 |
Defined in GHC.Word Methods toRational :: Word8 -> Rational # | |
| Real Word16 | Since: base-2.1 |
Defined in GHC.Word Methods toRational :: Word16 -> Rational # | |
| Real Word32 | Since: base-2.1 |
Defined in GHC.Word Methods toRational :: Word32 -> Rational # | |
| Real Word64 | Since: base-2.1 |
Defined in GHC.Word Methods toRational :: Word64 -> Rational # | |
| Real Scientific | WARNING: Avoid applying |
Defined in Data.Scientific Methods toRational :: Scientific -> Rational # | |
| Real DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime Methods toRational :: DiffTime -> Rational # | |
| Real PortNumber | |
Defined in Network.Socket.Types Methods toRational :: PortNumber -> Rational # | |
| Real NominalDiffTime | |
Defined in Data.Time.Clock.Internal.NominalDiffTime Methods toRational :: NominalDiffTime -> Rational # | |
| Integral a => Real (Ratio a) | Since: base-2.0.1 |
Defined in GHC.Real Methods toRational :: Ratio a -> Rational # | |
| Integral i => Real (DecimalRaw i) | |
Defined in Data.Decimal Methods toRational :: DecimalRaw i -> Rational # | |
| HasResolution a => Real (Fixed a) | Since: base-2.1 |
Defined in Data.Fixed Methods toRational :: Fixed a -> Rational # | |
| Real a => Real (Identity a) | |
Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational # | |
| Real a => Real (Const a b) | |
Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational # | |
| Real a => Real (Tagged s a) | |
Defined in Data.Tagged Methods toRational :: Tagged s a -> Rational # | |
class (RealFrac a, Floating a) => RealFloat a where #
Efficient, machine-independent access to the components of a floating-point number.
Minimal complete definition
floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE
Methods
floatRadix :: a -> Integer #
a constant function, returning the radix of the representation
(often 2)
floatDigits :: a -> Int #
a constant function, returning the number of digits of
floatRadix in the significand
floatRange :: a -> (Int, Int) #
a constant function, returning the lowest and highest values the exponent may assume
decodeFloat :: a -> (Integer, Int) #
The function decodeFloat applied to a real floating-point
number returns the significand expressed as an Integer and an
appropriately scaled exponent (an Int). If decodeFloat x(m,n), then x is equal in value to m*b^^n, where b
is the floating-point radix, and furthermore, either m and n
are both zero or else b^(d-1) <= , where abs m < b^dd is
the value of floatDigits xdecodeFloat 0 = (0,0)decodeFloat (-0.0) = (0,0)decodeFloat xisNaN xisInfinite xTrue.
encodeFloat :: Integer -> Int -> a #
encodeFloat performs the inverse of decodeFloat in the
sense that for finite x with the exception of -0.0,
uncurry encodeFloat (decodeFloat x) = xencodeFloat m nm*b^^n (or ±Infinity if overflow
occurs); usually the closer, but if m contains too many bits,
the result may be rounded in the wrong direction.
exponent corresponds to the second component of decodeFloat.
exponent 0 = 0x,
exponent x = snd (decodeFloat x) + floatDigits xx is a finite floating-point number, it is equal in value to
significand x * b ^^ exponent xb is the
floating-point radix.
The behaviour is unspecified on infinite or NaN values.
significand :: a -> a #
The first component of decodeFloat, scaled to lie in the open
interval (-1,1), either 0.0 or of absolute value >= 1/b,
where b is the floating-point radix.
The behaviour is unspecified on infinite or NaN values.
scaleFloat :: Int -> a -> a #
multiplies a floating-point number by an integer power of the radix
True if the argument is an IEEE "not-a-number" (NaN) value
isInfinite :: a -> Bool #
True if the argument is an IEEE infinity or negative infinity
isDenormalized :: a -> Bool #
True if the argument is too small to be represented in
normalized format
isNegativeZero :: a -> Bool #
True if the argument is an IEEE negative zero
True if the argument is an IEEE floating point number
a version of arctangent taking two real floating-point arguments.
For real floating x and y, atan2 y x(x,y). atan2 y x-pi,
pi]. It follows the Common Lisp semantics for the origin when
signed zeroes are supported. atan2 y 1y in a type
that is RealFloat, should return the same value as atan yatan2 is provided, but implementors
can provide a more accurate implementation.
Instances
class (Real a, Fractional a) => RealFrac a where #
Extracting components of fractions.
Minimal complete definition
Methods
properFraction :: Integral b => a -> (b, a) #
The function properFraction takes a real fractional number x
and returns a pair (n,f) such that x = n+f, and:
nis an integral number with the same sign asx; andfis a fraction with the same type and sign asx, and with absolute value less than1.
The default definitions of the ceiling, floor, truncate
and round functions are in terms of properFraction.
truncate :: Integral b => a -> b #
truncate xx between zero and x
round :: Integral b => a -> b #
round xx;
the even integer if x is equidistant between two integers
ceiling :: Integral b => a -> b #
ceiling xx
floor :: Integral b => a -> b #
floor xx
Instances
Conversion of values to readable Strings.
Derived instances of Show have the following properties, which
are compatible with derived instances of Read:
- The result of
showis a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used. - If the constructor is defined to be an infix operator, then
showsPrecwill produce infix applications of the constructor. - the representation will be enclosed in parentheses if the
precedence of the top-level constructor in
xis less thand(associativity is ignored). Thus, ifdis0then the result is never surrounded in parentheses; ifdis11it is always surrounded in parentheses, unless it is an atomic expression. - If the constructor is defined using record syntax, then
showwill produce the record-syntax form, with the fields given in the same order as the original declaration.
For example, given the declarations
infixr 5 :^: data Tree a = Leaf a | Tree a :^: Tree a
the derived instance of Show is equivalent to
instance (Show a) => Show (Tree a) where
showsPrec d (Leaf m) = showParen (d > app_prec) $
showString "Leaf " . showsPrec (app_prec+1) m
where app_prec = 10
showsPrec d (u :^: v) = showParen (d > up_prec) $
showsPrec (up_prec+1) u .
showString " :^: " .
showsPrec (up_prec+1) v
where up_prec = 5Note that right-associativity of :^: is ignored. For example,
show(Leaf 1 :^: Leaf 2 :^: Leaf 3)"Leaf 1 :^: (Leaf 2 :^: Leaf 3)".
Methods
Arguments
| :: Int | the operator precedence of the enclosing
context (a number from |
| -> a | the value to be converted to a |
| -> ShowS |
Convert a value to a readable String.
showsPrec should satisfy the law
showsPrec d x r ++ s == showsPrec d x (r ++ s)
Derived instances of Read and Show satisfy the following:
That is, readsPrec parses the string produced by
showsPrec, and delivers the value that showsPrec started with.
Instances
class Functor f => Applicative (f :: * -> *) where #
A functor with application, providing operations to
A minimal complete definition must include implementations of pure
and of either <*> or liftA2. If it defines both, then they must behave
the same as their default definitions:
(<*>) =liftA2id
liftA2f x y = f<$>x<*>y
Further, any definition must satisfy the following:
- identity
pureid<*>v = v- composition
pure(.)<*>u<*>v<*>w = u<*>(v<*>w)- homomorphism
puref<*>purex =pure(f x)- interchange
u
<*>purey =pure($y)<*>u
The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:
As a consequence of these laws, the Functor instance for f will satisfy
It may be useful to note that supposing
forall x y. p (q x y) = f x . g y
it follows from the above that
liftA2p (liftA2q u v) =liftA2f u .liftA2g v
If f is also a Monad, it should satisfy
(which implies that pure and <*> satisfy the applicative functor laws).
Methods
Lift a value.
(<*>) :: f (a -> b) -> f a -> f b infixl 4 #
Sequential application.
A few functors support an implementation of <*> that is more
efficient than the default one.
(*>) :: f a -> f b -> f b infixl 4 #
Sequence actions, discarding the value of the first argument.
(<*) :: f a -> f b -> f a infixl 4 #
Sequence actions, discarding the value of the second argument.
Instances
| Applicative [] | Since: base-2.1 |
| Applicative Maybe | Since: base-2.1 |
| Applicative IO | Since: base-2.1 |
| Applicative Par1 | Since: base-4.9.0.0 |
| Applicative Q | |
| Applicative IResult | |
| Applicative Result | |
| Applicative Parser | |
| Applicative Complex | Since: base-4.9.0.0 |
| Applicative Min | Since: base-4.9.0.0 |
| Applicative Max | Since: base-4.9.0.0 |
| Applicative First | Since: base-4.9.0.0 |
| Applicative Last | Since: base-4.9.0.0 |
| Applicative Option | Since: base-4.9.0.0 |
| Applicative ZipList | f '<$>' 'ZipList' xs1 '<*>' ... '<*>' 'ZipList' xsN
= 'ZipList' (zipWithN f xs1 ... xsN)where (\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..]
= ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..])
= ZipList {getZipList = ["a5","b6b6","c7c7c7"]}Since: base-2.1 |
| Applicative Identity | Since: base-4.8.0.0 |
| Applicative First | |
| Applicative Last | |
| Applicative Dual | Since: base-4.8.0.0 |
| Applicative Sum | Since: base-4.8.0.0 |
| Applicative Product | Since: base-4.8.0.0 |
| Applicative ReadPrec | Since: base-4.6.0.0 |
| Applicative ReadP | Since: base-4.6.0.0 |
| Applicative NonEmpty | Since: base-4.9.0.0 |
| Applicative MarkupM | |
| Applicative Put | |
| Applicative Tree | |
| Applicative Seq | Since: containers-0.5.4 |
| Applicative CryptoFailable | |
Defined in Crypto.Error.Types Methods pure :: a -> CryptoFailable a # (<*>) :: CryptoFailable (a -> b) -> CryptoFailable a -> CryptoFailable b # liftA2 :: (a -> b -> c) -> CryptoFailable a -> CryptoFailable b -> CryptoFailable c # (*>) :: CryptoFailable a -> CryptoFailable b -> CryptoFailable b # (<*) :: CryptoFailable a -> CryptoFailable b -> CryptoFailable a # | |
| Applicative DList | |
| Applicative Result | |
| Applicative SmallArray | |
Defined in Data.Primitive.SmallArray Methods pure :: a -> SmallArray a # (<*>) :: SmallArray (a -> b) -> SmallArray a -> SmallArray b # liftA2 :: (a -> b -> c) -> SmallArray a -> SmallArray b -> SmallArray c # (*>) :: SmallArray a -> SmallArray b -> SmallArray b # (<*) :: SmallArray a -> SmallArray b -> SmallArray a # | |
| Applicative Array | |
| Applicative Result | |
| Applicative Vector | |
| Applicative Id | |
| Applicative Box | |
| Applicative FormResult | |
Defined in Yesod.Form.Types Methods pure :: a -> FormResult a # (<*>) :: FormResult (a -> b) -> FormResult a -> FormResult b # liftA2 :: (a -> b -> c) -> FormResult a -> FormResult b -> FormResult c # (*>) :: FormResult a -> FormResult b -> FormResult b # (<*) :: FormResult a -> FormResult b -> FormResult a # | |
| Applicative Stream | |
| Applicative P | Since: base-4.5.0.0 |
| Applicative (Either e) | Since: base-3.0 |
| Applicative (U1 :: * -> *) | Since: base-4.9.0.0 |
| Monoid a => Applicative ((,) a) | For tuples, the ("hello ", (+15)) <*> ("world!", 2002)
("hello world!",2017)Since: base-2.1 |
| Applicative (ST s) | Since: base-4.4.0.0 |
| Applicative (Parser i) | |
| Monad m => Applicative (WrappedMonad m) | Since: base-2.1 |
Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a # | |
| Applicative (Proxy :: * -> *) | Since: base-4.7.0.0 |
| (Functor m, Monad m) => Applicative (MaybeT m) | |
| Monad m => Applicative (ZipSource m) | |
Defined in Data.Conduit.Internal.Conduit | |
| Applicative m => Applicative (ResourceT m) | |
Defined in Control.Monad.Trans.Resource.Internal | |
| Functor f => Applicative (Free f) | |
| Applicative m => Applicative (ListT m) | |
| Applicative m => Applicative (NoLoggingT m) | |
Defined in Control.Monad.Logger Methods pure :: a -> NoLoggingT m a # (<*>) :: NoLoggingT m (a -> b) -> NoLoggingT m a -> NoLoggingT m b # liftA2 :: (a -> b -> c) -> NoLoggingT m a -> NoLoggingT m b -> NoLoggingT m c # (*>) :: NoLoggingT m a -> NoLoggingT m b -> NoLoggingT m b # (<*) :: NoLoggingT m a -> NoLoggingT m b -> NoLoggingT m a # | |
| Applicative m => Applicative (WriterLoggingT m) | |
Defined in Control.Monad.Logger Methods pure :: a -> WriterLoggingT m a # (<*>) :: WriterLoggingT m (a -> b) -> WriterLoggingT m a -> WriterLoggingT m b # liftA2 :: (a -> b -> c) -> WriterLoggingT m a -> WriterLoggingT m b -> WriterLoggingT m c # (*>) :: WriterLoggingT m a -> WriterLoggingT m b -> WriterLoggingT m b # (<*) :: WriterLoggingT m a -> WriterLoggingT m b -> WriterLoggingT m a # | |
| Applicative m => Applicative (LoggingT m) | |
Defined in Control.Monad.Logger | |
| Monad m => Applicative (AForm m) | |
| Monad m => Applicative (FormInput m) | |
Defined in Yesod.Form.Input | |
| Applicative (WidgetFor site) | |
Defined in Yesod.Core.Types Methods pure :: a -> WidgetFor site a # (<*>) :: WidgetFor site (a -> b) -> WidgetFor site a -> WidgetFor site b # liftA2 :: (a -> b -> c) -> WidgetFor site a -> WidgetFor site b -> WidgetFor site c # (*>) :: WidgetFor site a -> WidgetFor site b -> WidgetFor site b # (<*) :: WidgetFor site a -> WidgetFor site b -> WidgetFor site a # | |
| Applicative (HandlerFor site) | |
Defined in Yesod.Core.Types Methods pure :: a -> HandlerFor site a # (<*>) :: HandlerFor site (a -> b) -> HandlerFor site a -> HandlerFor site b # liftA2 :: (a -> b -> c) -> HandlerFor site a -> HandlerFor site b -> HandlerFor site c # (*>) :: HandlerFor site a -> HandlerFor site b -> HandlerFor site b # (<*) :: HandlerFor site a -> HandlerFor site b -> HandlerFor site a # | |
| Monad m => Applicative (PErrorT m) | |
| Applicative f => Applicative (Rec1 f) | Since: base-4.9.0.0 |
| Arrow a => Applicative (WrappedArrow a b) | Since: base-2.1 |
Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |
| Monoid m => Applicative (Const m :: * -> *) | Since: base-2.0.1 |
| Applicative f => Applicative (Alt f) | |
| (Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
| (Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
| (Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
| (Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
| (Functor m, Monad m) => Applicative (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
| Monad m => Applicative (ZipSink i m) | |
Defined in Data.Conduit.Internal.Conduit | |
| (Applicative f, Monad f) => Applicative (WhenMissing f x) | Equivalent to Since: containers-0.5.9 |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMissing f x a # (<*>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c # (*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a # | |
| (Functor f, Functor a, Monad a) => Applicative (FreeT f a) | |
Defined in Control.Monad.Free | |
| (Functor m, Monad m) => Applicative (ErrorT e m) | |
Defined in Control.Monad.Trans.Error | |
| Applicative m => Applicative (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
| Applicative (Tagged s) | |
| Applicative (SubHandlerFor child master) | |
Defined in Yesod.Core.Types Methods pure :: a -> SubHandlerFor child master a # (<*>) :: SubHandlerFor child master (a -> b) -> SubHandlerFor child master a -> SubHandlerFor child master b # liftA2 :: (a -> b -> c) -> SubHandlerFor child master a -> SubHandlerFor child master b -> SubHandlerFor child master c # (*>) :: SubHandlerFor child master a -> SubHandlerFor child master b -> SubHandlerFor child master b # (<*) :: SubHandlerFor child master a -> SubHandlerFor child master b -> SubHandlerFor child master a # | |
| Applicative ((->) a :: * -> *) | Since: base-2.1 |
| (Applicative f, Applicative g) => Applicative (f :*: g) | Since: base-4.9.0.0 |
| (Applicative f, Applicative g) => Applicative (Product f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Product | |
| Applicative m => Applicative (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
| Applicative (ConduitT i o m) | |
Defined in Data.Conduit.Internal.Conduit Methods pure :: a -> ConduitT i o m a # (<*>) :: ConduitT i o m (a -> b) -> ConduitT i o m a -> ConduitT i o m b # liftA2 :: (a -> b -> c) -> ConduitT i o m a -> ConduitT i o m b -> ConduitT i o m c # (*>) :: ConduitT i o m a -> ConduitT i o m b -> ConduitT i o m b # (<*) :: ConduitT i o m a -> ConduitT i o m b -> ConduitT i o m a # | |
| Monad m => Applicative (ZipConduit i o m) | |
Defined in Data.Conduit.Internal.Conduit Methods pure :: a -> ZipConduit i o m a # (<*>) :: ZipConduit i o m (a -> b) -> ZipConduit i o m a -> ZipConduit i o m b # liftA2 :: (a -> b -> c) -> ZipConduit i o m a -> ZipConduit i o m b -> ZipConduit i o m c # (*>) :: ZipConduit i o m a -> ZipConduit i o m b -> ZipConduit i o m b # (<*) :: ZipConduit i o m a -> ZipConduit i o m b -> ZipConduit i o m a # | |
| (Monad f, Applicative f) => Applicative (WhenMatched f x y) | Equivalent to Since: containers-0.5.9 |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMatched f x y a # (<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c # (*>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a # | |
| (Applicative f, Monad f) => Applicative (WhenMissing f k x) | Equivalent to Since: containers-0.5.9 |
Defined in Data.Map.Internal Methods pure :: a -> WhenMissing f k x a # (<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c # (*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a # | |
| Stream s => Applicative (ParsecT e s m) |
|
Defined in Text.Megaparsec.Internal Methods pure :: a -> ParsecT e s m a # (<*>) :: ParsecT e s m (a -> b) -> ParsecT e s m a -> ParsecT e s m b # liftA2 :: (a -> b -> c) -> ParsecT e s m a -> ParsecT e s m b -> ParsecT e s m c # (*>) :: ParsecT e s m a -> ParsecT e s m b -> ParsecT e s m b # (<*) :: ParsecT e s m a -> ParsecT e s m b -> ParsecT e s m a # | |
| Applicative f => Applicative (M1 i c f) | Since: base-4.9.0.0 |
| (Applicative f, Applicative g) => Applicative (f :.: g) | Since: base-4.9.0.0 |
| (Applicative f, Applicative g) => Applicative (Compose f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Compose | |
| (Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict | |
| (Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
| (Monad f, Applicative f) => Applicative (WhenMatched f k x y) | Equivalent to Since: containers-0.5.9 |
Defined in Data.Map.Internal Methods pure :: a -> WhenMatched f k x y a # (<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c # (*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a # | |
| Monad state => Applicative (Builder collection mutCollection step state err) | |
Defined in Basement.MutableBuilder Methods pure :: a -> Builder collection mutCollection step state err a # (<*>) :: Builder collection mutCollection step state err (a -> b) -> Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b # liftA2 :: (a -> b -> c) -> Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err c # (*>) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err b # (<*) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err a # | |
| Monad m => Applicative (Pipe l i o u m) | |
Defined in Data.Conduit.Internal.Pipe Methods pure :: a -> Pipe l i o u m a # (<*>) :: Pipe l i o u m (a -> b) -> Pipe l i o u m a -> Pipe l i o u m b # liftA2 :: (a -> b -> c) -> Pipe l i o u m a -> Pipe l i o u m b -> Pipe l i o u m c # (*>) :: Pipe l i o u m a -> Pipe l i o u m b -> Pipe l i o u m b # (<*) :: Pipe l i o u m a -> Pipe l i o u m b -> Pipe l i o u m a # | |
class Foldable (t :: * -> *) where #
Data structures that can be folded.
For example, given a data type
data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)
a suitable instance would be
instance Foldable Tree where foldMap f Empty = mempty foldMap f (Leaf x) = f x foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f r
This is suitable even for abstract types, as the monoid is assumed
to satisfy the monoid laws. Alternatively, one could define foldr:
instance Foldable Tree where foldr f z Empty = z foldr f z (Leaf x) = f x z foldr f z (Node l k r) = foldr f (f k (foldr f z r)) l
Foldable instances are expected to satisfy the following laws:
foldr f z t = appEndo (foldMap (Endo . f) t ) z
foldl f z t = appEndo (getDual (foldMap (Dual . Endo . flip f) t)) z
fold = foldMap id
length = getSum . foldMap (Sum . const 1)
sum, product, maximum, and minimum should all be essentially
equivalent to foldMap forms, such as
sum = getSum . foldMap Sum
but may be less defined.
If the type is also a Functor instance, it should satisfy
foldMap f = fold . fmap f
which implies that
foldMap f . fmap g = foldMap (f . g)
Methods
fold :: Monoid m => t m -> m #
Combine the elements of a structure using a monoid.
foldMap :: Monoid m => (a -> m) -> t a -> m #
Map each element of the structure to a monoid, and combine the results.
foldr :: (a -> b -> b) -> b -> t a -> b #
Right-associative fold of a structure.
In the case of lists, foldr, when applied to a binary operator, a
starting value (typically the right-identity of the operator), and a
list, reduces the list using the binary operator, from right to left:
foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)
Note that, since the head of the resulting expression is produced by
an application of the operator to the first element of the list,
foldr can produce a terminating expression from an infinite list.
For a general Foldable structure this should be semantically identical
to,
foldr f z =foldrf z .toList
foldr' :: (a -> b -> b) -> b -> t a -> b #
Right-associative fold of a structure, but with strict application of the operator.
foldl :: (b -> a -> b) -> b -> t a -> b #
Left-associative fold of a structure.
In the case of lists, foldl, when applied to a binary
operator, a starting value (typically the left-identity of the operator),
and a list, reduces the list using the binary operator, from left to
right:
foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn
Note that to produce the outermost application of the operator the
entire input list must be traversed. This means that foldl' will
diverge if given an infinite list.
Also note that if you want an efficient left-fold, you probably want to
use foldl' instead of foldl. The reason for this is that latter does
not force the "inner" results (e.g. z in the above example)
before applying them to the operator (e.g. to f x1(). This results
in a thunk chain f x2)O(n) elements long, which then must be evaluated from
the outside-in.
For a general Foldable structure this should be semantically identical
to,
foldl f z =foldlf z .toList
foldl' :: (b -> a -> b) -> b -> t a -> b #
Left-associative fold of a structure but with strict application of the operator.
This ensures that each step of the fold is forced to weak head normal
form before being applied, avoiding the collection of thunks that would
otherwise occur. This is often what you want to strictly reduce a finite
list to a single, monolithic result (e.g. length).
For a general Foldable structure this should be semantically identical
to,
foldl f z =foldl'f z .toList
foldr1 :: (a -> a -> a) -> t a -> a #
A variant of foldr that has no base case,
and thus may only be applied to non-empty structures.
foldr1f =foldr1f .toList
foldl1 :: (a -> a -> a) -> t a -> a #
A variant of foldl that has no base case,
and thus may only be applied to non-empty structures.
foldl1f =foldl1f .toList
List of elements of a structure, from left to right.
Test whether the structure is empty. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.
Returns the size/length of a finite structure as an Int. The
default implementation is optimized for structures that are similar to
cons-lists, because there is no general way to do better.
elem :: Eq a => a -> t a -> Bool infix 4 #
Does the element occur in the structure?
maximum :: Ord a => t a -> a #
The largest element of a non-empty structure.
minimum :: Ord a => t a -> a #
The least element of a non-empty structure.
The sum function computes the sum of the numbers of a structure.
product :: Num a => t a -> a #
The product function computes the product of the numbers of a
structure.
Instances
| Foldable [] | Since: base-2.1 |
Defined in Data.Foldable Methods fold :: Monoid m => [m] -> m # foldMap :: Monoid m => (a -> m) -> [a] -> m # foldr :: (a -> b -> b) -> b -> [a] -> b # foldr' :: (a -> b -> b) -> b -> [a] -> b # foldl :: (b -> a -> b) -> b -> [a] -> b # foldl' :: (b -> a -> b) -> b -> [a] -> b # foldr1 :: (a -> a -> a) -> [a] -> a # foldl1 :: (a -> a -> a) -> [a] -> a # elem :: Eq a => a -> [a] -> Bool # maximum :: Ord a => [a] -> a # | |
| Foldable Maybe | Since: base-2.1 |
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # | |
| Foldable Par1 | |
Defined in Data.Foldable Methods fold :: Monoid m => Par1 m -> m # foldMap :: Monoid m => (a -> m) -> Par1 a -> m # foldr :: (a -> b -> b) -> b -> Par1 a -> b # foldr' :: (a -> b -> b) -> b -> Par1 a -> b # foldl :: (b -> a -> b) -> b -> Par1 a -> b # foldl' :: (b -> a -> b) -> b -> Par1 a -> b # foldr1 :: (a -> a -> a) -> Par1 a -> a # foldl1 :: (a -> a -> a) -> Par1 a -> a # elem :: Eq a => a -> Par1 a -> Bool # maximum :: Ord a => Par1 a -> a # | |
| Foldable IResult | |
Defined in Data.Aeson.Types.Internal Methods fold :: Monoid m => IResult m -> m # foldMap :: Monoid m => (a -> m) -> IResult a -> m # foldr :: (a -> b -> b) -> b -> IResult a -> b # foldr' :: (a -> b -> b) -> b -> IResult a -> b # foldl :: (b -> a -> b) -> b -> IResult a -> b # foldl' :: (b -> a -> b) -> b -> IResult a -> b # foldr1 :: (a -> a -> a) -> IResult a -> a # foldl1 :: (a -> a -> a) -> IResult a -> a # elem :: Eq a => a -> IResult a -> Bool # maximum :: Ord a => IResult a -> a # minimum :: Ord a => IResult a -> a # | |
| Foldable Result | |
Defined in Data.Aeson.Types.Internal Methods fold :: Monoid m => Result m -> m # foldMap :: Monoid m => (a -> m) -> Result a -> m # foldr :: (a -> b -> b) -> b -> Result a -> b # foldr' :: (a -> b -> b) -> b -> Result a -> b # foldl :: (b -> a -> b) -> b -> Result a -> b # foldl' :: (b -> a -> b) -> b -> Result a -> b # foldr1 :: (a -> a -> a) -> Result a -> a # foldl1 :: (a -> a -> a) -> Result a -> a # elem :: Eq a => a -> Result a -> Bool # maximum :: Ord a => Result a -> a # minimum :: Ord a => Result a -> a # | |
| Foldable Complex | |
Defined in Data.Complex Methods fold :: Monoid m => Complex m -> m # foldMap :: Monoid m => (a -> m) -> Complex a -> m # foldr :: (a -> b -> b) -> b -> Complex a -> b # foldr' :: (a -> b -> b) -> b -> Complex a -> b # foldl :: (b -> a -> b) -> b -> Complex a -> b # foldl' :: (b -> a -> b) -> b -> Complex a -> b # foldr1 :: (a -> a -> a) -> Complex a -> a # foldl1 :: (a -> a -> a) -> Complex a -> a # elem :: Eq a => a -> Complex a -> Bool # maximum :: Ord a => Complex a -> a # minimum :: Ord a => Complex a -> a # | |
| Foldable Min | Since: base-4.9.0.0 |
Defined in Data.Semigroup Methods fold :: Monoid m => Min m -> m # foldMap :: Monoid m => (a -> m) -> Min a -> m # foldr :: (a -> b -> b) -> b -> Min a -> b # foldr' :: (a -> b -> b) -> b -> Min a -> b # foldl :: (b -> a -> b) -> b -> Min a -> b # foldl' :: (b -> a -> b) -> b -> Min a -> b # foldr1 :: (a -> a -> a) -> Min a -> a # foldl1 :: (a -> a -> a) -> Min a -> a # elem :: Eq a => a -> Min a -> Bool # maximum :: Ord a => Min a -> a # | |
| Foldable Max | Since: base-4.9.0.0 |
Defined in Data.Semigroup Methods fold :: Monoid m => Max m -> m # foldMap :: Monoid m => (a -> m) -> Max a -> m # foldr :: (a -> b -> b) -> b -> Max a -> b # foldr' :: (a -> b -> b) -> b -> Max a -> b # foldl :: (b -> a -> b) -> b -> Max a -> b # foldl' :: (b -> a -> b) -> b -> Max a -> b # foldr1 :: (a -> a -> a) -> Max a -> a # foldl1 :: (a -> a -> a) -> Max a -> a # elem :: Eq a => a -> Max a -> Bool # maximum :: Ord a => Max a -> a # | |
| Foldable First | Since: base-4.9.0.0 |
Defined in Data.Semigroup Methods fold :: Monoid m => First m -> m # foldMap :: Monoid m => (a -> m) -> First a -> m # foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b # foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b # foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # | |
| Foldable Last | Since: base-4.9.0.0 |
Defined in Data.Semigroup Methods fold :: Monoid m => Last m -> m # foldMap :: Monoid m => (a -> m) -> Last a -> m # foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b # foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b # foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
| Foldable Option | Since: base-4.9.0.0 |
Defined in Data.Semigroup Methods fold :: Monoid m => Option m -> m # foldMap :: Monoid m => (a -> m) -> Option a -> m # foldr :: (a -> b -> b) -> b -> Option a -> b # foldr' :: (a -> b -> b) -> b -> Option a -> b # foldl :: (b -> a -> b) -> b -> Option a -> b # foldl' :: (b -> a -> b) -> b -> Option a -> b # foldr1 :: (a -> a -> a) -> Option a -> a # foldl1 :: (a -> a -> a) -> Option a -> a # elem :: Eq a => a -> Option a -> Bool # maximum :: Ord a => Option a -> a # minimum :: Ord a => Option a -> a # | |
| Foldable ZipList | |
Defined in Control.Applicative Methods fold :: Monoid m => ZipList m -> m # foldMap :: Monoid m => (a -> m) -> ZipList a -> m # foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b # foldl :: (b -> a -> b) -> b -> ZipList a -> b # foldl' :: (b -> a -> b) -> b -> ZipList a -> b # foldr1 :: (a -> a -> a) -> ZipList a -> a # foldl1 :: (a -> a -> a) -> ZipList a -> a # elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # | |
| Foldable Identity | Since: base-4.8.0.0 |
Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m # foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b # foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b # foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # | |
| Foldable First | Since: base-4.8.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => First m -> m # foldMap :: Monoid m => (a -> m) -> First a -> m # foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b # foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b # foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # | |
| Foldable Last | Since: base-4.8.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => Last m -> m # foldMap :: Monoid m => (a -> m) -> Last a -> m # foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b # foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b # foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
| Foldable Dual | Since: base-4.8.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => Dual m -> m # foldMap :: Monoid m => (a -> m) -> Dual a -> m # foldr :: (a -> b -> b) -> b -> Dual a -> b # foldr' :: (a -> b -> b) -> b -> Dual a -> b # foldl :: (b -> a -> b) -> b -> Dual a -> b # foldl' :: (b -> a -> b) -> b -> Dual a -> b # foldr1 :: (a -> a -> a) -> Dual a -> a # foldl1 :: (a -> a -> a) -> Dual a -> a # elem :: Eq a => a -> Dual a -> Bool # maximum :: Ord a => Dual a -> a # | |
| Foldable Sum | Since: base-4.8.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => Sum m -> m # foldMap :: Monoid m => (a -> m) -> Sum a -> m # foldr :: (a -> b -> b) -> b -> Sum a -> b # foldr' :: (a -> b -> b) -> b -> Sum a -> b # foldl :: (b -> a -> b) -> b -> Sum a -> b # foldl' :: (b -> a -> b) -> b -> Sum a -> b # foldr1 :: (a -> a -> a) -> Sum a -> a # foldl1 :: (a -> a -> a) -> Sum a -> a # elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # | |
| Foldable Product | Since: base-4.8.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => Product m -> m # foldMap :: Monoid m => (a -> m) -> Product a -> m # foldr :: (a -> b -> b) -> b -> Product a -> b # foldr' :: (a -> b -> b) -> b -> Product a -> b # foldl :: (b -> a -> b) -> b -> Product a -> b # foldl' :: (b -> a -> b) -> b -> Product a -> b # foldr1 :: (a -> a -> a) -> Product a -> a # foldl1 :: (a -> a -> a) -> Product a -> a # elem :: Eq a => a -> Product a -> Bool # maximum :: Ord a => Product a -> a # minimum :: Ord a => Product a -> a # | |
| Foldable NonEmpty | Since: base-4.9.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m # foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m # foldr :: (a -> b -> b) -> b -> NonEmpty a -> b # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b # foldl :: (b -> a -> b) -> b -> NonEmpty a -> b # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b # foldr1 :: (a -> a -> a) -> NonEmpty a -> a # foldl1 :: (a -> a -> a) -> NonEmpty a -> a # elem :: Eq a => a -> NonEmpty a -> Bool # maximum :: Ord a => NonEmpty a -> a # minimum :: Ord a => NonEmpty a -> a # | |
| Foldable IntMap | |
Defined in Data.IntMap.Internal Methods fold :: Monoid m => IntMap m -> m # foldMap :: Monoid m => (a -> m) -> IntMap a -> m # foldr :: (a -> b -> b) -> b -> IntMap a -> b # foldr' :: (a -> b -> b) -> b -> IntMap a -> b # foldl :: (b -> a -> b) -> b -> IntMap a -> b # foldl' :: (b -> a -> b) -> b -> IntMap a -> b # foldr1 :: (a -> a -> a) -> IntMap a -> a # foldl1 :: (a -> a -> a) -> IntMap a -> a # elem :: Eq a => a -> IntMap a -> Bool # maximum :: Ord a => IntMap a -> a # minimum :: Ord a => IntMap a -> a # | |
| Foldable Tree | |
Defined in Data.Tree Methods fold :: Monoid m => Tree m -> m # foldMap :: Monoid m => (a -> m) -> Tree a -> m # foldr :: (a -> b -> b) -> b -> Tree a -> b # foldr' :: (a -> b -> b) -> b -> Tree a -> b # foldl :: (b -> a -> b) -> b -> Tree a -> b # foldl' :: (b -> a -> b) -> b -> Tree a -> b # foldr1 :: (a -> a -> a) -> Tree a -> a # foldl1 :: (a -> a -> a) -> Tree a -> a # elem :: Eq a => a -> Tree a -> Bool # maximum :: Ord a => Tree a -> a # | |
| Foldable Seq | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Seq m -> m # foldMap :: Monoid m => (a -> m) -> Seq a -> m # foldr :: (a -> b -> b) -> b -> Seq a -> b # foldr' :: (a -> b -> b) -> b -> Seq a -> b # foldl :: (b -> a -> b) -> b -> Seq a -> b # foldl' :: (b -> a -> b) -> b -> Seq a -> b # foldr1 :: (a -> a -> a) -> Seq a -> a # foldl1 :: (a -> a -> a) -> Seq a -> a # elem :: Eq a => a -> Seq a -> Bool # maximum :: Ord a => Seq a -> a # | |
| Foldable FingerTree | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => FingerTree m -> m # foldMap :: Monoid m => (a -> m) -> FingerTree a -> m # foldr :: (a -> b -> b) -> b -> FingerTree a -> b # foldr' :: (a -> b -> b) -> b -> FingerTree a -> b # foldl :: (b -> a -> b) -> b -> FingerTree a -> b # foldl' :: (b -> a -> b) -> b -> FingerTree a -> b # foldr1 :: (a -> a -> a) -> FingerTree a -> a # foldl1 :: (a -> a -> a) -> FingerTree a -> a # toList :: FingerTree a -> [a] # null :: FingerTree a -> Bool # length :: FingerTree a -> Int # elem :: Eq a => a -> FingerTree a -> Bool # maximum :: Ord a => FingerTree a -> a # minimum :: Ord a => FingerTree a -> a # sum :: Num a => FingerTree a -> a # product :: Num a => FingerTree a -> a # | |
| Foldable Digit | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Digit m -> m # foldMap :: Monoid m => (a -> m) -> Digit a -> m # foldr :: (a -> b -> b) -> b -> Digit a -> b # foldr' :: (a -> b -> b) -> b -> Digit a -> b # foldl :: (b -> a -> b) -> b -> Digit a -> b # foldl' :: (b -> a -> b) -> b -> Digit a -> b # foldr1 :: (a -> a -> a) -> Digit a -> a # foldl1 :: (a -> a -> a) -> Digit a -> a # elem :: Eq a => a -> Digit a -> Bool # maximum :: Ord a => Digit a -> a # minimum :: Ord a => Digit a -> a # | |
| Foldable Node | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Node m -> m # foldMap :: Monoid m => (a -> m) -> Node a -> m # foldr :: (a -> b -> b) -> b -> Node a -> b # foldr' :: (a -> b -> b) -> b -> Node a -> b # foldl :: (b -> a -> b) -> b -> Node a -> b # foldl' :: (b -> a -> b) -> b -> Node a -> b # foldr1 :: (a -> a -> a) -> Node a -> a # foldl1 :: (a -> a -> a) -> Node a -> a # elem :: Eq a => a -> Node a -> Bool # maximum :: Ord a => Node a -> a # | |
| Foldable Elem | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Elem m -> m # foldMap :: Monoid m => (a -> m) -> Elem a -> m # foldr :: (a -> b -> b) -> b -> Elem a -> b # foldr' :: (a -> b -> b) -> b -> Elem a -> b # foldl :: (b -> a -> b) -> b -> Elem a -> b # foldl' :: (b -> a -> b) -> b -> Elem a -> b # foldr1 :: (a -> a -> a) -> Elem a -> a # foldl1 :: (a -> a -> a) -> Elem a -> a # elem :: Eq a => a -> Elem a -> Bool # maximum :: Ord a => Elem a -> a # | |
| Foldable ViewL | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewL m -> m # foldMap :: Monoid m => (a -> m) -> ViewL a -> m # foldr :: (a -> b -> b) -> b -> ViewL a -> b # foldr' :: (a -> b -> b) -> b -> ViewL a -> b # foldl :: (b -> a -> b) -> b -> ViewL a -> b # foldl' :: (b -> a -> b) -> b -> ViewL a -> b # foldr1 :: (a -> a -> a) -> ViewL a -> a # foldl1 :: (a -> a -> a) -> ViewL a -> a # elem :: Eq a => a -> ViewL a -> Bool # maximum :: Ord a => ViewL a -> a # minimum :: Ord a => ViewL a -> a # | |
| Foldable ViewR | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewR m -> m # foldMap :: Monoid m => (a -> m) -> ViewR a -> m # foldr :: (a -> b -> b) -> b -> ViewR a -> b # foldr' :: (a -> b -> b) -> b -> ViewR a -> b # foldl :: (b -> a -> b) -> b -> ViewR a -> b # foldl' :: (b -> a -> b) -> b -> ViewR a -> b # foldr1 :: (a -> a -> a) -> ViewR a -> a # foldl1 :: (a -> a -> a) -> ViewR a -> a # elem :: Eq a => a -> ViewR a -> Bool # maximum :: Ord a => ViewR a -> a # minimum :: Ord a => ViewR a -> a # | |
| Foldable Set | |
Defined in Data.Set.Internal Methods fold :: Monoid m => Set m -> m # foldMap :: Monoid m => (a -> m) -> Set a -> m # foldr :: (a -> b -> b) -> b -> Set a -> b # foldr' :: (a -> b -> b) -> b -> Set a -> b # foldl :: (b -> a -> b) -> b -> Set a -> b # foldl' :: (b -> a -> b) -> b -> Set a -> b # foldr1 :: (a -> a -> a) -> Set a -> a # foldl1 :: (a -> a -> a) -> Set a -> a # elem :: Eq a => a -> Set a -> Bool # maximum :: Ord a => Set a -> a # | |
| Foldable DList | |
Defined in Data.DList Methods fold :: Monoid m => DList m -> m # foldMap :: Monoid m => (a -> m) -> DList a -> m # foldr :: (a -> b -> b) -> b -> DList a -> b # foldr' :: (a -> b -> b) -> b -> DList a -> b # foldl :: (b -> a -> b) -> b -> DList a -> b # foldl' :: (b -> a -> b) -> b -> DList a -> b # foldr1 :: (a -> a -> a) -> DList a -> a # foldl1 :: (a -> a -> a) -> DList a -> a # elem :: Eq a => a -> DList a -> Bool # maximum :: Ord a => DList a -> a # minimum :: Ord a => DList a -> a # | |
| Foldable Hashed | |
Defined in Data.Hashable.Class Methods fold :: Monoid m => Hashed m -> m # foldMap :: Monoid m => (a -> m) -> Hashed a -> m # foldr :: (a -> b -> b) -> b -> Hashed a -> b # foldr' :: (a -> b -> b) -> b -> Hashed a -> b # foldl :: (b -> a -> b) -> b -> Hashed a -> b # foldl' :: (b -> a -> b) -> b -> Hashed a -> b # foldr1 :: (a -> a -> a) -> Hashed a -> a # foldl1 :: (a -> a -> a) -> Hashed a -> a # elem :: Eq a => a -> Hashed a -> Bool # maximum :: Ord a => Hashed a -> a # minimum :: Ord a => Hashed a -> a # | |
| Foldable ModuleName | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ModuleName m -> m # foldMap :: Monoid m => (a -> m) -> ModuleName a -> m # foldr :: (a -> b -> b) -> b -> ModuleName a -> b # foldr' :: (a -> b -> b) -> b -> ModuleName a -> b # foldl :: (b -> a -> b) -> b -> ModuleName a -> b # foldl' :: (b -> a -> b) -> b -> ModuleName a -> b # foldr1 :: (a -> a -> a) -> ModuleName a -> a # foldl1 :: (a -> a -> a) -> ModuleName a -> a # toList :: ModuleName a -> [a] # null :: ModuleName a -> Bool # length :: ModuleName a -> Int # elem :: Eq a => a -> ModuleName a -> Bool # maximum :: Ord a => ModuleName a -> a # minimum :: Ord a => ModuleName a -> a # sum :: Num a => ModuleName a -> a # product :: Num a => ModuleName a -> a # | |
| Foldable SpecialCon | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => SpecialCon m -> m # foldMap :: Monoid m => (a -> m) -> SpecialCon a -> m # foldr :: (a -> b -> b) -> b -> SpecialCon a -> b # foldr' :: (a -> b -> b) -> b -> SpecialCon a -> b # foldl :: (b -> a -> b) -> b -> SpecialCon a -> b # foldl' :: (b -> a -> b) -> b -> SpecialCon a -> b # foldr1 :: (a -> a -> a) -> SpecialCon a -> a # foldl1 :: (a -> a -> a) -> SpecialCon a -> a # toList :: SpecialCon a -> [a] # null :: SpecialCon a -> Bool # length :: SpecialCon a -> Int # elem :: Eq a => a -> SpecialCon a -> Bool # maximum :: Ord a => SpecialCon a -> a # minimum :: Ord a => SpecialCon a -> a # sum :: Num a => SpecialCon a -> a # product :: Num a => SpecialCon a -> a # | |
| Foldable QName | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => QName m -> m # foldMap :: Monoid m => (a -> m) -> QName a -> m # foldr :: (a -> b -> b) -> b -> QName a -> b # foldr' :: (a -> b -> b) -> b -> QName a -> b # foldl :: (b -> a -> b) -> b -> QName a -> b # foldl' :: (b -> a -> b) -> b -> QName a -> b # foldr1 :: (a -> a -> a) -> QName a -> a # foldl1 :: (a -> a -> a) -> QName a -> a # elem :: Eq a => a -> QName a -> Bool # maximum :: Ord a => QName a -> a # minimum :: Ord a => QName a -> a # | |
| Foldable Name | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Name m -> m # foldMap :: Monoid m => (a -> m) -> Name a -> m # foldr :: (a -> b -> b) -> b -> Name a -> b # foldr' :: (a -> b -> b) -> b -> Name a -> b # foldl :: (b -> a -> b) -> b -> Name a -> b # foldl' :: (b -> a -> b) -> b -> Name a -> b # foldr1 :: (a -> a -> a) -> Name a -> a # foldl1 :: (a -> a -> a) -> Name a -> a # elem :: Eq a => a -> Name a -> Bool # maximum :: Ord a => Name a -> a # | |
| Foldable IPName | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => IPName m -> m # foldMap :: Monoid m => (a -> m) -> IPName a -> m # foldr :: (a -> b -> b) -> b -> IPName a -> b # foldr' :: (a -> b -> b) -> b -> IPName a -> b # foldl :: (b -> a -> b) -> b -> IPName a -> b # foldl' :: (b -> a -> b) -> b -> IPName a -> b # foldr1 :: (a -> a -> a) -> IPName a -> a # foldl1 :: (a -> a -> a) -> IPName a -> a # elem :: Eq a => a -> IPName a -> Bool # maximum :: Ord a => IPName a -> a # minimum :: Ord a => IPName a -> a # | |
| Foldable QOp | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => QOp m -> m # foldMap :: Monoid m => (a -> m) -> QOp a -> m # foldr :: (a -> b -> b) -> b -> QOp a -> b # foldr' :: (a -> b -> b) -> b -> QOp a -> b # foldl :: (b -> a -> b) -> b -> QOp a -> b # foldl' :: (b -> a -> b) -> b -> QOp a -> b # foldr1 :: (a -> a -> a) -> QOp a -> a # foldl1 :: (a -> a -> a) -> QOp a -> a # elem :: Eq a => a -> QOp a -> Bool # maximum :: Ord a => QOp a -> a # | |
| Foldable Op | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Op m -> m # foldMap :: Monoid m => (a -> m) -> Op a -> m # foldr :: (a -> b -> b) -> b -> Op a -> b # foldr' :: (a -> b -> b) -> b -> Op a -> b # foldl :: (b -> a -> b) -> b -> Op a -> b # foldl' :: (b -> a -> b) -> b -> Op a -> b # foldr1 :: (a -> a -> a) -> Op a -> a # foldl1 :: (a -> a -> a) -> Op a -> a # elem :: Eq a => a -> Op a -> Bool # maximum :: Ord a => Op a -> a # | |
| Foldable CName | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => CName m -> m # foldMap :: Monoid m => (a -> m) -> CName a -> m # foldr :: (a -> b -> b) -> b -> CName a -> b # foldr' :: (a -> b -> b) -> b -> CName a -> b # foldl :: (b -> a -> b) -> b -> CName a -> b # foldl' :: (b -> a -> b) -> b -> CName a -> b # foldr1 :: (a -> a -> a) -> CName a -> a # foldl1 :: (a -> a -> a) -> CName a -> a # elem :: Eq a => a -> CName a -> Bool # maximum :: Ord a => CName a -> a # minimum :: Ord a => CName a -> a # | |
| Foldable Module | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Module m -> m # foldMap :: Monoid m => (a -> m) -> Module a -> m # foldr :: (a -> b -> b) -> b -> Module a -> b # foldr' :: (a -> b -> b) -> b -> Module a -> b # foldl :: (b -> a -> b) -> b -> Module a -> b # foldl' :: (b -> a -> b) -> b -> Module a -> b # foldr1 :: (a -> a -> a) -> Module a -> a # foldl1 :: (a -> a -> a) -> Module a -> a # elem :: Eq a => a -> Module a -> Bool # maximum :: Ord a => Module a -> a # minimum :: Ord a => Module a -> a # | |
| Foldable ModuleHead | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ModuleHead m -> m # foldMap :: Monoid m => (a -> m) -> ModuleHead a -> m # foldr :: (a -> b -> b) -> b -> ModuleHead a -> b # foldr' :: (a -> b -> b) -> b -> ModuleHead a -> b # foldl :: (b -> a -> b) -> b -> ModuleHead a -> b # foldl' :: (b -> a -> b) -> b -> ModuleHead a -> b # foldr1 :: (a -> a -> a) -> ModuleHead a -> a # foldl1 :: (a -> a -> a) -> ModuleHead a -> a # toList :: ModuleHead a -> [a] # null :: ModuleHead a -> Bool # length :: ModuleHead a -> Int # elem :: Eq a => a -> ModuleHead a -> Bool # maximum :: Ord a => ModuleHead a -> a # minimum :: Ord a => ModuleHead a -> a # sum :: Num a => ModuleHead a -> a # product :: Num a => ModuleHead a -> a # | |
| Foldable ExportSpecList | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ExportSpecList m -> m # foldMap :: Monoid m => (a -> m) -> ExportSpecList a -> m # foldr :: (a -> b -> b) -> b -> ExportSpecList a -> b # foldr' :: (a -> b -> b) -> b -> ExportSpecList a -> b # foldl :: (b -> a -> b) -> b -> ExportSpecList a -> b # foldl' :: (b -> a -> b) -> b -> ExportSpecList a -> b # foldr1 :: (a -> a -> a) -> ExportSpecList a -> a # foldl1 :: (a -> a -> a) -> ExportSpecList a -> a # toList :: ExportSpecList a -> [a] # null :: ExportSpecList a -> Bool # length :: ExportSpecList a -> Int # elem :: Eq a => a -> ExportSpecList a -> Bool # maximum :: Ord a => ExportSpecList a -> a # minimum :: Ord a => ExportSpecList a -> a # sum :: Num a => ExportSpecList a -> a # product :: Num a => ExportSpecList a -> a # | |
| Foldable ExportSpec | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ExportSpec m -> m # foldMap :: Monoid m => (a -> m) -> ExportSpec a -> m # foldr :: (a -> b -> b) -> b -> ExportSpec a -> b # foldr' :: (a -> b -> b) -> b -> ExportSpec a -> b # foldl :: (b -> a -> b) -> b -> ExportSpec a -> b # foldl' :: (b -> a -> b) -> b -> ExportSpec a -> b # foldr1 :: (a -> a -> a) -> ExportSpec a -> a # foldl1 :: (a -> a -> a) -> ExportSpec a -> a # toList :: ExportSpec a -> [a] # null :: ExportSpec a -> Bool # length :: ExportSpec a -> Int # elem :: Eq a => a -> ExportSpec a -> Bool # maximum :: Ord a => ExportSpec a -> a # minimum :: Ord a => ExportSpec a -> a # sum :: Num a => ExportSpec a -> a # product :: Num a => ExportSpec a -> a # | |
| Foldable EWildcard | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => EWildcard m -> m # foldMap :: Monoid m => (a -> m) -> EWildcard a -> m # foldr :: (a -> b -> b) -> b -> EWildcard a -> b # foldr' :: (a -> b -> b) -> b -> EWildcard a -> b # foldl :: (b -> a -> b) -> b -> EWildcard a -> b # foldl' :: (b -> a -> b) -> b -> EWildcard a -> b # foldr1 :: (a -> a -> a) -> EWildcard a -> a # foldl1 :: (a -> a -> a) -> EWildcard a -> a # toList :: EWildcard a -> [a] # length :: EWildcard a -> Int # elem :: Eq a => a -> EWildcard a -> Bool # maximum :: Ord a => EWildcard a -> a # minimum :: Ord a => EWildcard a -> a # | |
| Foldable Namespace | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Namespace m -> m # foldMap :: Monoid m => (a -> m) -> Namespace a -> m # foldr :: (a -> b -> b) -> b -> Namespace a -> b # foldr' :: (a -> b -> b) -> b -> Namespace a -> b # foldl :: (b -> a -> b) -> b -> Namespace a -> b # foldl' :: (b -> a -> b) -> b -> Namespace a -> b # foldr1 :: (a -> a -> a) -> Namespace a -> a # foldl1 :: (a -> a -> a) -> Namespace a -> a # toList :: Namespace a -> [a] # length :: Namespace a -> Int # elem :: Eq a => a -> Namespace a -> Bool # maximum :: Ord a => Namespace a -> a # minimum :: Ord a => Namespace a -> a # | |
| Foldable ImportDecl | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ImportDecl m -> m # foldMap :: Monoid m => (a -> m) -> ImportDecl a -> m # foldr :: (a -> b -> b) -> b -> ImportDecl a -> b # foldr' :: (a -> b -> b) -> b -> ImportDecl a -> b # foldl :: (b -> a -> b) -> b -> ImportDecl a -> b # foldl' :: (b -> a -> b) -> b -> ImportDecl a -> b # foldr1 :: (a -> a -> a) -> ImportDecl a -> a # foldl1 :: (a -> a -> a) -> ImportDecl a -> a # toList :: ImportDecl a -> [a] # null :: ImportDecl a -> Bool # length :: ImportDecl a -> Int # elem :: Eq a => a -> ImportDecl a -> Bool # maximum :: Ord a => ImportDecl a -> a # minimum :: Ord a => ImportDecl a -> a # sum :: Num a => ImportDecl a -> a # product :: Num a => ImportDecl a -> a # | |
| Foldable ImportSpecList | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ImportSpecList m -> m # foldMap :: Monoid m => (a -> m) -> ImportSpecList a -> m # foldr :: (a -> b -> b) -> b -> ImportSpecList a -> b # foldr' :: (a -> b -> b) -> b -> ImportSpecList a -> b # foldl :: (b -> a -> b) -> b -> ImportSpecList a -> b # foldl' :: (b -> a -> b) -> b -> ImportSpecList a -> b # foldr1 :: (a -> a -> a) -> ImportSpecList a -> a # foldl1 :: (a -> a -> a) -> ImportSpecList a -> a # toList :: ImportSpecList a -> [a] # null :: ImportSpecList a -> Bool # length :: ImportSpecList a -> Int # elem :: Eq a => a -> ImportSpecList a -> Bool # maximum :: Ord a => ImportSpecList a -> a # minimum :: Ord a => ImportSpecList a -> a # sum :: Num a => ImportSpecList a -> a # product :: Num a => ImportSpecList a -> a # | |
| Foldable ImportSpec | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ImportSpec m -> m # foldMap :: Monoid m => (a -> m) -> ImportSpec a -> m # foldr :: (a -> b -> b) -> b -> ImportSpec a -> b # foldr' :: (a -> b -> b) -> b -> ImportSpec a -> b # foldl :: (b -> a -> b) -> b -> ImportSpec a -> b # foldl' :: (b -> a -> b) -> b -> ImportSpec a -> b # foldr1 :: (a -> a -> a) -> ImportSpec a -> a # foldl1 :: (a -> a -> a) -> ImportSpec a -> a # toList :: ImportSpec a -> [a] # null :: ImportSpec a -> Bool # length :: ImportSpec a -> Int # elem :: Eq a => a -> ImportSpec a -> Bool # maximum :: Ord a => ImportSpec a -> a # minimum :: Ord a => ImportSpec a -> a # sum :: Num a => ImportSpec a -> a # product :: Num a => ImportSpec a -> a # | |
| Foldable Assoc | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Assoc m -> m # foldMap :: Monoid m => (a -> m) -> Assoc a -> m # foldr :: (a -> b -> b) -> b -> Assoc a -> b # foldr' :: (a -> b -> b) -> b -> Assoc a -> b # foldl :: (b -> a -> b) -> b -> Assoc a -> b # foldl' :: (b -> a -> b) -> b -> Assoc a -> b # foldr1 :: (a -> a -> a) -> Assoc a -> a # foldl1 :: (a -> a -> a) -> Assoc a -> a # elem :: Eq a => a -> Assoc a -> Bool # maximum :: Ord a => Assoc a -> a # minimum :: Ord a => Assoc a -> a # | |
| Foldable Decl | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Decl m -> m # foldMap :: Monoid m => (a -> m) -> Decl a -> m # foldr :: (a -> b -> b) -> b -> Decl a -> b # foldr' :: (a -> b -> b) -> b -> Decl a -> b # foldl :: (b -> a -> b) -> b -> Decl a -> b # foldl' :: (b -> a -> b) -> b -> Decl a -> b # foldr1 :: (a -> a -> a) -> Decl a -> a # foldl1 :: (a -> a -> a) -> Decl a -> a # elem :: Eq a => a -> Decl a -> Bool # maximum :: Ord a => Decl a -> a # | |
| Foldable PatternSynDirection | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => PatternSynDirection m -> m # foldMap :: Monoid m => (a -> m) -> PatternSynDirection a -> m # foldr :: (a -> b -> b) -> b -> PatternSynDirection a -> b # foldr' :: (a -> b -> b) -> b -> PatternSynDirection a -> b # foldl :: (b -> a -> b) -> b -> PatternSynDirection a -> b # foldl' :: (b -> a -> b) -> b -> PatternSynDirection a -> b # foldr1 :: (a -> a -> a) -> PatternSynDirection a -> a # foldl1 :: (a -> a -> a) -> PatternSynDirection a -> a # toList :: PatternSynDirection a -> [a] # null :: PatternSynDirection a -> Bool # length :: PatternSynDirection a -> Int # elem :: Eq a => a -> PatternSynDirection a -> Bool # maximum :: Ord a => PatternSynDirection a -> a # minimum :: Ord a => PatternSynDirection a -> a # sum :: Num a => PatternSynDirection a -> a # product :: Num a => PatternSynDirection a -> a # | |
| Foldable TypeEqn | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => TypeEqn m -> m # foldMap :: Monoid m => (a -> m) -> TypeEqn a -> m # foldr :: (a -> b -> b) -> b -> TypeEqn a -> b # foldr' :: (a -> b -> b) -> b -> TypeEqn a -> b # foldl :: (b -> a -> b) -> b -> TypeEqn a -> b # foldl' :: (b -> a -> b) -> b -> TypeEqn a -> b # foldr1 :: (a -> a -> a) -> TypeEqn a -> a # foldl1 :: (a -> a -> a) -> TypeEqn a -> a # elem :: Eq a => a -> TypeEqn a -> Bool # maximum :: Ord a => TypeEqn a -> a # minimum :: Ord a => TypeEqn a -> a # | |
| Foldable Annotation | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Annotation m -> m # foldMap :: Monoid m => (a -> m) -> Annotation a -> m # foldr :: (a -> b -> b) -> b -> Annotation a -> b # foldr' :: (a -> b -> b) -> b -> Annotation a -> b # foldl :: (b -> a -> b) -> b -> Annotation a -> b # foldl' :: (b -> a -> b) -> b -> Annotation a -> b # foldr1 :: (a -> a -> a) -> Annotation a -> a # foldl1 :: (a -> a -> a) -> Annotation a -> a # toList :: Annotation a -> [a] # null :: Annotation a -> Bool # length :: Annotation a -> Int # elem :: Eq a => a -> Annotation a -> Bool # maximum :: Ord a => Annotation a -> a # minimum :: Ord a => Annotation a -> a # sum :: Num a => Annotation a -> a # product :: Num a => Annotation a -> a # | |
| Foldable BooleanFormula | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => BooleanFormula m -> m # foldMap :: Monoid m => (a -> m) -> BooleanFormula a -> m # foldr :: (a -> b -> b) -> b -> BooleanFormula a -> b # foldr' :: (a -> b -> b) -> b -> BooleanFormula a -> b # foldl :: (b -> a -> b) -> b -> BooleanFormula a -> b # foldl' :: (b -> a -> b) -> b -> BooleanFormula a -> b # foldr1 :: (a -> a -> a) -> BooleanFormula a -> a # foldl1 :: (a -> a -> a) -> BooleanFormula a -> a # toList :: BooleanFormula a -> [a] # null :: BooleanFormula a -> Bool # length :: BooleanFormula a -> Int # elem :: Eq a => a -> BooleanFormula a -> Bool # maximum :: Ord a => BooleanFormula a -> a # minimum :: Ord a => BooleanFormula a -> a # sum :: Num a => BooleanFormula a -> a # product :: Num a => BooleanFormula a -> a # | |
| Foldable Role | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Role m -> m # foldMap :: Monoid m => (a -> m) -> Role a -> m # foldr :: (a -> b -> b) -> b -> Role a -> b # foldr' :: (a -> b -> b) -> b -> Role a -> b # foldl :: (b -> a -> b) -> b -> Role a -> b # foldl' :: (b -> a -> b) -> b -> Role a -> b # foldr1 :: (a -> a -> a) -> Role a -> a # foldl1 :: (a -> a -> a) -> Role a -> a # elem :: Eq a => a -> Role a -> Bool # maximum :: Ord a => Role a -> a # | |
| Foldable DataOrNew | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => DataOrNew m -> m # foldMap :: Monoid m => (a -> m) -> DataOrNew a -> m # foldr :: (a -> b -> b) -> b -> DataOrNew a -> b # foldr' :: (a -> b -> b) -> b -> DataOrNew a -> b # foldl :: (b -> a -> b) -> b -> DataOrNew a -> b # foldl' :: (b -> a -> b) -> b -> DataOrNew a -> b # foldr1 :: (a -> a -> a) -> DataOrNew a -> a # foldl1 :: (a -> a -> a) -> DataOrNew a -> a # toList :: DataOrNew a -> [a] # length :: DataOrNew a -> Int # elem :: Eq a => a -> DataOrNew a -> Bool # maximum :: Ord a => DataOrNew a -> a # minimum :: Ord a => DataOrNew a -> a # | |
| Foldable InjectivityInfo | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => InjectivityInfo m -> m # foldMap :: Monoid m => (a -> m) -> InjectivityInfo a -> m # foldr :: (a -> b -> b) -> b -> InjectivityInfo a -> b # foldr' :: (a -> b -> b) -> b -> InjectivityInfo a -> b # foldl :: (b -> a -> b) -> b -> InjectivityInfo a -> b # foldl' :: (b -> a -> b) -> b -> InjectivityInfo a -> b # foldr1 :: (a -> a -> a) -> InjectivityInfo a -> a # foldl1 :: (a -> a -> a) -> InjectivityInfo a -> a # toList :: InjectivityInfo a -> [a] # null :: InjectivityInfo a -> Bool # length :: InjectivityInfo a -> Int # elem :: Eq a => a -> InjectivityInfo a -> Bool # maximum :: Ord a => InjectivityInfo a -> a # minimum :: Ord a => InjectivityInfo a -> a # sum :: Num a => InjectivityInfo a -> a # product :: Num a => InjectivityInfo a -> a # | |
| Foldable ResultSig | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ResultSig m -> m # foldMap :: Monoid m => (a -> m) -> ResultSig a -> m # foldr :: (a -> b -> b) -> b -> ResultSig a -> b # foldr' :: (a -> b -> b) -> b -> ResultSig a -> b # foldl :: (b -> a -> b) -> b -> ResultSig a -> b # foldl' :: (b -> a -> b) -> b -> ResultSig a -> b # foldr1 :: (a -> a -> a) -> ResultSig a -> a # foldl1 :: (a -> a -> a) -> ResultSig a -> a # toList :: ResultSig a -> [a] # length :: ResultSig a -> Int # elem :: Eq a => a -> ResultSig a -> Bool # maximum :: Ord a => ResultSig a -> a # minimum :: Ord a => ResultSig a -> a # | |
| Foldable DeclHead | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => DeclHead m -> m # foldMap :: Monoid m => (a -> m) -> DeclHead a -> m # foldr :: (a -> b -> b) -> b -> DeclHead a -> b # foldr' :: (a -> b -> b) -> b -> DeclHead a -> b # foldl :: (b -> a -> b) -> b -> DeclHead a -> b # foldl' :: (b -> a -> b) -> b -> DeclHead a -> b # foldr1 :: (a -> a -> a) -> DeclHead a -> a # foldl1 :: (a -> a -> a) -> DeclHead a -> a # elem :: Eq a => a -> DeclHead a -> Bool # maximum :: Ord a => DeclHead a -> a # minimum :: Ord a => DeclHead a -> a # | |
| Foldable InstRule | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => InstRule m -> m # foldMap :: Monoid m => (a -> m) -> InstRule a -> m # foldr :: (a -> b -> b) -> b -> InstRule a -> b # foldr' :: (a -> b -> b) -> b -> InstRule a -> b # foldl :: (b -> a -> b) -> b -> InstRule a -> b # foldl' :: (b -> a -> b) -> b -> InstRule a -> b # foldr1 :: (a -> a -> a) -> InstRule a -> a # foldl1 :: (a -> a -> a) -> InstRule a -> a # elem :: Eq a => a -> InstRule a -> Bool # maximum :: Ord a => InstRule a -> a # minimum :: Ord a => InstRule a -> a # | |
| Foldable InstHead | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => InstHead m -> m # foldMap :: Monoid m => (a -> m) -> InstHead a -> m # foldr :: (a -> b -> b) -> b -> InstHead a -> b # foldr' :: (a -> b -> b) -> b -> InstHead a -> b # foldl :: (b -> a -> b) -> b -> InstHead a -> b # foldl' :: (b -> a -> b) -> b -> InstHead a -> b # foldr1 :: (a -> a -> a) -> InstHead a -> a # foldl1 :: (a -> a -> a) -> InstHead a -> a # elem :: Eq a => a -> InstHead a -> Bool # maximum :: Ord a => InstHead a -> a # minimum :: Ord a => InstHead a -> a # | |
| Foldable Deriving | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Deriving m -> m # foldMap :: Monoid m => (a -> m) -> Deriving a -> m # foldr :: (a -> b -> b) -> b -> Deriving a -> b # foldr' :: (a -> b -> b) -> b -> Deriving a -> b # foldl :: (b -> a -> b) -> b -> Deriving a -> b # foldl' :: (b -> a -> b) -> b -> Deriving a -> b # foldr1 :: (a -> a -> a) -> Deriving a -> a # foldl1 :: (a -> a -> a) -> Deriving a -> a # elem :: Eq a => a -> Deriving a -> Bool # maximum :: Ord a => Deriving a -> a # minimum :: Ord a => Deriving a -> a # | |
| Foldable DerivStrategy | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => DerivStrategy m -> m # foldMap :: Monoid m => (a -> m) -> DerivStrategy a -> m # foldr :: (a -> b -> b) -> b -> DerivStrategy a -> b # foldr' :: (a -> b -> b) -> b -> DerivStrategy a -> b # foldl :: (b -> a -> b) -> b -> DerivStrategy a -> b # foldl' :: (b -> a -> b) -> b -> DerivStrategy a -> b # foldr1 :: (a -> a -> a) -> DerivStrategy a -> a # foldl1 :: (a -> a -> a) -> DerivStrategy a -> a # toList :: DerivStrategy a -> [a] # null :: DerivStrategy a -> Bool # length :: DerivStrategy a -> Int # elem :: Eq a => a -> DerivStrategy a -> Bool # maximum :: Ord a => DerivStrategy a -> a # minimum :: Ord a => DerivStrategy a -> a # sum :: Num a => DerivStrategy a -> a # product :: Num a => DerivStrategy a -> a # | |
| Foldable Binds | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Binds m -> m # foldMap :: Monoid m => (a -> m) -> Binds a -> m # foldr :: (a -> b -> b) -> b -> Binds a -> b # foldr' :: (a -> b -> b) -> b -> Binds a -> b # foldl :: (b -> a -> b) -> b -> Binds a -> b # foldl' :: (b -> a -> b) -> b -> Binds a -> b # foldr1 :: (a -> a -> a) -> Binds a -> a # foldl1 :: (a -> a -> a) -> Binds a -> a # elem :: Eq a => a -> Binds a -> Bool # maximum :: Ord a => Binds a -> a # minimum :: Ord a => Binds a -> a # | |
| Foldable IPBind | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => IPBind m -> m # foldMap :: Monoid m => (a -> m) -> IPBind a -> m # foldr :: (a -> b -> b) -> b -> IPBind a -> b # foldr' :: (a -> b -> b) -> b -> IPBind a -> b # foldl :: (b -> a -> b) -> b -> IPBind a -> b # foldl' :: (b -> a -> b) -> b -> IPBind a -> b # foldr1 :: (a -> a -> a) -> IPBind a -> a # foldl1 :: (a -> a -> a) -> IPBind a -> a # elem :: Eq a => a -> IPBind a -> Bool # maximum :: Ord a => IPBind a -> a # minimum :: Ord a => IPBind a -> a # | |
| Foldable Match | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Match m -> m # foldMap :: Monoid m => (a -> m) -> Match a -> m # foldr :: (a -> b -> b) -> b -> Match a -> b # foldr' :: (a -> b -> b) -> b -> Match a -> b # foldl :: (b -> a -> b) -> b -> Match a -> b # foldl' :: (b -> a -> b) -> b -> Match a -> b # foldr1 :: (a -> a -> a) -> Match a -> a # foldl1 :: (a -> a -> a) -> Match a -> a # elem :: Eq a => a -> Match a -> Bool # maximum :: Ord a => Match a -> a # minimum :: Ord a => Match a -> a # | |
| Foldable QualConDecl | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => QualConDecl m -> m # foldMap :: Monoid m => (a -> m) -> QualConDecl a -> m # foldr :: (a -> b -> b) -> b -> QualConDecl a -> b # foldr' :: (a -> b -> b) -> b -> QualConDecl a -> b # foldl :: (b -> a -> b) -> b -> QualConDecl a -> b # foldl' :: (b -> a -> b) -> b -> QualConDecl a -> b # foldr1 :: (a -> a -> a) -> QualConDecl a -> a # foldl1 :: (a -> a -> a) -> QualConDecl a -> a # toList :: QualConDecl a -> [a] # null :: QualConDecl a -> Bool # length :: QualConDecl a -> Int # elem :: Eq a => a -> QualConDecl a -> Bool # maximum :: Ord a => QualConDecl a -> a # minimum :: Ord a => QualConDecl a -> a # sum :: Num a => QualConDecl a -> a # product :: Num a => QualConDecl a -> a # | |
| Foldable ConDecl | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ConDecl m -> m # foldMap :: Monoid m => (a -> m) -> ConDecl a -> m # foldr :: (a -> b -> b) -> b -> ConDecl a -> b # foldr' :: (a -> b -> b) -> b -> ConDecl a -> b # foldl :: (b -> a -> b) -> b -> ConDecl a -> b # foldl' :: (b -> a -> b) -> b -> ConDecl a -> b # foldr1 :: (a -> a -> a) -> ConDecl a -> a # foldl1 :: (a -> a -> a) -> ConDecl a -> a # elem :: Eq a => a -> ConDecl a -> Bool # maximum :: Ord a => ConDecl a -> a # minimum :: Ord a => ConDecl a -> a # | |
| Foldable FieldDecl | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => FieldDecl m -> m # foldMap :: Monoid m => (a -> m) -> FieldDecl a -> m # foldr :: (a -> b -> b) -> b -> FieldDecl a -> b # foldr' :: (a -> b -> b) -> b -> FieldDecl a -> b # foldl :: (b -> a -> b) -> b -> FieldDecl a -> b # foldl' :: (b -> a -> b) -> b -> FieldDecl a -> b # foldr1 :: (a -> a -> a) -> FieldDecl a -> a # foldl1 :: (a -> a -> a) -> FieldDecl a -> a # toList :: FieldDecl a -> [a] # length :: FieldDecl a -> Int # elem :: Eq a => a -> FieldDecl a -> Bool # maximum :: Ord a => FieldDecl a -> a # minimum :: Ord a => FieldDecl a -> a # | |
| Foldable GadtDecl | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => GadtDecl m -> m # foldMap :: Monoid m => (a -> m) -> GadtDecl a -> m # foldr :: (a -> b -> b) -> b -> GadtDecl a -> b # foldr' :: (a -> b -> b) -> b -> GadtDecl a -> b # foldl :: (b -> a -> b) -> b -> GadtDecl a -> b # foldl' :: (b -> a -> b) -> b -> GadtDecl a -> b # foldr1 :: (a -> a -> a) -> GadtDecl a -> a # foldl1 :: (a -> a -> a) -> GadtDecl a -> a # elem :: Eq a => a -> GadtDecl a -> Bool # maximum :: Ord a => GadtDecl a -> a # minimum :: Ord a => GadtDecl a -> a # | |
| Foldable ClassDecl | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ClassDecl m -> m # foldMap :: Monoid m => (a -> m) -> ClassDecl a -> m # foldr :: (a -> b -> b) -> b -> ClassDecl a -> b # foldr' :: (a -> b -> b) -> b -> ClassDecl a -> b # foldl :: (b -> a -> b) -> b -> ClassDecl a -> b # foldl' :: (b -> a -> b) -> b -> ClassDecl a -> b # foldr1 :: (a -> a -> a) -> ClassDecl a -> a # foldl1 :: (a -> a -> a) -> ClassDecl a -> a # toList :: ClassDecl a -> [a] # length :: ClassDecl a -> Int # elem :: Eq a => a -> ClassDecl a -> Bool # maximum :: Ord a => ClassDecl a -> a # minimum :: Ord a => ClassDecl a -> a # | |
| Foldable InstDecl | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => InstDecl m -> m # foldMap :: Monoid m => (a -> m) -> InstDecl a -> m # foldr :: (a -> b -> b) -> b -> InstDecl a -> b # foldr' :: (a -> b -> b) -> b -> InstDecl a -> b # foldl :: (b -> a -> b) -> b -> InstDecl a -> b # foldl' :: (b -> a -> b) -> b -> InstDecl a -> b # foldr1 :: (a -> a -> a) -> InstDecl a -> a # foldl1 :: (a -> a -> a) -> InstDecl a -> a # elem :: Eq a => a -> InstDecl a -> Bool # maximum :: Ord a => InstDecl a -> a # minimum :: Ord a => InstDecl a -> a # | |
| Foldable BangType | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => BangType m -> m # foldMap :: Monoid m => (a -> m) -> BangType a -> m # foldr :: (a -> b -> b) -> b -> BangType a -> b # foldr' :: (a -> b -> b) -> b -> BangType a -> b # foldl :: (b -> a -> b) -> b -> BangType a -> b # foldl' :: (b -> a -> b) -> b -> BangType a -> b # foldr1 :: (a -> a -> a) -> BangType a -> a # foldl1 :: (a -> a -> a) -> BangType a -> a # elem :: Eq a => a -> BangType a -> Bool # maximum :: Ord a => BangType a -> a # minimum :: Ord a => BangType a -> a # | |
| Foldable Unpackedness | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Unpackedness m -> m # foldMap :: Monoid m => (a -> m) -> Unpackedness a -> m # foldr :: (a -> b -> b) -> b -> Unpackedness a -> b # foldr' :: (a -> b -> b) -> b -> Unpackedness a -> b # foldl :: (b -> a -> b) -> b -> Unpackedness a -> b # foldl' :: (b -> a -> b) -> b -> Unpackedness a -> b # foldr1 :: (a -> a -> a) -> Unpackedness a -> a # foldl1 :: (a -> a -> a) -> Unpackedness a -> a # toList :: Unpackedness a -> [a] # null :: Unpackedness a -> Bool # length :: Unpackedness a -> Int # elem :: Eq a => a -> Unpackedness a -> Bool # maximum :: Ord a => Unpackedness a -> a # minimum :: Ord a => Unpackedness a -> a # sum :: Num a => Unpackedness a -> a # product :: Num a => Unpackedness a -> a # | |
| Foldable Rhs | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Rhs m -> m # foldMap :: Monoid m => (a -> m) -> Rhs a -> m # foldr :: (a -> b -> b) -> b -> Rhs a -> b # foldr' :: (a -> b -> b) -> b -> Rhs a -> b # foldl :: (b -> a -> b) -> b -> Rhs a -> b # foldl' :: (b -> a -> b) -> b -> Rhs a -> b # foldr1 :: (a -> a -> a) -> Rhs a -> a # foldl1 :: (a -> a -> a) -> Rhs a -> a # elem :: Eq a => a -> Rhs a -> Bool # maximum :: Ord a => Rhs a -> a # | |
| Foldable GuardedRhs | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => GuardedRhs m -> m # foldMap :: Monoid m => (a -> m) -> GuardedRhs a -> m # foldr :: (a -> b -> b) -> b -> GuardedRhs a -> b # foldr' :: (a -> b -> b) -> b -> GuardedRhs a -> b # foldl :: (b -> a -> b) -> b -> GuardedRhs a -> b # foldl' :: (b -> a -> b) -> b -> GuardedRhs a -> b # foldr1 :: (a -> a -> a) -> GuardedRhs a -> a # foldl1 :: (a -> a -> a) -> GuardedRhs a -> a # toList :: GuardedRhs a -> [a] # null :: GuardedRhs a -> Bool # length :: GuardedRhs a -> Int # elem :: Eq a => a -> GuardedRhs a -> Bool # maximum :: Ord a => GuardedRhs a -> a # minimum :: Ord a => GuardedRhs a -> a # sum :: Num a => GuardedRhs a -> a # product :: Num a => GuardedRhs a -> a # | |
| Foldable Type | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Type m -> m # foldMap :: Monoid m => (a -> m) -> Type a -> m # foldr :: (a -> b -> b) -> b -> Type a -> b # foldr' :: (a -> b -> b) -> b -> Type a -> b # foldl :: (b -> a -> b) -> b -> Type a -> b # foldl' :: (b -> a -> b) -> b -> Type a -> b # foldr1 :: (a -> a -> a) -> Type a -> a # foldl1 :: (a -> a -> a) -> Type a -> a # elem :: Eq a => a -> Type a -> Bool # maximum :: Ord a => Type a -> a # | |
| Foldable MaybePromotedName | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => MaybePromotedName m -> m # foldMap :: Monoid m => (a -> m) -> MaybePromotedName a -> m # foldr :: (a -> b -> b) -> b -> MaybePromotedName a -> b # foldr' :: (a -> b -> b) -> b -> MaybePromotedName a -> b # foldl :: (b -> a -> b) -> b -> MaybePromotedName a -> b # foldl' :: (b -> a -> b) -> b -> MaybePromotedName a -> b # foldr1 :: (a -> a -> a) -> MaybePromotedName a -> a # foldl1 :: (a -> a -> a) -> MaybePromotedName a -> a # toList :: MaybePromotedName a -> [a] # null :: MaybePromotedName a -> Bool # length :: MaybePromotedName a -> Int # elem :: Eq a => a -> MaybePromotedName a -> Bool # maximum :: Ord a => MaybePromotedName a -> a # minimum :: Ord a => MaybePromotedName a -> a # sum :: Num a => MaybePromotedName a -> a # product :: Num a => MaybePromotedName a -> a # | |
| Foldable Promoted | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Promoted m -> m # foldMap :: Monoid m => (a -> m) -> Promoted a -> m # foldr :: (a -> b -> b) -> b -> Promoted a -> b # foldr' :: (a -> b -> b) -> b -> Promoted a -> b # foldl :: (b -> a -> b) -> b -> Promoted a -> b # foldl' :: (b -> a -> b) -> b -> Promoted a -> b # foldr1 :: (a -> a -> a) -> Promoted a -> a # foldl1 :: (a -> a -> a) -> Promoted a -> a # elem :: Eq a => a -> Promoted a -> Bool # maximum :: Ord a => Promoted a -> a # minimum :: Ord a => Promoted a -> a # | |
| Foldable TyVarBind | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => TyVarBind m -> m # foldMap :: Monoid m => (a -> m) -> TyVarBind a -> m # foldr :: (a -> b -> b) -> b -> TyVarBind a -> b # foldr' :: (a -> b -> b) -> b -> TyVarBind a -> b # foldl :: (b -> a -> b) -> b -> TyVarBind a -> b # foldl' :: (b -> a -> b) -> b -> TyVarBind a -> b # foldr1 :: (a -> a -> a) -> TyVarBind a -> a # foldl1 :: (a -> a -> a) -> TyVarBind a -> a # toList :: TyVarBind a -> [a] # length :: TyVarBind a -> Int # elem :: Eq a => a -> TyVarBind a -> Bool # maximum :: Ord a => TyVarBind a -> a # minimum :: Ord a => TyVarBind a -> a # | |
| Foldable Kind | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Kind m -> m # foldMap :: Monoid m => (a -> m) -> Kind a -> m # foldr :: (a -> b -> b) -> b -> Kind a -> b # foldr' :: (a -> b -> b) -> b -> Kind a -> b # foldl :: (b -> a -> b) -> b -> Kind a -> b # foldl' :: (b -> a -> b) -> b -> Kind a -> b # foldr1 :: (a -> a -> a) -> Kind a -> a # foldl1 :: (a -> a -> a) -> Kind a -> a # elem :: Eq a => a -> Kind a -> Bool # maximum :: Ord a => Kind a -> a # | |
| Foldable FunDep | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => FunDep m -> m # foldMap :: Monoid m => (a -> m) -> FunDep a -> m # foldr :: (a -> b -> b) -> b -> FunDep a -> b # foldr' :: (a -> b -> b) -> b -> FunDep a -> b # foldl :: (b -> a -> b) -> b -> FunDep a -> b # foldl' :: (b -> a -> b) -> b -> FunDep a -> b # foldr1 :: (a -> a -> a) -> FunDep a -> a # foldl1 :: (a -> a -> a) -> FunDep a -> a # elem :: Eq a => a -> FunDep a -> Bool # maximum :: Ord a => FunDep a -> a # minimum :: Ord a => FunDep a -> a # | |
| Foldable Context | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Context m -> m # foldMap :: Monoid m => (a -> m) -> Context a -> m # foldr :: (a -> b -> b) -> b -> Context a -> b # foldr' :: (a -> b -> b) -> b -> Context a -> b # foldl :: (b -> a -> b) -> b -> Context a -> b # foldl' :: (b -> a -> b) -> b -> Context a -> b # foldr1 :: (a -> a -> a) -> Context a -> a # foldl1 :: (a -> a -> a) -> Context a -> a # elem :: Eq a => a -> Context a -> Bool # maximum :: Ord a => Context a -> a # minimum :: Ord a => Context a -> a # | |
| Foldable Asst | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Asst m -> m # foldMap :: Monoid m => (a -> m) -> Asst a -> m # foldr :: (a -> b -> b) -> b -> Asst a -> b # foldr' :: (a -> b -> b) -> b -> Asst a -> b # foldl :: (b -> a -> b) -> b -> Asst a -> b # foldl' :: (b -> a -> b) -> b -> Asst a -> b # foldr1 :: (a -> a -> a) -> Asst a -> a # foldl1 :: (a -> a -> a) -> Asst a -> a # elem :: Eq a => a -> Asst a -> Bool # maximum :: Ord a => Asst a -> a # | |
| Foldable Literal | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Literal m -> m # foldMap :: Monoid m => (a -> m) -> Literal a -> m # foldr :: (a -> b -> b) -> b -> Literal a -> b # foldr' :: (a -> b -> b) -> b -> Literal a -> b # foldl :: (b -> a -> b) -> b -> Literal a -> b # foldl' :: (b -> a -> b) -> b -> Literal a -> b # foldr1 :: (a -> a -> a) -> Literal a -> a # foldl1 :: (a -> a -> a) -> Literal a -> a # elem :: Eq a => a -> Literal a -> Bool # maximum :: Ord a => Literal a -> a # minimum :: Ord a => Literal a -> a # | |
| Foldable Sign | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Sign m -> m # foldMap :: Monoid m => (a -> m) -> Sign a -> m # foldr :: (a -> b -> b) -> b -> Sign a -> b # foldr' :: (a -> b -> b) -> b -> Sign a -> b # foldl :: (b -> a -> b) -> b -> Sign a -> b # foldl' :: (b -> a -> b) -> b -> Sign a -> b # foldr1 :: (a -> a -> a) -> Sign a -> a # foldl1 :: (a -> a -> a) -> Sign a -> a # elem :: Eq a => a -> Sign a -> Bool # maximum :: Ord a => Sign a -> a # | |
| Foldable Exp | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Exp m -> m # foldMap :: Monoid m => (a -> m) -> Exp a -> m # foldr :: (a -> b -> b) -> b -> Exp a -> b # foldr' :: (a -> b -> b) -> b -> Exp a -> b # foldl :: (b -> a -> b) -> b -> Exp a -> b # foldl' :: (b -> a -> b) -> b -> Exp a -> b # foldr1 :: (a -> a -> a) -> Exp a -> a # foldl1 :: (a -> a -> a) -> Exp a -> a # elem :: Eq a => a -> Exp a -> Bool # maximum :: Ord a => Exp a -> a # | |
| Foldable XName | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => XName m -> m # foldMap :: Monoid m => (a -> m) -> XName a -> m # foldr :: (a -> b -> b) -> b -> XName a -> b # foldr' :: (a -> b -> b) -> b -> XName a -> b # foldl :: (b -> a -> b) -> b -> XName a -> b # foldl' :: (b -> a -> b) -> b -> XName a -> b # foldr1 :: (a -> a -> a) -> XName a -> a # foldl1 :: (a -> a -> a) -> XName a -> a # elem :: Eq a => a -> XName a -> Bool # maximum :: Ord a => XName a -> a # minimum :: Ord a => XName a -> a # | |
| Foldable XAttr | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => XAttr m -> m # foldMap :: Monoid m => (a -> m) -> XAttr a -> m # foldr :: (a -> b -> b) -> b -> XAttr a -> b # foldr' :: (a -> b -> b) -> b -> XAttr a -> b # foldl :: (b -> a -> b) -> b -> XAttr a -> b # foldl' :: (b -> a -> b) -> b -> XAttr a -> b # foldr1 :: (a -> a -> a) -> XAttr a -> a # foldl1 :: (a -> a -> a) -> XAttr a -> a # elem :: Eq a => a -> XAttr a -> Bool # maximum :: Ord a => XAttr a -> a # minimum :: Ord a => XAttr a -> a # | |
| Foldable Bracket | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Bracket m -> m # foldMap :: Monoid m => (a -> m) -> Bracket a -> m # foldr :: (a -> b -> b) -> b -> Bracket a -> b # foldr' :: (a -> b -> b) -> b -> Bracket a -> b # foldl :: (b -> a -> b) -> b -> Bracket a -> b # foldl' :: (b -> a -> b) -> b -> Bracket a -> b # foldr1 :: (a -> a -> a) -> Bracket a -> a # foldl1 :: (a -> a -> a) -> Bracket a -> a # elem :: Eq a => a -> Bracket a -> Bool # maximum :: Ord a => Bracket a -> a # minimum :: Ord a => Bracket a -> a # | |
| Foldable Splice | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Splice m -> m # foldMap :: Monoid m => (a -> m) -> Splice a -> m # foldr :: (a -> b -> b) -> b -> Splice a -> b # foldr' :: (a -> b -> b) -> b -> Splice a -> b # foldl :: (b -> a -> b) -> b -> Splice a -> b # foldl' :: (b -> a -> b) -> b -> Splice a -> b # foldr1 :: (a -> a -> a) -> Splice a -> a # foldl1 :: (a -> a -> a) -> Splice a -> a # elem :: Eq a => a -> Splice a -> Bool # maximum :: Ord a => Splice a -> a # minimum :: Ord a => Splice a -> a # | |
| Foldable Safety | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Safety m -> m # foldMap :: Monoid m => (a -> m) -> Safety a -> m # foldr :: (a -> b -> b) -> b -> Safety a -> b # foldr' :: (a -> b -> b) -> b -> Safety a -> b # foldl :: (b -> a -> b) -> b -> Safety a -> b # foldl' :: (b -> a -> b) -> b -> Safety a -> b # foldr1 :: (a -> a -> a) -> Safety a -> a # foldl1 :: (a -> a -> a) -> Safety a -> a # elem :: Eq a => a -> Safety a -> Bool # maximum :: Ord a => Safety a -> a # minimum :: Ord a => Safety a -> a # | |
| Foldable CallConv | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => CallConv m -> m # foldMap :: Monoid m => (a -> m) -> CallConv a -> m # foldr :: (a -> b -> b) -> b -> CallConv a -> b # foldr' :: (a -> b -> b) -> b -> CallConv a -> b # foldl :: (b -> a -> b) -> b -> CallConv a -> b # foldl' :: (b -> a -> b) -> b -> CallConv a -> b # foldr1 :: (a -> a -> a) -> CallConv a -> a # foldl1 :: (a -> a -> a) -> CallConv a -> a # elem :: Eq a => a -> CallConv a -> Bool # maximum :: Ord a => CallConv a -> a # minimum :: Ord a => CallConv a -> a # | |
| Foldable ModulePragma | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ModulePragma m -> m # foldMap :: Monoid m => (a -> m) -> ModulePragma a -> m # foldr :: (a -> b -> b) -> b -> ModulePragma a -> b # foldr' :: (a -> b -> b) -> b -> ModulePragma a -> b # foldl :: (b -> a -> b) -> b -> ModulePragma a -> b # foldl' :: (b -> a -> b) -> b -> ModulePragma a -> b # foldr1 :: (a -> a -> a) -> ModulePragma a -> a # foldl1 :: (a -> a -> a) -> ModulePragma a -> a # toList :: ModulePragma a -> [a] # null :: ModulePragma a -> Bool # length :: ModulePragma a -> Int # elem :: Eq a => a -> ModulePragma a -> Bool # maximum :: Ord a => ModulePragma a -> a # minimum :: Ord a => ModulePragma a -> a # sum :: Num a => ModulePragma a -> a # product :: Num a => ModulePragma a -> a # | |
| Foldable Overlap | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Overlap m -> m # foldMap :: Monoid m => (a -> m) -> Overlap a -> m # foldr :: (a -> b -> b) -> b -> Overlap a -> b # foldr' :: (a -> b -> b) -> b -> Overlap a -> b # foldl :: (b -> a -> b) -> b -> Overlap a -> b # foldl' :: (b -> a -> b) -> b -> Overlap a -> b # foldr1 :: (a -> a -> a) -> Overlap a -> a # foldl1 :: (a -> a -> a) -> Overlap a -> a # elem :: Eq a => a -> Overlap a -> Bool # maximum :: Ord a => Overlap a -> a # minimum :: Ord a => Overlap a -> a # | |
| Foldable Activation | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Activation m -> m # foldMap :: Monoid m => (a -> m) -> Activation a -> m # foldr :: (a -> b -> b) -> b -> Activation a -> b # foldr' :: (a -> b -> b) -> b -> Activation a -> b # foldl :: (b -> a -> b) -> b -> Activation a -> b # foldl' :: (b -> a -> b) -> b -> Activation a -> b # foldr1 :: (a -> a -> a) -> Activation a -> a # foldl1 :: (a -> a -> a) -> Activation a -> a # toList :: Activation a -> [a] # null :: Activation a -> Bool # length :: Activation a -> Int # elem :: Eq a => a -> Activation a -> Bool # maximum :: Ord a => Activation a -> a # minimum :: Ord a => Activation a -> a # sum :: Num a => Activation a -> a # product :: Num a => Activation a -> a # | |
| Foldable Rule | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Rule m -> m # foldMap :: Monoid m => (a -> m) -> Rule a -> m # foldr :: (a -> b -> b) -> b -> Rule a -> b # foldr' :: (a -> b -> b) -> b -> Rule a -> b # foldl :: (b -> a -> b) -> b -> Rule a -> b # foldl' :: (b -> a -> b) -> b -> Rule a -> b # foldr1 :: (a -> a -> a) -> Rule a -> a # foldl1 :: (a -> a -> a) -> Rule a -> a # elem :: Eq a => a -> Rule a -> Bool # maximum :: Ord a => Rule a -> a # | |
| Foldable RuleVar | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => RuleVar m -> m # foldMap :: Monoid m => (a -> m) -> RuleVar a -> m # foldr :: (a -> b -> b) -> b -> RuleVar a -> b # foldr' :: (a -> b -> b) -> b -> RuleVar a -> b # foldl :: (b -> a -> b) -> b -> RuleVar a -> b # foldl' :: (b -> a -> b) -> b -> RuleVar a -> b # foldr1 :: (a -> a -> a) -> RuleVar a -> a # foldl1 :: (a -> a -> a) -> RuleVar a -> a # elem :: Eq a => a -> RuleVar a -> Bool # maximum :: Ord a => RuleVar a -> a # minimum :: Ord a => RuleVar a -> a # | |
| Foldable WarningText | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => WarningText m -> m # foldMap :: Monoid m => (a -> m) -> WarningText a -> m # foldr :: (a -> b -> b) -> b -> WarningText a -> b # foldr' :: (a -> b -> b) -> b -> WarningText a -> b # foldl :: (b -> a -> b) -> b -> WarningText a -> b # foldl' :: (b -> a -> b) -> b -> WarningText a -> b # foldr1 :: (a -> a -> a) -> WarningText a -> a # foldl1 :: (a -> a -> a) -> WarningText a -> a # toList :: WarningText a -> [a] # null :: WarningText a -> Bool # length :: WarningText a -> Int # elem :: Eq a => a -> WarningText a -> Bool # maximum :: Ord a => WarningText a -> a # minimum :: Ord a => WarningText a -> a # sum :: Num a => WarningText a -> a # product :: Num a => WarningText a -> a # | |
| Foldable Pat | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Pat m -> m # foldMap :: Monoid m => (a -> m) -> Pat a -> m # foldr :: (a -> b -> b) -> b -> Pat a -> b # foldr' :: (a -> b -> b) -> b -> Pat a -> b # foldl :: (b -> a -> b) -> b -> Pat a -> b # foldl' :: (b -> a -> b) -> b -> Pat a -> b # foldr1 :: (a -> a -> a) -> Pat a -> a # foldl1 :: (a -> a -> a) -> Pat a -> a # elem :: Eq a => a -> Pat a -> Bool # maximum :: Ord a => Pat a -> a # | |
| Foldable PXAttr | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => PXAttr m -> m # foldMap :: Monoid m => (a -> m) -> PXAttr a -> m # foldr :: (a -> b -> b) -> b -> PXAttr a -> b # foldr' :: (a -> b -> b) -> b -> PXAttr a -> b # foldl :: (b -> a -> b) -> b -> PXAttr a -> b # foldl' :: (b -> a -> b) -> b -> PXAttr a -> b # foldr1 :: (a -> a -> a) -> PXAttr a -> a # foldl1 :: (a -> a -> a) -> PXAttr a -> a # elem :: Eq a => a -> PXAttr a -> Bool # maximum :: Ord a => PXAttr a -> a # minimum :: Ord a => PXAttr a -> a # | |
| Foldable RPatOp | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => RPatOp m -> m # foldMap :: Monoid m => (a -> m) -> RPatOp a -> m # foldr :: (a -> b -> b) -> b -> RPatOp a -> b # foldr' :: (a -> b -> b) -> b -> RPatOp a -> b # foldl :: (b -> a -> b) -> b -> RPatOp a -> b # foldl' :: (b -> a -> b) -> b -> RPatOp a -> b # foldr1 :: (a -> a -> a) -> RPatOp a -> a # foldl1 :: (a -> a -> a) -> RPatOp a -> a # elem :: Eq a => a -> RPatOp a -> Bool # maximum :: Ord a => RPatOp a -> a # minimum :: Ord a => RPatOp a -> a # | |
| Foldable RPat | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => RPat m -> m # foldMap :: Monoid m => (a -> m) -> RPat a -> m # foldr :: (a -> b -> b) -> b -> RPat a -> b # foldr' :: (a -> b -> b) -> b -> RPat a -> b # foldl :: (b -> a -> b) -> b -> RPat a -> b # foldl' :: (b -> a -> b) -> b -> RPat a -> b # foldr1 :: (a -> a -> a) -> RPat a -> a # foldl1 :: (a -> a -> a) -> RPat a -> a # elem :: Eq a => a -> RPat a -> Bool # maximum :: Ord a => RPat a -> a # | |
| Foldable PatField | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => PatField m -> m # foldMap :: Monoid m => (a -> m) -> PatField a -> m # foldr :: (a -> b -> b) -> b -> PatField a -> b # foldr' :: (a -> b -> b) -> b -> PatField a -> b # foldl :: (b -> a -> b) -> b -> PatField a -> b # foldl' :: (b -> a -> b) -> b -> PatField a -> b # foldr1 :: (a -> a -> a) -> PatField a -> a # foldl1 :: (a -> a -> a) -> PatField a -> a # elem :: Eq a => a -> PatField a -> Bool # maximum :: Ord a => PatField a -> a # minimum :: Ord a => PatField a -> a # | |
| Foldable Stmt | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Stmt m -> m # foldMap :: Monoid m => (a -> m) -> Stmt a -> m # foldr :: (a -> b -> b) -> b -> Stmt a -> b # foldr' :: (a -> b -> b) -> b -> Stmt a -> b # foldl :: (b -> a -> b) -> b -> Stmt a -> b # foldl' :: (b -> a -> b) -> b -> Stmt a -> b # foldr1 :: (a -> a -> a) -> Stmt a -> a # foldl1 :: (a -> a -> a) -> Stmt a -> a # elem :: Eq a => a -> Stmt a -> Bool # maximum :: Ord a => Stmt a -> a # | |
| Foldable QualStmt | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => QualStmt m -> m # foldMap :: Monoid m => (a -> m) -> QualStmt a -> m # foldr :: (a -> b -> b) -> b -> QualStmt a -> b # foldr' :: (a -> b -> b) -> b -> QualStmt a -> b # foldl :: (b -> a -> b) -> b -> QualStmt a -> b # foldl' :: (b -> a -> b) -> b -> QualStmt a -> b # foldr1 :: (a -> a -> a) -> QualStmt a -> a # foldl1 :: (a -> a -> a) -> QualStmt a -> a # elem :: Eq a => a -> QualStmt a -> Bool # maximum :: Ord a => QualStmt a -> a # minimum :: Ord a => QualStmt a -> a # | |
| Foldable FieldUpdate | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => FieldUpdate m -> m # foldMap :: Monoid m => (a -> m) -> FieldUpdate a -> m # foldr :: (a -> b -> b) -> b -> FieldUpdate a -> b # foldr' :: (a -> b -> b) -> b -> FieldUpdate a -> b # foldl :: (b -> a -> b) -> b -> FieldUpdate a -> b # foldl' :: (b -> a -> b) -> b -> FieldUpdate a -> b # foldr1 :: (a -> a -> a) -> FieldUpdate a -> a # foldl1 :: (a -> a -> a) -> FieldUpdate a -> a # toList :: FieldUpdate a -> [a] # null :: FieldUpdate a -> Bool # length :: FieldUpdate a -> Int # elem :: Eq a => a -> FieldUpdate a -> Bool # maximum :: Ord a => FieldUpdate a -> a # minimum :: Ord a => FieldUpdate a -> a # sum :: Num a => FieldUpdate a -> a # product :: Num a => FieldUpdate a -> a # | |
| Foldable Alt | |
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Alt m -> m # foldMap :: Monoid m => (a -> m) -> Alt a -> m # foldr :: (a -> b -> b) -> b -> Alt a -> b # foldr' :: (a -> b -> b) -> b -> Alt a -> b # foldl :: (b -> a -> b) -> b -> Alt a -> b # foldl' :: (b -> a -> b) -> b -> Alt a -> b # foldr1 :: (a -> a -> a) -> Alt a -> a # foldl1 :: (a -> a -> a) -> Alt a -> a # elem :: Eq a => a -> Alt a -> Bool # maximum :: Ord a => Alt a -> a # | |
| Foldable HistoriedResponse | |
Defined in Network.HTTP.Client Methods fold :: Monoid m => HistoriedResponse m -> m # foldMap :: Monoid m => (a -> m) -> HistoriedResponse a -> m # foldr :: (a -> b -> b) -> b -> HistoriedResponse a -> b # foldr' :: (a -> b -> b) -> b -> HistoriedResponse a -> b # foldl :: (b -> a -> b) -> b -> HistoriedResponse a -> b # foldl' :: (b -> a -> b) -> b -> HistoriedResponse a -> b # foldr1 :: (a -> a -> a) -> HistoriedResponse a -> a # foldl1 :: (a -> a -> a) -> HistoriedResponse a -> a # toList :: HistoriedResponse a -> [a] # null :: HistoriedResponse a -> Bool # length :: HistoriedResponse a -> Int # elem :: Eq a => a -> HistoriedResponse a -> Bool # maximum :: Ord a => HistoriedResponse a -> a # minimum :: Ord a => HistoriedResponse a -> a # sum :: Num a => HistoriedResponse a -> a # product :: Num a => HistoriedResponse a -> a # | |
| 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 # | |
| Foldable SmallArray | |
Defined in Data.Primitive.SmallArray Methods fold :: Monoid m => SmallArray m -> m # foldMap :: Monoid m => (a -> m) -> SmallArray a -> m # foldr :: (a -> b -> b) -> b -> SmallArray a -> b # foldr' :: (a -> b -> b) -> b -> SmallArray a -> b # foldl :: (b -> a -> b) -> b -> SmallArray a -> b # foldl' :: (b -> a -> b) -> b -> SmallArray a -> b # foldr1 :: (a -> a -> a) -> SmallArray a -> a # foldl1 :: (a -> a -> a) -> SmallArray a -> a # toList :: SmallArray a -> [a] # null :: SmallArray a -> Bool # length :: SmallArray a -> Int # elem :: Eq a => a -> SmallArray a -> Bool # maximum :: Ord a => SmallArray a -> a # minimum :: Ord a => SmallArray a -> a # sum :: Num a => SmallArray a -> a # product :: Num a => SmallArray a -> a # | |
| Foldable Array | |
Defined in Data.Primitive.Array Methods fold :: Monoid m => Array m -> m # foldMap :: Monoid m => (a -> m) -> Array a -> m # foldr :: (a -> b -> b) -> b -> Array a -> b # foldr' :: (a -> b -> b) -> b -> Array a -> b # foldl :: (b -> a -> b) -> b -> Array a -> b # foldl' :: (b -> a -> b) -> b -> Array a -> b # foldr1 :: (a -> a -> a) -> Array a -> a # foldl1 :: (a -> a -> a) -> Array a -> a # elem :: Eq a => a -> Array a -> Bool # maximum :: Ord a => Array a -> a # minimum :: Ord a => Array a -> a # | |
| Foldable HashSet | |
Defined in Data.HashSet Methods fold :: Monoid m => HashSet m -> m # foldMap :: Monoid m => (a -> m) -> HashSet a -> m # foldr :: (a -> b -> b) -> b -> HashSet a -> b # foldr' :: (a -> b -> b) -> b -> HashSet a -> b # foldl :: (b -> a -> b) -> b -> HashSet a -> b # foldl' :: (b -> a -> b) -> b -> HashSet a -> b # foldr1 :: (a -> a -> a) -> HashSet a -> a # foldl1 :: (a -> a -> a) -> HashSet a -> a # elem :: Eq a => a -> HashSet a -> Bool # maximum :: Ord a => HashSet a -> a # minimum :: Ord a => HashSet a -> a # | |
| Foldable Vector | |
Defined in Data.Vector Methods fold :: Monoid m => Vector m -> m # foldMap :: Monoid m => (a -> m) -> Vector a -> m # foldr :: (a -> b -> b) -> b -> Vector a -> b # foldr' :: (a -> b -> b) -> b -> Vector a -> b # foldl :: (b -> a -> b) -> b -> Vector a -> b # foldl' :: (b -> a -> b) -> b -> Vector a -> b # foldr1 :: (a -> a -> a) -> Vector a -> a # foldl1 :: (a -> a -> a) -> Vector a -> a # elem :: Eq a => a -> Vector a -> Bool # maximum :: Ord a => Vector a -> a # minimum :: Ord a => Vector a -> a # | |
| Foldable FormResult | Since: yesod-form-1.4.5 |
Defined in Yesod.Form.Types Methods fold :: Monoid m => FormResult m -> m # foldMap :: Monoid m => (a -> m) -> FormResult a -> m # foldr :: (a -> b -> b) -> b -> FormResult a -> b # foldr' :: (a -> b -> b) -> b -> FormResult a -> b # foldl :: (b -> a -> b) -> b -> FormResult a -> b # foldl' :: (b -> a -> b) -> b -> FormResult a -> b # foldr1 :: (a -> a -> a) -> FormResult a -> a # foldl1 :: (a -> a -> a) -> FormResult a -> a # toList :: FormResult a -> [a] # null :: FormResult a -> Bool # length :: FormResult a -> Int # elem :: Eq a => a -> FormResult a -> Bool # maximum :: Ord a => FormResult a -> a # minimum :: Ord a => FormResult a -> a # sum :: Num a => FormResult a -> a # product :: Num a => FormResult a -> a # | |
| Foldable (Either a) | Since: base-4.7.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m # foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # toList :: Either a a0 -> [a0] # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # | |
| Foldable (V1 :: * -> *) | |
Defined in Data.Foldable Methods fold :: Monoid m => V1 m -> m # foldMap :: Monoid m => (a -> m) -> V1 a -> m # foldr :: (a -> b -> b) -> b -> V1 a -> b # foldr' :: (a -> b -> b) -> b -> V1 a -> b # foldl :: (b -> a -> b) -> b -> V1 a -> b # foldl' :: (b -> a -> b) -> b -> V1 a -> b # foldr1 :: (a -> a -> a) -> V1 a -> a # foldl1 :: (a -> a -> a) -> V1 a -> a # elem :: Eq a => a -> V1 a -> Bool # maximum :: Ord a => V1 a -> a # | |
| Foldable (U1 :: * -> *) | Since: base-4.9.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => U1 m -> m # foldMap :: Monoid m => (a -> m) -> U1 a -> m # foldr :: (a -> b -> b) -> b -> U1 a -> b # foldr' :: (a -> b -> b) -> b -> U1 a -> b # foldl :: (b -> a -> b) -> b -> U1 a -> b # foldl' :: (b -> a -> b) -> b -> U1 a -> b # foldr1 :: (a -> a -> a) -> U1 a -> a # foldl1 :: (a -> a -> a) -> U1 a -> a # elem :: Eq a => a -> U1 a -> Bool # maximum :: Ord a => U1 a -> a # | |
| Foldable ((,) a) | Since: base-4.7.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => (a, m) -> m # foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m # foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b # foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b # foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b # foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b # foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # elem :: Eq a0 => a0 -> (a, a0) -> Bool # maximum :: Ord a0 => (a, a0) -> a0 # minimum :: Ord a0 => (a, a0) -> a0 # | |
| Foldable (HashMap k) | |
Defined in Data.HashMap.Base Methods fold :: Monoid m => HashMap k m -> m # foldMap :: Monoid m => (a -> m) -> HashMap k a -> m # foldr :: (a -> b -> b) -> b -> HashMap k a -> b # foldr' :: (a -> b -> b) -> b -> HashMap k a -> b # foldl :: (b -> a -> b) -> b -> HashMap k a -> b # foldl' :: (b -> a -> b) -> b -> HashMap k a -> b # foldr1 :: (a -> a -> a) -> HashMap k a -> a # foldl1 :: (a -> a -> a) -> HashMap k a -> a # toList :: HashMap k a -> [a] # length :: HashMap k a -> Int # elem :: Eq a => a -> HashMap k a -> Bool # maximum :: Ord a => HashMap k a -> a # minimum :: Ord a => HashMap k a -> a # | |
| Foldable (Map k) | |
Defined in Data.Map.Internal Methods fold :: Monoid m => Map k m -> m # foldMap :: Monoid m => (a -> m) -> Map k a -> m # foldr :: (a -> b -> b) -> b -> Map k a -> b # foldr' :: (a -> b -> b) -> b -> Map k a -> b # foldl :: (b -> a -> b) -> b -> Map k a -> b # foldl' :: (b -> a -> b) -> b -> Map k a -> b # foldr1 :: (a -> a -> a) -> Map k a -> a # foldl1 :: (a -> a -> a) -> Map k a -> a # elem :: Eq a => a -> Map k a -> Bool # maximum :: Ord a => Map k a -> a # minimum :: Ord a => Map k a -> a # | |
| Foldable (Array i) | Since: base-4.8.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => Array i m -> m # foldMap :: Monoid m => (a -> m) -> Array i a -> m # foldr :: (a -> b -> b) -> b -> Array i a -> b # foldr' :: (a -> b -> b) -> b -> Array i a -> b # foldl :: (b -> a -> b) -> b -> Array i a -> b # foldl' :: (b -> a -> b) -> b -> Array i a -> b # foldr1 :: (a -> a -> a) -> Array i a -> a # foldl1 :: (a -> a -> a) -> Array i a -> a # elem :: Eq a => a -> Array i a -> Bool # maximum :: Ord a => Array i a -> a # minimum :: Ord a => Array i a -> a # | |
| Foldable (Arg a) | Since: base-4.9.0.0 |
Defined in Data.Semigroup Methods fold :: Monoid m => Arg a m -> m # foldMap :: Monoid m => (a0 -> m) -> Arg a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Arg a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Arg a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Arg a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Arg a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # elem :: Eq a0 => a0 -> Arg a a0 -> Bool # maximum :: Ord a0 => Arg a a0 -> a0 # minimum :: Ord a0 => Arg a a0 -> a0 # | |
| Foldable (Proxy :: * -> *) | Since: base-4.7.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => Proxy m -> m # foldMap :: Monoid m => (a -> m) -> Proxy a -> m # foldr :: (a -> b -> b) -> b -> Proxy a -> b # foldr' :: (a -> b -> b) -> b -> Proxy a -> b # foldl :: (b -> a -> b) -> b -> Proxy a -> b # foldl' :: (b -> a -> b) -> b -> Proxy a -> b # foldr1 :: (a -> a -> a) -> Proxy a -> a # foldl1 :: (a -> a -> a) -> Proxy a -> a # elem :: Eq a => a -> Proxy a -> Bool # maximum :: Ord a => Proxy a -> a # minimum :: Ord a => Proxy a -> a # | |
| Foldable f => Foldable (MaybeT f) | |
Defined in Control.Monad.Trans.Maybe Methods fold :: Monoid m => MaybeT f m -> m # foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m # foldr :: (a -> b -> b) -> b -> MaybeT f a -> b # foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b # foldl :: (b -> a -> b) -> b -> MaybeT f a -> b # foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b # foldr1 :: (a -> a -> a) -> MaybeT f a -> a # foldl1 :: (a -> a -> a) -> MaybeT f a -> a # elem :: Eq a => a -> MaybeT f a -> Bool # maximum :: Ord a => MaybeT f a -> a # minimum :: Ord a => MaybeT f a -> a # | |
| (Functor f, Foldable f) => Foldable (Free f) | |
Defined in Control.Monad.Free Methods fold :: Monoid m => Free f m -> m # foldMap :: Monoid m => (a -> m) -> Free f a -> m # foldr :: (a -> b -> b) -> b -> Free f a -> b # foldr' :: (a -> b -> b) -> b -> Free f a -> b # foldl :: (b -> a -> b) -> b -> Free f a -> b # foldl' :: (b -> a -> b) -> b -> Free f a -> b # foldr1 :: (a -> a -> a) -> Free f a -> a # foldl1 :: (a -> a -> a) -> Free f a -> a # elem :: Eq a => a -> Free f a -> Bool # maximum :: Ord a => Free f a -> a # minimum :: Ord a => Free f a -> a # | |
| Foldable f => Foldable (ListT f) | |
Defined in Control.Monad.Trans.List Methods fold :: Monoid m => ListT f m -> m # foldMap :: Monoid m => (a -> m) -> ListT f a -> m # foldr :: (a -> b -> b) -> b -> ListT f a -> b # foldr' :: (a -> b -> b) -> b -> ListT f a -> b # foldl :: (b -> a -> b) -> b -> ListT f a -> b # foldl' :: (b -> a -> b) -> b -> ListT f a -> b # foldr1 :: (a -> a -> a) -> ListT f a -> a # foldl1 :: (a -> a -> a) -> ListT f a -> a # elem :: Eq a => a -> ListT f a -> Bool # maximum :: Ord a => ListT f a -> a # minimum :: Ord a => ListT f a -> a # | |
| Foldable f => Foldable (Lift1 f) | |
Defined in Prelude.Extras Methods fold :: Monoid m => Lift1 f m -> m # foldMap :: Monoid m => (a -> m) -> Lift1 f a -> m # foldr :: (a -> b -> b) -> b -> Lift1 f a -> b # foldr' :: (a -> b -> b) -> b -> Lift1 f a -> b # foldl :: (b -> a -> b) -> b -> Lift1 f a -> b # foldl' :: (b -> a -> b) -> b -> Lift1 f a -> b # foldr1 :: (a -> a -> a) -> Lift1 f a -> a # foldl1 :: (a -> a -> a) -> Lift1 f a -> a # elem :: Eq a => a -> Lift1 f a -> Bool # maximum :: Ord a => Lift1 f a -> a # minimum :: Ord a => Lift1 f a -> a # | |
| Foldable f => Foldable (Rec1 f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Rec1 f m -> m # foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m # foldr :: (a -> b -> b) -> b -> Rec1 f a -> b # foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b # foldl :: (b -> a -> b) -> b -> Rec1 f a -> b # foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b # foldr1 :: (a -> a -> a) -> Rec1 f a -> a # foldl1 :: (a -> a -> a) -> Rec1 f a -> a # elem :: Eq a => a -> Rec1 f a -> Bool # maximum :: Ord a => Rec1 f a -> a # minimum :: Ord a => Rec1 f a -> a # | |
| Foldable (URec Char :: * -> *) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Char m -> m # foldMap :: Monoid m => (a -> m) -> URec Char a -> m # foldr :: (a -> b -> b) -> b -> URec Char a -> b # foldr' :: (a -> b -> b) -> b -> URec Char a -> b # foldl :: (b -> a -> b) -> b -> URec Char a -> b # foldl' :: (b -> a -> b) -> b -> URec Char a -> b # foldr1 :: (a -> a -> a) -> URec Char a -> a # foldl1 :: (a -> a -> a) -> URec Char a -> a # toList :: URec Char a -> [a] # length :: URec Char a -> Int # elem :: Eq a => a -> URec Char a -> Bool # maximum :: Ord a => URec Char a -> a # minimum :: Ord a => URec Char a -> a # | |
| Foldable (URec Double :: * -> *) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Double m -> m # foldMap :: Monoid m => (a -> m) -> URec Double a -> m # foldr :: (a -> b -> b) -> b -> URec Double a -> b # foldr' :: (a -> b -> b) -> b -> URec Double a -> b # foldl :: (b -> a -> b) -> b -> URec Double a -> b # foldl' :: (b -> a -> b) -> b -> URec Double a -> b # foldr1 :: (a -> a -> a) -> URec Double a -> a # foldl1 :: (a -> a -> a) -> URec Double a -> a # toList :: URec Double a -> [a] # null :: URec Double a -> Bool # length :: URec Double a -> Int # elem :: Eq a => a -> URec Double a -> Bool # maximum :: Ord a => URec Double a -> a # minimum :: Ord a => URec Double a -> a # | |
| Foldable (URec Float :: * -> *) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Float m -> m # foldMap :: Monoid m => (a -> m) -> URec Float a -> m # foldr :: (a -> b -> b) -> b -> URec Float a -> b # foldr' :: (a -> b -> b) -> b -> URec Float a -> b # foldl :: (b -> a -> b) -> b -> URec Float a -> b # foldl' :: (b -> a -> b) -> b -> URec Float a -> b # foldr1 :: (a -> a -> a) -> URec Float a -> a # foldl1 :: (a -> a -> a) -> URec Float a -> a # toList :: URec Float a -> [a] # null :: URec Float a -> Bool # length :: URec Float a -> Int # elem :: Eq a => a -> URec Float a -> Bool # maximum :: Ord a => URec Float a -> a # minimum :: Ord a => URec Float a -> a # | |
| Foldable (URec Int :: * -> *) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Int m -> m # foldMap :: Monoid m => (a -> m) -> URec Int a -> m # foldr :: (a -> b -> b) -> b -> URec Int a -> b # foldr' :: (a -> b -> b) -> b -> URec Int a -> b # foldl :: (b -> a -> b) -> b -> URec Int a -> b # foldl' :: (b -> a -> b) -> b -> URec Int a -> b # foldr1 :: (a -> a -> a) -> URec Int a -> a # foldl1 :: (a -> a -> a) -> URec Int a -> a # elem :: Eq a => a -> URec Int a -> Bool # maximum :: Ord a => URec Int a -> a # minimum :: Ord a => URec Int a -> a # | |
| Foldable (URec Word :: * -> *) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec Word m -> m # foldMap :: Monoid m => (a -> m) -> URec Word a -> m # foldr :: (a -> b -> b) -> b -> URec Word a -> b # foldr' :: (a -> b -> b) -> b -> URec Word a -> b # foldl :: (b -> a -> b) -> b -> URec Word a -> b # foldl' :: (b -> a -> b) -> b -> URec Word a -> b # foldr1 :: (a -> a -> a) -> URec Word a -> a # foldl1 :: (a -> a -> a) -> URec Word a -> a # toList :: URec Word a -> [a] # length :: URec Word a -> Int # elem :: Eq a => a -> URec Word a -> Bool # maximum :: Ord a => URec Word a -> a # minimum :: Ord a => URec Word a -> a # | |
| Foldable (URec (Ptr ()) :: * -> *) | |
Defined in Data.Foldable Methods fold :: Monoid m => URec (Ptr ()) m -> m # foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m # foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b # foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b # foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b # foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b # foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a # foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a # toList :: URec (Ptr ()) a -> [a] # null :: URec (Ptr ()) a -> Bool # length :: URec (Ptr ()) a -> Int # elem :: Eq a => a -> URec (Ptr ()) a -> Bool # maximum :: Ord a => URec (Ptr ()) a -> a # minimum :: Ord a => URec (Ptr ()) a -> a # | |
| Foldable (Const m :: * -> *) | Since: base-4.7.0.0 |
Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b # foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b # foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # | |
| Foldable f => Foldable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Strict Methods fold :: Monoid m => WriterT w f m -> m # foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m # foldr :: (a -> b -> b) -> b -> WriterT w f a -> b # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b # foldl :: (b -> a -> b) -> b -> WriterT w f a -> b # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b # foldr1 :: (a -> a -> a) -> WriterT w f a -> a # foldl1 :: (a -> a -> a) -> WriterT w f a -> a # toList :: WriterT w f a -> [a] # null :: WriterT w f a -> Bool # length :: WriterT w f a -> Int # elem :: Eq a => a -> WriterT w f a -> Bool # maximum :: Ord a => WriterT w f a -> a # minimum :: Ord a => WriterT w f a -> a # | |
| Foldable f => Foldable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Lazy Methods fold :: Monoid m => WriterT w f m -> m # foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m # foldr :: (a -> b -> b) -> b -> WriterT w f a -> b # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b # foldl :: (b -> a -> b) -> b -> WriterT w f a -> b # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b # foldr1 :: (a -> a -> a) -> WriterT w f a -> a # foldl1 :: (a -> a -> a) -> WriterT w f a -> a # toList :: WriterT w f a -> [a] # null :: WriterT w f a -> Bool # length :: WriterT w f a -> Int # elem :: Eq a => a -> WriterT w f a -> Bool # maximum :: Ord a => WriterT w f a -> a # minimum :: Ord a => WriterT w f a -> a # | |
| Foldable f => Foldable (ExceptT e f) | |
Defined in Control.Monad.Trans.Except Methods fold :: Monoid m => ExceptT e f m -> m # foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldr1 :: (a -> a -> a) -> ExceptT e f a -> a # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a # toList :: ExceptT e f a -> [a] # null :: ExceptT e f a -> Bool # length :: ExceptT e f a -> Int # elem :: Eq a => a -> ExceptT e f a -> Bool # maximum :: Ord a => ExceptT e f a -> a # minimum :: Ord a => ExceptT e f a -> a # | |
| (Traversable m, Traversable f) => Foldable (FreeT f m) | |
Defined in Control.Monad.Free Methods fold :: Monoid m0 => FreeT f m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> FreeT f m a -> m0 # foldr :: (a -> b -> b) -> b -> FreeT f m a -> b # foldr' :: (a -> b -> b) -> b -> FreeT f m a -> b # foldl :: (b -> a -> b) -> b -> FreeT f m a -> b # foldl' :: (b -> a -> b) -> b -> FreeT f m a -> b # foldr1 :: (a -> a -> a) -> FreeT f m a -> a # foldl1 :: (a -> a -> a) -> FreeT f m a -> a # toList :: FreeT f m a -> [a] # length :: FreeT f m a -> Int # elem :: Eq a => a -> FreeT f m a -> Bool # maximum :: Ord a => FreeT f m a -> a # minimum :: Ord a => FreeT f m a -> a # | |
| Foldable f => Foldable (ErrorT e f) | |
Defined in Control.Monad.Trans.Error Methods fold :: Monoid m => ErrorT e f m -> m # foldMap :: Monoid m => (a -> m) -> ErrorT e f a -> m # foldr :: (a -> b -> b) -> b -> ErrorT e f a -> b # foldr' :: (a -> b -> b) -> b -> ErrorT e f a -> b # foldl :: (b -> a -> b) -> b -> ErrorT e f a -> b # foldl' :: (b -> a -> b) -> b -> ErrorT e f a -> b # foldr1 :: (a -> a -> a) -> ErrorT e f a -> a # foldl1 :: (a -> a -> a) -> ErrorT e f a -> a # toList :: ErrorT e f a -> [a] # null :: ErrorT e f a -> Bool # length :: ErrorT e f a -> Int # elem :: Eq a => a -> ErrorT e f a -> Bool # maximum :: Ord a => ErrorT e f a -> a # minimum :: Ord a => ErrorT e f a -> a # | |
| Foldable f => Foldable (IdentityT f) | |
Defined in Control.Monad.Trans.Identity Methods fold :: Monoid m => IdentityT f m -> m # foldMap :: Monoid m => (a -> m) -> IdentityT f a -> m # foldr :: (a -> b -> b) -> b -> IdentityT f a -> b # foldr' :: (a -> b -> b) -> b -> IdentityT f a -> b # foldl :: (b -> a -> b) -> b -> IdentityT f a -> b # foldl' :: (b -> a -> b) -> b -> IdentityT f a -> b # foldr1 :: (a -> a -> a) -> IdentityT f a -> a # foldl1 :: (a -> a -> a) -> IdentityT f a -> a # toList :: IdentityT f a -> [a] # null :: IdentityT f a -> Bool # length :: IdentityT f a -> Int # elem :: Eq a => a -> IdentityT f a -> Bool # maximum :: Ord a => IdentityT f a -> a # minimum :: Ord a => IdentityT f a -> a # | |
| Foldable (f a) => Foldable (Lift2 f a) | |
Defined in Prelude.Extras Methods fold :: Monoid m => Lift2 f a m -> m # foldMap :: Monoid m => (a0 -> m) -> Lift2 f a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Lift2 f a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Lift2 f a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Lift2 f a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Lift2 f a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Lift2 f a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Lift2 f a a0 -> a0 # toList :: Lift2 f a a0 -> [a0] # null :: Lift2 f a a0 -> Bool # length :: Lift2 f a a0 -> Int # elem :: Eq a0 => a0 -> Lift2 f a a0 -> Bool # maximum :: Ord a0 => Lift2 f a a0 -> a0 # minimum :: Ord a0 => Lift2 f a a0 -> a0 # | |
| Foldable (Tagged s) | |
Defined in Data.Tagged Methods fold :: Monoid m => Tagged s m -> m # foldMap :: Monoid m => (a -> m) -> Tagged s a -> m # foldr :: (a -> b -> b) -> b -> Tagged s a -> b # foldr' :: (a -> b -> b) -> b -> Tagged s a -> b # foldl :: (b -> a -> b) -> b -> Tagged s a -> b # foldl' :: (b -> a -> b) -> b -> Tagged s a -> b # foldr1 :: (a -> a -> a) -> Tagged s a -> a # foldl1 :: (a -> a -> a) -> Tagged s a -> a # elem :: Eq a => a -> Tagged s a -> Bool # maximum :: Ord a => Tagged s a -> a # minimum :: Ord a => Tagged s a -> a # | |
| Foldable (K1 i c :: * -> *) | |
Defined in Data.Foldable Methods fold :: Monoid m => K1 i c m -> m # foldMap :: Monoid m => (a -> m) -> K1 i c a -> m # foldr :: (a -> b -> b) -> b -> K1 i c a -> b # foldr' :: (a -> b -> b) -> b -> K1 i c a -> b # foldl :: (b -> a -> b) -> b -> K1 i c a -> b # foldl' :: (b -> a -> b) -> b -> K1 i c a -> b # foldr1 :: (a -> a -> a) -> K1 i c a -> a # foldl1 :: (a -> a -> a) -> K1 i c a -> a # elem :: Eq a => a -> K1 i c a -> Bool # maximum :: Ord a => K1 i c a -> a # minimum :: Ord a => K1 i c a -> a # | |
| (Foldable f, Foldable g) => Foldable (f :+: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :+: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b # foldr1 :: (a -> a -> a) -> (f :+: g) a -> a # foldl1 :: (a -> a -> a) -> (f :+: g) a -> a # toList :: (f :+: g) a -> [a] # length :: (f :+: g) a -> Int # elem :: Eq a => a -> (f :+: g) a -> Bool # maximum :: Ord a => (f :+: g) a -> a # minimum :: Ord a => (f :+: g) a -> a # | |
| (Foldable f, Foldable g) => Foldable (f :*: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :*: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :*: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :*: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :*: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :*: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :*: g) a -> b # foldr1 :: (a -> a -> a) -> (f :*: g) a -> a # foldl1 :: (a -> a -> a) -> (f :*: g) a -> a # toList :: (f :*: g) a -> [a] # length :: (f :*: g) a -> Int # elem :: Eq a => a -> (f :*: g) a -> Bool # maximum :: Ord a => (f :*: g) a -> a # minimum :: Ord a => (f :*: g) a -> a # | |
| (Foldable f, Foldable g) => Foldable (Product f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Product Methods fold :: Monoid m => Product f g m -> m # foldMap :: Monoid m => (a -> m) -> Product f g a -> m # foldr :: (a -> b -> b) -> b -> Product f g a -> b # foldr' :: (a -> b -> b) -> b -> Product f g a -> b # foldl :: (b -> a -> b) -> b -> Product f g a -> b # foldl' :: (b -> a -> b) -> b -> Product f g a -> b # foldr1 :: (a -> a -> a) -> Product f g a -> a # foldl1 :: (a -> a -> a) -> Product f g a -> a # toList :: Product f g a -> [a] # null :: Product f g a -> Bool # length :: Product f g a -> Int # elem :: Eq a => a -> Product f g a -> Bool # maximum :: Ord a => Product f g a -> a # minimum :: Ord a => Product f g a -> a # | |
| (Foldable f, Foldable g) => Foldable (Sum f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Sum Methods fold :: Monoid m => Sum f g m -> m # foldMap :: Monoid m => (a -> m) -> Sum f g a -> m # foldr :: (a -> b -> b) -> b -> Sum f g a -> b # foldr' :: (a -> b -> b) -> b -> Sum f g a -> b # foldl :: (b -> a -> b) -> b -> Sum f g a -> b # foldl' :: (b -> a -> b) -> b -> Sum f g a -> b # foldr1 :: (a -> a -> a) -> Sum f g a -> a # foldl1 :: (a -> a -> a) -> Sum f g a -> a # elem :: Eq a => a -> Sum f g a -> Bool # maximum :: Ord a => Sum f g a -> a # minimum :: Ord a => Sum f g a -> a # | |
| Foldable f => Foldable (M1 i c f) | |
Defined in Data.Foldable Methods fold :: Monoid m => M1 i c f m -> m # foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m # foldr :: (a -> b -> b) -> b -> M1 i c f a -> b # foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b # foldl :: (b -> a -> b) -> b -> M1 i c f a -> b # foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b # foldr1 :: (a -> a -> a) -> M1 i c f a -> a # foldl1 :: (a -> a -> a) -> M1 i c f a -> a # elem :: Eq a => a -> M1 i c f a -> Bool # maximum :: Ord a => M1 i c f a -> a # minimum :: Ord a => M1 i c f a -> a # | |
| (Foldable f, Foldable g) => Foldable (f :.: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :.: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b # foldr1 :: (a -> a -> a) -> (f :.: g) a -> a # foldl1 :: (a -> a -> a) -> (f :.: g) a -> a # toList :: (f :.: g) a -> [a] # length :: (f :.: g) a -> Int # elem :: Eq a => a -> (f :.: g) a -> Bool # maximum :: Ord a => (f :.: g) a -> a # minimum :: Ord a => (f :.: g) a -> a # | |
| (Foldable f, Foldable g) => Foldable (Compose f g) | Since: base-4.9.0.0 |
Defined in Data.Functor.Compose Methods fold :: Monoid m => Compose f g m -> m # foldMap :: Monoid m => (a -> m) -> Compose f g a -> m # foldr :: (a -> b -> b) -> b -> Compose f g a -> b # foldr' :: (a -> b -> b) -> b -> Compose f g a -> b # foldl :: (b -> a -> b) -> b -> Compose f g a -> b # foldl' :: (b -> a -> b) -> b -> Compose f g a -> b # foldr1 :: (a -> a -> a) -> Compose f g a -> a # foldl1 :: (a -> a -> a) -> Compose f g a -> a # toList :: Compose f g a -> [a] # null :: Compose f g a -> Bool # length :: Compose f g a -> Int # elem :: Eq a => a -> Compose f g a -> Bool # maximum :: Ord a => Compose f g a -> a # minimum :: Ord a => Compose f g a -> a # | |
class (Functor t, Foldable t) => Traversable (t :: * -> *) where #
Functors representing data structures that can be traversed from left to right.
A definition of traverse must satisfy the following laws:
- naturality
t .for every applicative transformationtraversef =traverse(t . f)t- identity
traverseIdentity = Identity- composition
traverse(Compose .fmapg . f) = Compose .fmap(traverseg) .traversef
A definition of sequenceA must satisfy the following laws:
- naturality
t .for every applicative transformationsequenceA=sequenceA.fmaptt- identity
sequenceA.fmapIdentity = Identity- composition
sequenceA.fmapCompose = Compose .fmapsequenceA.sequenceA
where an applicative transformation is a function
t :: (Applicative f, Applicative g) => f a -> g a
preserving the Applicative operations, i.e.
and the identity functor Identity and composition of functors Compose
are defined as
newtype Identity a = Identity a
instance Functor Identity where
fmap f (Identity x) = Identity (f x)
instance Applicative Identity where
pure x = Identity x
Identity f <*> Identity x = Identity (f x)
newtype Compose f g a = Compose (f (g a))
instance (Functor f, Functor g) => Functor (Compose f g) where
fmap f (Compose x) = Compose (fmap (fmap f) x)
instance (Applicative f, Applicative g) => Applicative (Compose f g) where
pure x = Compose (pure (pure x))
Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)(The naturality law is implied by parametricity.)
Instances are similar to Functor, e.g. given a data type
data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)
a suitable instance would be
instance Traversable Tree where traverse f Empty = pure Empty traverse f (Leaf x) = Leaf <$> f x traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r
This is suitable even for abstract types, as the laws for <*>
imply a form of associativity.
The superclass instances should satisfy the following:
- In the
Functorinstance,fmapshould be equivalent to traversal with the identity applicative functor (fmapDefault). - In the
Foldableinstance,foldMapshould be equivalent to traversal with a constant applicative functor (foldMapDefault).
Methods
traverse :: Applicative f => (a -> f b) -> t a -> f (t b) #
Map each element of a structure to an action, evaluate these actions
from left to right, and collect the results. For a version that ignores
the results see traverse_.
sequenceA :: Applicative f => t (f a) -> f (t a) #
Evaluate each action in the structure from left to right, and
and collect the results. For a version that ignores the results
see sequenceA_.
mapM :: Monad m => (a -> m b) -> t a -> m (t b) #
Map each element of a structure to a monadic action, evaluate
these actions from left to right, and collect the results. For
a version that ignores the results see mapM_.
sequence :: Monad m => t (m a) -> m (t a) #
Evaluate each monadic action in the structure from left to
right, and collect the results. For a version that ignores the
results see sequence_.
Instances
The class of semigroups (types with an associative binary operation).
Instances should satisfy the associativity law:
Since: base-4.9.0.0
Minimal complete definition
Instances
class Semigroup a => Monoid a where #
The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:
x
<>mempty= xmempty<>x = xx(<>(y<>z) = (x<>y)<>zSemigrouplaw)mconcat=foldr'(<>)'mempty
The method names refer to the monoid of lists under concatenation, but there are many other instances.
Some types can be viewed as a monoid in more than one way,
e.g. both addition and multiplication on numbers.
In such cases we often define newtypes and make those instances
of Monoid, e.g. Sum and Product.
NOTE: Semigroup is a superclass of Monoid since base-4.11.0.0.
Minimal complete definition
Methods
Identity of mappend
An associative operation
NOTE: This method is redundant and has the default
implementation mappend = '(<>)'
Fold a list using the monoid.
For most types, the default definition for mconcat will be
used, but the function is included in the class definition so
that an optimized version can be provided for specific types.
Instances
Instances
The character type Char is an enumeration whose values represent
Unicode (or equivalently ISO/IEC 10646) code points (i.e. characters, see
http://www.unicode.org/ for details). This set extends the ISO 8859-1
(Latin-1) character set (the first 256 characters), which is itself an extension
of the ASCII character set (the first 128 characters). A character literal in
Haskell has type Char.
To convert a Char to or from the corresponding Int value defined
by Unicode, use toEnum and fromEnum from the
Enum class respectively (or equivalently ord and chr).
Instances
Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.
Instances
Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.
Instances
A fixed-precision integer type with at least the range [-2^29 .. 2^29-1].
The exact range for a given implementation can be determined by using
minBound and maxBound from the Bounded class.
Instances
Invariant: Jn# and Jp# are used iff value doesn't fit in S#
Useful properties resulting from the invariants:
Instances
The Maybe type encapsulates an optional value. A value of type
Maybe aa (represented as Just aNothing). Using Maybe is a good way to
deal with errors or exceptional cases without resorting to drastic
measures such as error.
The Maybe type is also a monad. It is a simple kind of error
monad, where all errors are represented by Nothing. A richer
error monad can be built using the Either type.
Instances
| Monad Maybe | Since: base-2.1 |
| Functor Maybe | Since: base-2.1 |
| Applicative Maybe | Since: base-2.1 |
| Foldable Maybe | Since: base-2.1 |
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # | |
| Traversable Maybe | Since: base-2.1 |
| ToJSON1 Maybe | |
Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Maybe a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Maybe a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Maybe a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Maybe a] -> Encoding # | |
| FromJSON1 Maybe | |
| Alternative Maybe | Since: base-2.1 |
| MonadPlus Maybe | Since: base-2.1 |
| Eq1 Maybe | Since: base-4.9.0.0 |
| Ord1 Maybe | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Read1 Maybe | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
| Show1 Maybe | Since: base-4.9.0.0 |
| MonadFailure Maybe | |
| Hashable1 Maybe | |
Defined in Data.Hashable.Class | |
| Eq1 Maybe | |
| Ord1 Maybe | |
| Show1 Maybe | |
| Read1 Maybe | |
| MonadBaseControl Maybe Maybe | |
| (Selector s, GToJSON enc arity (K1 i (Maybe a) :: * -> *), KeyValuePair enc pairs, Monoid pairs) => RecordToPairs enc pairs arity (S1 s (K1 i (Maybe a) :: * -> *)) | |
Defined in Data.Aeson.Types.ToJSON | |
| (Selector s, FromJSON a) => FromRecord arity (S1 s (K1 i (Maybe a) :: * -> *)) | |
Defined in Data.Aeson.Types.FromJSON | |
| Eq a => Eq (Maybe a) | |
| Ord a => Ord (Maybe a) | |
| Read a => Read (Maybe a) | Since: base-2.1 |
| Show a => Show (Maybe a) | |
| Generic (Maybe a) | |
| Semigroup a => Semigroup (Maybe a) | Since: base-4.9.0.0 |
| Semigroup a => Monoid (Maybe a) | Lift a semigroup into Since 4.11.0: constraint on inner Since: base-2.1 |
| Lift a => Lift (Maybe a) | |
| Hashable a => Hashable (Maybe a) | |
Defined in Data.Hashable.Class | |
| ToJSON a => ToJSON (Maybe a) | |
Defined in Data.Aeson.Types.ToJSON | |
| FromJSON a => FromJSON (Maybe a) | |
| SingKind a => SingKind (Maybe a) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
| Default (Maybe a) | |
Defined in Data.Default.Class | |
| JSON a => JSON (Maybe a) | |
| MonoFunctor (Maybe a) | |
| MonoFoldable (Maybe a) | |
Defined in Data.MonoTraversable Methods ofoldMap :: Monoid m => (Element (Maybe a) -> m) -> Maybe a -> m # ofoldr :: (Element (Maybe a) -> b -> b) -> b -> Maybe a -> b # ofoldl' :: (a0 -> Element (Maybe a) -> a0) -> a0 -> Maybe a -> a0 # otoList :: Maybe a -> [Element (Maybe a)] # oall :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool # oany :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool # olength64 :: Maybe a -> Int64 # ocompareLength :: Integral i => Maybe a -> i -> Ordering # otraverse_ :: Applicative f => (Element (Maybe a) -> f b) -> Maybe a -> f () # ofor_ :: Applicative f => Maybe a -> (Element (Maybe a) -> f b) -> f () # omapM_ :: Applicative m => (Element (Maybe a) -> m ()) -> Maybe a -> m () # oforM_ :: Applicative m => Maybe a -> (Element (Maybe a) -> m ()) -> m () # ofoldlM :: Monad m => (a0 -> Element (Maybe a) -> m a0) -> a0 -> Maybe a -> m a0 # ofoldMap1Ex :: Semigroup m => (Element (Maybe a) -> m) -> Maybe a -> m # ofoldr1Ex :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Element (Maybe a) # ofoldl1Ex' :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Element (Maybe a) # headEx :: Maybe a -> Element (Maybe a) # lastEx :: Maybe a -> Element (Maybe a) # unsafeHead :: Maybe a -> Element (Maybe a) # unsafeLast :: Maybe a -> Element (Maybe a) # maximumByEx :: (Element (Maybe a) -> Element (Maybe a) -> Ordering) -> Maybe a -> Element (Maybe a) # minimumByEx :: (Element (Maybe a) -> Element (Maybe a) -> Ordering) -> Maybe a -> Element (Maybe a) # | |
| MonoTraversable (Maybe a) | |
| MonoPointed (Maybe a) | |
| PathPiece a => PathPiece (Maybe a) | |
Defined in Web.PathPieces | |
| PersistField a => PersistField (Maybe a) | |
Defined in Database.Persist.Class.PersistField Methods toPersistValue :: Maybe a -> PersistValue # fromPersistValue :: PersistValue -> Either Text (Maybe a) # | |
| Generic1 Maybe | |
| SingI (Nothing :: Maybe a) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
| SingI a2 => SingI (Just a2 :: Maybe a1) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
| type Failure Maybe | |
Defined in Basement.Monad | |
| type StM Maybe a | |
Defined in Control.Monad.Trans.Control | |
| type Rep (Maybe a) | |
| data Sing (b :: Maybe a) | |
| type DemoteRep (Maybe a) | |
Defined in GHC.Generics | |
| type Element (Maybe a) | |
Defined in Data.MonoTraversable | |
| type Rep1 Maybe | |
Instances
| Bounded Ordering | Since: base-2.1 |
| Enum Ordering | Since: base-2.1 |
| Eq Ordering | |
| Ord Ordering | |
Defined in GHC.Classes | |
| Read Ordering | Since: base-2.1 |
| Show Ordering | |
| Ix Ordering | Since: base-2.1 |
Defined in GHC.Arr | |
| Generic Ordering | |
| Semigroup Ordering | Since: base-4.9.0.0 |
| Monoid Ordering | Since: base-2.1 |
| Hashable Ordering | |
Defined in Data.Hashable.Class | |
| ToJSON Ordering | |
Defined in Data.Aeson.Types.ToJSON | |
| FromJSON Ordering | |
| Default Ordering | |
Defined in Data.Default.Class | |
| JSON Ordering | |
| type Rep Ordering | |
A value of type IO aa.
There is really only one way to "perform" an I/O action: bind it to
Main.main in your program. When your program is run, the I/O will
be performed. It isn't possible to perform I/O from an arbitrary
function, unless that function is itself in the IO monad and called
at some point, directly or indirectly, from Main.main.
IO is a monad, so IO actions can be combined using either the do-notation
or the >> and >>= operations from the Monad class.
Instances
Instances
The Either type represents values with two possibilities: a value of
type Either a bLeft aRight b
The Either type is sometimes used to represent a value which is
either correct or an error; by convention, the Left constructor is
used to hold an error value and the Right constructor is used to
hold a correct value (mnemonic: "right" also means "correct").
Examples
The type Either String IntString or an Int. The Left constructor can be used only on
Strings, and the Right constructor can be used only on Ints:
>>>let s = Left "foo" :: Either String Int>>>sLeft "foo">>>let n = Right 3 :: Either String Int>>>nRight 3>>>:type ss :: Either String Int>>>:type nn :: Either String Int
The fmap from our Functor instance will ignore Left values, but
will apply the supplied function to values contained in a Right:
>>>let s = Left "foo" :: Either String Int>>>let n = Right 3 :: Either String Int>>>fmap (*2) sLeft "foo">>>fmap (*2) nRight 6
The Monad instance for Either allows us to chain together multiple
actions which may fail, and fail overall if any of the individual
steps failed. First we'll write a function that can either parse an
Int from a Char, or fail.
>>>import Data.Char ( digitToInt, isDigit )>>>:{let parseEither :: Char -> Either String Int parseEither c | isDigit c = Right (digitToInt c) | otherwise = Left "parse error">>>:}
The following should work, since both '1' and '2' can be
parsed as Ints.
>>>:{let parseMultiple :: Either String Int parseMultiple = do x <- parseEither '1' y <- parseEither '2' return (x + y)>>>:}
>>>parseMultipleRight 3
But the following should fail overall, since the first operation where
we attempt to parse 'm' as an Int will fail:
>>>:{let parseMultiple :: Either String Int parseMultiple = do x <- parseEither 'm' y <- parseEither '2' return (x + y)>>>:}
>>>parseMultipleLeft "parse error"
Instances
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.
Instances
(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 #
An infix synonym for fmap.
The name of this operator is an allusion to $.
Note the similarities between their types:
($) :: (a -> b) -> a -> b (<$>) :: Functor f => (a -> b) -> f a -> f b
Whereas $ is function application, <$> is function
application lifted over a Functor.
Examples
Convert from a Maybe IntMaybe Stringshow:
>>>show <$> NothingNothing>>>show <$> Just 3Just "3"
Convert from an Either Int IntEither IntString using show:
>>>show <$> Left 17Left 17>>>show <$> Right 17Right "17"
Double each element of a list:
>>>(*2) <$> [1,2,3][2,4,6]
Apply even to the second element of a pair:
>>>even <$> (2,2)(2,True)
A space efficient, packed, unboxed Unicode text type.
Instances
This is the simplest representation of UTC. It consists of the day number, and a time offset from midnight. Note that if a day has a leap second added to it, it will have 86401 seconds.
Constructors
| UTCTime | |
Fields
| |
Instances
A type that can be converted to JSON.
Instances in general must specify toJSON and should (but don't need
to) specify toEncoding.
An example type and instance:
-- Allow ourselves to writeTextliterals. {-# LANGUAGE OverloadedStrings #-} data Coord = Coord { x :: Double, y :: Double } instanceToJSONCoord wheretoJSON(Coord x y) =object["x".=x, "y".=y]toEncoding(Coord x y) =pairs("x".=x<>"y".=y)
Instead of manually writing your ToJSON instance, there are two options
to do it automatically:
- Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so it will probably be more efficient than the following option.
- The compiler can provide a default generic implementation for
toJSON.
To use the second, simply add a deriving clause to your
datatype and declare a GenericToJSON instance. If you require nothing other than
defaultOptions, it is sufficient to write (and this is the only
alternative where the default toJSON implementation is sufficient):
{-# LANGUAGE DeriveGeneric #-}
import GHC.Generics
data Coord = Coord { x :: Double, y :: Double } deriving Generic
instance ToJSON Coord where
toEncoding = genericToEncoding defaultOptions
If on the other hand you wish to customize the generic decoding, you have to implement both methods:
customOptions =defaultOptions{fieldLabelModifier=maptoUpper} instanceToJSONCoord wheretoJSON=genericToJSONcustomOptionstoEncoding=genericToEncodingcustomOptions
Previous versions of this library only had the toJSON method. Adding
toEncoding had to reasons:
- toEncoding is more efficient for the common case that the output of
toJSONis directly serialized to aByteString. Further, expressing either method in terms of the other would be non-optimal. - The choice of defaults allows a smooth transition for existing users:
Existing instances that do not define
toEncodingstill compile and have the correct semantics. This is ensured by making the default implementation oftoEncodingusetoJSON. This produces correct results, but since it performs an intermediate conversion to aValue, it will be less efficient than directly emitting anEncoding. (this also means that specifying nothing more thaninstance ToJSON Coordwould be sufficient as a generically decoding instance, but there probably exists no good reason to not specifytoEncodingin new instances.)
Methods
Convert a Haskell value to a JSON-friendly intermediate type.
toEncoding :: a -> Encoding #
Encode a Haskell value as JSON.
The default implementation of this method creates an
intermediate Value using toJSON. This provides
source-level compatibility for people upgrading from older
versions of this library, but obviously offers no performance
advantage.
To benefit from direct encoding, you must provide an
implementation for this method. The easiest way to do so is by
having your types implement Generic using the DeriveGeneric
extension, and then have GHC generate a method body as follows.
instanceToJSONCoord wheretoEncoding=genericToEncodingdefaultOptions
toJSONList :: [a] -> Value #
toEncodingList :: [a] -> Encoding #
Instances
(.:) :: FromJSON a => Object -> Text -> Parser a #
Retrieve the value associated with the given key of an Object.
The result is empty if the key is not present or the value cannot
be converted to the desired type.
This accessor is appropriate if the key and value must be present
in an object for it to be valid. If the key and value are
optional, use .:? instead.
A type that can be converted from JSON, with the possibility of failure.
In many cases, you can get the compiler to generate parsing code for you (see below). To begin, let's cover writing an instance by hand.
There are various reasons a conversion could fail. For example, an
Object could be missing a required key, an Array could be of
the wrong size, or a value could be of an incompatible type.
The basic ways to signal a failed conversion are as follows:
emptyandmzerowork, but are terse and uninformative;failyields a custom error message;typeMismatchproduces an informative message for cases when the value encountered is not of the expected type.
An example type and instance using typeMismatch:
-- Allow ourselves to writeTextliterals. {-# LANGUAGE OverloadedStrings #-} data Coord = Coord { x :: Double, y :: Double } instanceFromJSONCoord whereparseJSON(Objectv) = Coord<$>v.:"x"<*>v.:"y" -- We do not expect a non-Objectvalue here. -- We could usemzeroto fail, buttypeMismatch-- gives a much more informative error message.parseJSONinvalid =typeMismatch"Coord" invalid
For this common case of only being concerned with a single
type of JSON value, the functions withObject, withNumber, etc.
are provided. Their use is to be preferred when possible, since
they are more terse. Using withObject, we can rewrite the above instance
(assuming the same language extension and data type) as:
instanceFromJSONCoord whereparseJSON=withObject"Coord" $ \v -> Coord<$>v.:"x"<*>v.:"y"
Instead of manually writing your FromJSON instance, there are two options
to do it automatically:
- Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so it will probably be more efficient than the following option.
- The compiler can provide a default generic implementation for
parseJSON.
To use the second, simply add a deriving clause to your
datatype and declare a GenericFromJSON instance for your datatype without giving
a definition for parseJSON.
For example, the previous example can be simplified to just:
{-# LANGUAGE DeriveGeneric #-}
import GHC.Generics
data Coord = Coord { x :: Double, y :: Double } deriving Generic
instance FromJSON Coord
The default implementation will be equivalent to
parseJSON = ; If you need different
options, you can customize the generic decoding by defining:genericParseJSON defaultOptions
customOptions =defaultOptions{fieldLabelModifier=maptoUpper} instanceFromJSONCoord whereparseJSON=genericParseJSONcustomOptions
Instances
A JSON value represented as a Haskell value.
Instances
read :: Read a => String -> a #
The read function reads input from a string, which must be
completely consumed by the input process. read fails with an error if the
parse is unsuccessful, and it is therefore discouraged from being used in
real applications. Use readMaybe or readEither for safe alternatives.
>>>read "123" :: Int123
>>>read "hello" :: Int*** Exception: Prelude.read: no parse
class (Alternative m, Monad m) => MonadPlus (m :: * -> *) where #
Monads that also support choice and failure.
Methods
The identity of mplus. It should also satisfy the equations
mzero >>= f = mzero v >> mzero = mzero
The default definition is
mzero = empty
An associative operation. The default definition is
mplus = (<|>)
Instances
Uninhabited data type
Since: base-4.8.0.0
Instances
| Eq Void | Since: base-4.8.0.0 |
| Data Void | Since: base-4.8.0.0 |
Defined in Data.Void Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Void -> c Void # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Void # dataTypeOf :: Void -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Void) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Void) # gmapT :: (forall b. Data b => b -> b) -> Void -> Void # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Void -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Void -> r # gmapQ :: (forall d. Data d => d -> u) -> Void -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Void -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Void -> m Void # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Void -> m Void # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Void -> m Void # | |
| Ord Void | Since: base-4.8.0.0 |
| Read Void | Reading a Since: base-4.8.0.0 |
| Show Void | Since: base-4.8.0.0 |
| Ix Void | Since: base-4.8.0.0 |
| Generic Void | |
| Semigroup Void | Since: base-4.9.0.0 |
| Hashable Void | |
Defined in Data.Hashable.Class | |
| Exception Void | Since: base-4.8.0.0 |
Defined in Data.Void Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String # | |
| ShowErrorComponent Void | |
Defined in Text.Megaparsec.Error Methods showErrorComponent :: Void -> String # | |
| type Rep Void | Since: base-4.8.0.0 |
class Bifunctor (p :: * -> * -> *) where #
A bifunctor is a type constructor that takes
two type arguments and is a functor in both arguments. That
is, unlike with Functor, a type constructor such as Either
does not need to be partially applied for a Bifunctor
instance, and the methods in this class permit mapping
functions over the Left value or the Right value,
or both at the same time.
Formally, the class Bifunctor represents a bifunctor
from Hask -> Hask.
Intuitively it is a bifunctor where both the first and second arguments are covariant.
You can define a Bifunctor by either defining bimap or by
defining both first and second.
If you supply bimap, you should ensure that:
bimapidid≡id
If you supply first and second, ensure:
firstid≡idsecondid≡id
If you supply both, you should also ensure:
bimapf g ≡firstf.secondg
These ensure by parametricity:
bimap(f.g) (h.i) ≡bimapf h.bimapg ifirst(f.g) ≡firstf.firstgsecond(f.g) ≡secondf.secondg
Since: base-4.8.0.0
Methods
bimap :: (a -> b) -> (c -> d) -> p a c -> p b d #
Map over both arguments at the same time.
bimapf g ≡firstf.secondg
Examples
>>>bimap toUpper (+1) ('j', 3)('J',4)
>>>bimap toUpper (+1) (Left 'j')Left 'J'
>>>bimap toUpper (+1) (Right 3)Right 4
Instances
| Bifunctor Either | Since: base-4.8.0.0 |
| Bifunctor (,) | Since: base-4.8.0.0 |
| Bifunctor Arg | Since: base-4.9.0.0 |
| Bifunctor ((,,) x1) | Since: base-4.8.0.0 |
| Bifunctor (Const :: * -> * -> *) | Since: base-4.8.0.0 |
| Bifunctor (Tagged :: * -> * -> *) | |
| Bifunctor (K1 i :: * -> * -> *) | Since: base-4.9.0.0 |
| Bifunctor ((,,,) x1 x2) | Since: base-4.8.0.0 |
| Bifunctor ((,,,,) x1 x2 x3) | Since: base-4.8.0.0 |
| Bifunctor ((,,,,,) x1 x2 x3 x4) | Since: base-4.8.0.0 |
| Bifunctor ((,,,,,,) x1 x2 x3 x4 x5) | Since: base-4.8.0.0 |
class Monad m => MonadIO (m :: * -> *) 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:
Minimal complete definition
Instances
unless :: Applicative f => Bool -> f () -> f () #
The reverse of when.
replicateM_ :: Applicative m => Int -> m a -> m () #
Like replicateM, but discards the result.
replicateM :: Applicative m => Int -> m a -> m [a] #
replicateM n actn times,
gathering the results.
foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m () #
Like foldM, but discards the result.
foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b #
The foldM function is analogous to foldl, except that its result is
encapsulated in a monad. Note that foldM works from left-to-right over
the list arguments. This could be an issue where ( and the `folded
function' are not commutative.>>)
foldM f a1 [x1, x2, ..., xm] == do a2 <- f a1 x1 a3 <- f a2 x2 ... f am xm
If right-to-left evaluation is required, the input list should be reversed.
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () #
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] #
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) #
The mapAndUnzipM function maps its first argument over a list, returning
the result as a pair of lists. This function is mainly used with complicated
data structures or a state-transforming monad.
forever :: Applicative f => f a -> f b #
forever act
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 #
Left-to-right Kleisli composition of monads.
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] #
This generalizes the list-based filter function.
foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m #
fmapDefault :: Traversable t => (a -> b) -> t a -> t b #
This function may be used as a value for fmap in a Functor
instance, provided that traverse is defined. (Using
fmapDefault with a Traversable instance defined only by
sequenceA will result in infinite recursion.)
fmapDefaultf ≡runIdentity.traverse(Identity. f)
mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c) #
mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c) #
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b) #
for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b) #
appendFile :: FilePath -> String -> IO () #
The computation appendFile file str function appends the string str,
to the file file.
Note that writeFile and appendFile write a literal string
to a file. To write a value of any printable type, as with print,
use the show function to convert the value to a string first.
main = appendFile "squares" (show [(x,x*x) | x <- [0,0.1..2]])
interact :: (String -> String) -> IO () #
The interact function takes a function of type String->String
as its argument. The entire input from the standard input device is
passed to this function as its argument, and the resulting string is
output on the standard output device.
getContents :: IO String #
The getContents operation returns all user input as a single string,
which is read lazily as it is needed
(same as hGetContents stdin).
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.
type IOError = IOException #
minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a #
The least element of a non-empty structure with respect to the given comparison function.
maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a #
The largest element of a non-empty structure with respect to the given comparison function.
all :: Foldable t => (a -> Bool) -> t a -> Bool #
Determines whether all elements of the structure satisfy the predicate.
any :: Foldable t => (a -> Bool) -> t a -> Bool #
Determines whether any element of the structure satisfies the predicate.
concatMap :: Foldable t => (a -> [b]) -> t a -> [b] #
Map a function over all the elements of a container and concatenate the resulting lists.
concat :: Foldable t => t [a] -> [a] #
The concatenation of all the elements of a container of lists.
asum :: (Foldable t, Alternative f) => t (f a) -> f a #
sequence_ :: (Foldable t, Monad m) => t (m a) -> m () #
Evaluate each monadic action in the structure from left to right,
and ignore the results. For a version that doesn't ignore the
results see sequence.
As of base 4.8.0.0, sequence_ is just sequenceA_, specialized
to Monad.
sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f () #
Evaluate each action in the structure from left to right, and
ignore the results. For a version that doesn't ignore the results
see sequenceA.
for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f () #
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.
foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b #
Monadic fold over the elements of a structure, associating to the left, i.e. from left to right.
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b #
Monadic fold over the elements of a structure, associating to the right, i.e. from right to left.
words breaks a string up into a list of words, which were delimited
by white space.
>>>words "Lorem ipsum\ndolor"["Lorem","ipsum","dolor"]
lines breaks a string up into a list of strings at newline
characters. The resulting strings do not contain newlines.
Note that after splitting the string at newline characters, the last part of the string is considered a line even if it doesn't end with a newline. For example,
>>>lines ""[]
>>>lines "\n"[""]
>>>lines "one"["one"]
>>>lines "one\n"["one"]
>>>lines "one\n\n"["one",""]
>>>lines "one\ntwo"["one","two"]
>>>lines "one\ntwo\n"["one","two"]
Thus lines ss.
unfoldr :: (b -> Maybe (a, b)) -> b -> [a] #
The unfoldr function is a `dual' to foldr: while foldr
reduces a list to a summary value, unfoldr builds a list from
a seed value. The function takes the element and returns Nothing
if it is done producing the list or returns Just (a,b), in which
case, a is a prepended to the list and b is used as the next
element in a recursive call. For example,
iterate f == unfoldr (\x -> Just (x, f x))
In some cases, unfoldr can undo a foldr operation:
unfoldr f' (foldr f z xs) == xs
if the following holds:
f' (f x y) = Just (x,y) f' z = Nothing
A simple use of unfoldr:
>>>unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10[10,9,8,7,6,5,4,3,2,1]
fromRight :: b -> Either a b -> b #
Return the contents of a Right-value or a default value otherwise.
Examples
Basic usage:
>>>fromRight 1 (Right 3)3>>>fromRight 1 (Left "foo")1
Since: base-4.10.0.0
fromLeft :: a -> Either a b -> a #
Return the contents of a Left-value or a default value otherwise.
Examples
Basic usage:
>>>fromLeft 1 (Left 3)3>>>fromLeft 1 (Right "foo")1
Since: base-4.10.0.0
isRight :: Either a b -> Bool #
Return True if the given value is a Right-value, False otherwise.
Examples
Basic usage:
>>>isRight (Left "foo")False>>>isRight (Right 3)True
Assuming a Left value signifies some sort of error, we can use
isRight to write a very simple reporting function that only
outputs "SUCCESS" when a computation has succeeded.
This example shows how isRight might be used to avoid pattern
matching when one does not care about the value contained in the
constructor:
>>>import Control.Monad ( when )>>>let report e = when (isRight e) $ putStrLn "SUCCESS">>>report (Left "parse error")>>>report (Right 1)SUCCESS
Since: base-4.7.0.0
isLeft :: Either a b -> Bool #
Return True if the given value is a Left-value, False otherwise.
Examples
Basic usage:
>>>isLeft (Left "foo")True>>>isLeft (Right 3)False
Assuming a Left value signifies some sort of error, we can use
isLeft to write a very simple error-reporting function that does
absolutely nothing in the case of success, and outputs "ERROR" if
any error occurred.
This example shows how isLeft might be used to avoid pattern
matching when one does not care about the value contained in the
constructor:
>>>import Control.Monad ( when )>>>let report e = when (isLeft e) $ putStrLn "ERROR">>>report (Right 1)>>>report (Left "parse error")ERROR
Since: base-4.7.0.0
partitionEithers :: [Either a b] -> ([a], [b]) #
Partitions a list of Either into two lists.
All the Left elements are extracted, in order, to the first
component of the output. Similarly the Right elements are extracted
to the second component of the output.
Examples
Basic usage:
>>>let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]>>>partitionEithers list(["foo","bar","baz"],[3,7])
The pair returned by partitionEithers x(:lefts x, rights x)
>>>let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]>>>partitionEithers list == (lefts list, rights list)True
either :: (a -> c) -> (b -> c) -> Either a b -> c #
Case analysis for the Either type.
If the value is Left aa;
if it is Right bb.
Examples
We create two values of type Either String IntLeft constructor and another using the Right constructor. Then
we apply "either" the length function (if we have a String)
or the "times-two" function (if we have an Int):
>>>let s = Left "foo" :: Either String Int>>>let n = Right 3 :: Either String Int>>>either length (*2) s3>>>either length (*2) n6
The lex function reads a single lexeme from the input, discarding
initial white space, and returning the characters that constitute the
lexeme. If the input string contains only white space, lex returns a
single successful `lexeme' consisting of the empty string. (Thus
lex "" = [("","")]lex fails (i.e. returns []).
This lexer is not completely faithful to the Haskell lexical syntax in the following respects:
- Qualified names are not handled properly
- Octal and hexadecimal numerics are not recognized as a single token
- Comments are not treated properly
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
lcm :: Integral a => a -> a -> a #
lcm x yx and y divide.
gcd :: Integral a => a -> a -> a #
gcd x yx and y of which
every common factor of x and y is also a factor; for example
gcd 4 2 = 2gcd (-4) 6 = 2gcd 0 44. gcd 0 00.
(That is, the common divisor that is "greatest" in the divisibility
preordering.)
Note: Since for signed fixed-width integer types, abs minBound < 0minBound0 or minBound
(^^) :: (Fractional a, Integral b) => a -> b -> a infixr 8 #
raise a number to an integral power
showString :: String -> ShowS #
utility function converting a String to a show function that
simply prepends the string unchanged.
utility function converting a Char to a show function that
simply prepends the character unchanged.
unzip :: [(a, b)] -> ([a], [b]) #
unzip transforms a list of pairs into a list of first components
and a list of second components.
(!!) :: [a] -> Int -> a infixl 9 #
List index (subscript) operator, starting from 0.
It is an instance of the more general genericIndex,
which takes an index of any integral type.
lookup :: Eq a => a -> [(a, b)] -> Maybe b #
lookup key assocs looks up a key in an association list.
break :: (a -> Bool) -> [a] -> ([a], [a]) #
break, applied to a predicate p and a list xs, returns a tuple where
first element is longest prefix (possibly empty) of xs of elements that
do not satisfy p and second element is the remainder of the list:
break (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4]) break (< 9) [1,2,3] == ([],[1,2,3]) break (> 9) [1,2,3] == ([1,2,3],[])
span :: (a -> Bool) -> [a] -> ([a], [a]) #
span, applied to a predicate p and a list xs, returns a tuple where
first element is longest prefix (possibly empty) of xs of elements that
satisfy p and second element is the remainder of the list:
span (< 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4]) span (< 9) [1,2,3] == ([1,2,3],[]) span (< 0) [1,2,3] == ([],[1,2,3])
splitAt :: Int -> [a] -> ([a], [a]) #
splitAt n xs returns a tuple where first element is xs prefix of
length n and second element is the remainder of the list:
splitAt 6 "Hello World!" == ("Hello ","World!")
splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5])
splitAt 1 [1,2,3] == ([1],[2,3])
splitAt 3 [1,2,3] == ([1,2,3],[])
splitAt 4 [1,2,3] == ([1,2,3],[])
splitAt 0 [1,2,3] == ([],[1,2,3])
splitAt (-1) [1,2,3] == ([],[1,2,3])It is equivalent to ( when take n xs, drop n xs)n is not _|_
(splitAt _|_ xs = _|_).
splitAt is an instance of the more general genericSplitAt,
in which n may be of any integral type.
drop n xs returns the suffix of xs
after the first n elements, or [] if n > :length xs
drop 6 "Hello World!" == "World!" drop 3 [1,2,3,4,5] == [4,5] drop 3 [1,2] == [] drop 3 [] == [] drop (-1) [1,2] == [1,2] drop 0 [1,2] == [1,2]
It is an instance of the more general genericDrop,
in which n may be of any integral type.
take n, applied to a list xs, returns the prefix of xs
of length n, or xs itself if n > :length xs
take 5 "Hello World!" == "Hello" take 3 [1,2,3,4,5] == [1,2,3] take 3 [1,2] == [1,2] take 3 [] == [] take (-1) [1,2] == [] take 0 [1,2] == []
It is an instance of the more general genericTake,
in which n may be of any integral type.
takeWhile :: (a -> Bool) -> [a] -> [a] #
takeWhile, applied to a predicate p and a list xs, returns the
longest prefix (possibly empty) of xs of elements that satisfy p:
takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2] takeWhile (< 9) [1,2,3] == [1,2,3] takeWhile (< 0) [1,2,3] == []
cycle ties a finite list into a circular one, or equivalently,
the infinite repetition of the original list. It is the identity
on infinite lists.
replicate :: Int -> a -> [a] #
replicate n x is a list of length n with x the value of
every element.
It is an instance of the more general genericReplicate,
in which n may be of any integral type.
mapMaybe :: (a -> Maybe b) -> [a] -> [b] #
The mapMaybe function is a version of map which can throw
out elements. In particular, the functional argument returns
something of type Maybe bNothing, no element
is added on to the result list. If it is Just bb is
included in the result list.
Examples
Using mapMaybe f xcatMaybes $ map f x
>>>import Text.Read ( readMaybe )>>>let readMaybeInt = readMaybe :: String -> Maybe Int>>>mapMaybe readMaybeInt ["1", "Foo", "3"][1,3]>>>catMaybes $ map readMaybeInt ["1", "Foo", "3"][1,3]
If we map the Just constructor, the entire list should be returned:
>>>mapMaybe Just [1,2,3][1,2,3]
catMaybes :: [Maybe a] -> [a] #
The catMaybes function takes a list of Maybes and returns
a list of all the Just values.
Examples
Basic usage:
>>>catMaybes [Just 1, Nothing, Just 3][1,3]
When constructing a list of Maybe values, catMaybes can be used
to return all of the "success" results (if the list is the result
of a map, then mapMaybe would be more appropriate):
>>>import Text.Read ( readMaybe )>>>[readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ][Just 1,Nothing,Just 3]>>>catMaybes $ [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ][1,3]
listToMaybe :: [a] -> Maybe a #
The listToMaybe function returns Nothing on an empty list
or Just aa is the first element of the list.
Examples
Basic usage:
>>>listToMaybe []Nothing
>>>listToMaybe [9]Just 9
>>>listToMaybe [1,2,3]Just 1
Composing maybeToList with listToMaybe should be the identity
on singleton/empty lists:
>>>maybeToList $ listToMaybe [5][5]>>>maybeToList $ listToMaybe [][]
But not on lists with more than one element:
>>>maybeToList $ listToMaybe [1,2,3][1]
maybeToList :: Maybe a -> [a] #
The maybeToList function returns an empty list when given
Nothing or a singleton list when not given Nothing.
Examples
Basic usage:
>>>maybeToList (Just 7)[7]
>>>maybeToList Nothing[]
One can use maybeToList to avoid pattern matching when combined
with a function that (safely) works on lists:
>>>import Text.Read ( readMaybe )>>>sum $ maybeToList (readMaybe "3")3>>>sum $ maybeToList (readMaybe "")0
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
maybe :: b -> (a -> b) -> Maybe a -> b #
The maybe function takes a default value, a function, and a Maybe
value. If the Maybe value is Nothing, the function returns the
default value. Otherwise, it applies the function to the value inside
the Just and returns the result.
Examples
Basic usage:
>>>maybe False odd (Just 3)True
>>>maybe False odd NothingFalse
Read an integer from a string using readMaybe. If we succeed,
return twice the integer; that is, apply (*2) to it. If instead
we fail to parse an integer, return 0 by default:
>>>import Text.Read ( readMaybe )>>>maybe 0 (*2) (readMaybe "5")10>>>maybe 0 (*2) (readMaybe "")0
Apply show to a Maybe Int. If we have Just n, we want to show
the underlying Int n. But if we have Nothing, we return the
empty string instead of (for example) "Nothing":
>>>maybe "" show (Just 5)"5">>>maybe "" show Nothing""
uncurry :: (a -> b -> c) -> (a, b) -> c #
uncurry converts a curried function to a function on pairs.
Examples
>>>uncurry (+) (1,2)3
>>>uncurry ($) (show, 1)"1"
>>>map (uncurry max) [(1,2), (3,4), (6,8)][2,4,8]
until :: (a -> Bool) -> (a -> a) -> a -> a #
until p ff until p holds.
($!) :: (a -> b) -> a -> b infixr 0 #
Strict (call-by-value) application operator. It takes a function and an argument, evaluates the argument to weak head normal form (WHNF), then calls the function with that value.
flip :: (a -> b -> c) -> b -> a -> c #
flip ff.
>>>flip (++) "hello" "world""worldhello"
const x is a unary function which evaluates to x for all inputs.
>>>const 42 "hello"42
>>>map (const 42) [0..3][42,42,42,42]
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r #
Promote a function to a monad, scanning the monadic arguments from
left to right (cf. liftM2).
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r #
Promote a function to a monad, scanning the monadic arguments from
left to right (cf. liftM2).
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r #
Promote a function to a monad, scanning the monadic arguments from
left to right (cf. liftM2).
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r #
Promote a function to a monad, scanning the monadic arguments from left to right. For example,
liftM2 (+) [0,1] [0,2] = [0,2,1,3] liftM2 (+) (Just 1) Nothing = Nothing
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.
(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 #
Same as >>=, but with the arguments interchanged.
undefined :: HasCallStack => a #
errorWithoutStackTrace :: [Char] -> a #
A variant of error that does not produce a stack trace.
Since: base-4.9.0.0
error :: HasCallStack => [Char] -> a #
error stops execution and displays an error message.
preEscapedToMarkup :: ToMarkup a => a -> Markup #
Convert a value to Markup without escaping
class MonadIO m => MonadUnliftIO (m :: * -> *) where #
Monads which allow their actions to be run in IO.
While MonadIO allows an IO action to be lifted into another
monad, this class captures the opposite concept: allowing you to
capture the monadic context. Note that, in order to meet the laws
given below, the intuition is that a monad must have no monadic
state, but may have monadic context. This essentially limits
MonadUnliftIO to ReaderT and IdentityT transformers on top of
IO.
Laws. For any value u returned by askUnliftIO, it must meet the
monad transformer laws as reformulated for MonadUnliftIO:
unliftIO u . return = return
unliftIO u (m >>= f) = unliftIO u m >>= unliftIO u . f
The third is a currently nameless law which ensures that the current context is preserved.
askUnliftIO >>= (u -> liftIO (unliftIO u m)) = m
If you have a name for this, please submit it in a pull request for great glory.
Since: unliftio-core-0.1.0.0
Minimal complete definition
Methods
askUnliftIO :: m (UnliftIO m) #
Capture the current monadic context, providing the ability to
run monadic actions in IO.
See UnliftIO for an explanation of why we need a helper
datatype here.
@since 0.1.0.0
withRunInIO :: ((forall a. m a -> IO a) -> IO b) -> m b #
Convenience function for capturing the monadic context and running an IO
action with a runner function. The runner function is used to run a monadic
action m in IO.
Since: unliftio-core-0.1.0.0
Instances
class MonadIO m => MonadResource (m :: * -> *) where #
A Monad which allows for safe resource allocation. In theory, any monad
transformer stack which includes a ResourceT can be an instance of
MonadResource.
Note: runResourceT has a requirement for a MonadUnliftIO m monad,
which allows control operations to be lifted. A MonadResource does not
have this requirement. This means that transformers such as ContT can be
an instance of MonadResource. However, the ContT wrapper will need to be
unwrapped before calling runResourceT.
Since 0.3.0
Minimal complete definition
Methods
liftResourceT :: ResourceT IO a -> m a #
Lift a ResourceT IO action into the current Monad.
Since 0.4.0
Instances
class MonadTrans (t :: (* -> *) -> * -> *) where #
The class of monad transformers. Instances should satisfy the
following laws, which state that lift is a monad transformation:
Minimal complete definition
Methods
lift :: Monad m => m a -> t m a #
Lift a computation from the argument monad to the constructed monad.
Instances
This is a length of time, as measured by a clock. Conversion functions will treat it as seconds. It has a precision of 10^-12 s.
Instances
| Enum DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime | |
| Eq DiffTime | |
| Fractional DiffTime | |
| Data DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DiffTime -> c DiffTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DiffTime # toConstr :: DiffTime -> Constr # dataTypeOf :: DiffTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DiffTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DiffTime) # gmapT :: (forall b. Data b => b -> b) -> DiffTime -> DiffTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DiffTime -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DiffTime -> r # gmapQ :: (forall d. Data d => d -> u) -> DiffTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DiffTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime # | |
| Num DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime | |
| Ord DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime | |
| Real DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime Methods toRational :: DiffTime -> Rational # | |
| RealFrac DiffTime | |
| Show DiffTime | |
| ToJSON DiffTime | |
Defined in Data.Aeson.Types.ToJSON | |
| FromJSON DiffTime | This instance includes a bounds check to prevent maliciously
large inputs to fill up the memory of the target system. You can
newtype |
| NFData DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime | |
A class for types with a default value.
Instances
Generates a function that takes a LogSource, a level name and a Text and logs a LevelOther message. Usage:
$logOtherS "SomeSource" "My new level" "This is a log message"
Generates a function that takes a LogSource and Text and logs a LevelDebug message. Usage:
$logDebugS "SomeSource" "This is a debug log message"
Generates a function that takes a Text and logs a LevelOther message. Usage:
$(logOther "My new level") "This is a log message"
Generates a function that takes a Text and logs a LevelDebug message. Usage:
$(logDebug) "This is a debug log message"
Constructors
| LevelDebug | |
| LevelInfo | |
| LevelWarn | |
| LevelError | |
| LevelOther Text |
class Monad m => MonadLogger (m :: * -> *) #
A Monad which has the ability to log messages in some manner.
Instances
Minimal complete definition
Instances
| PathPiece Bool | |
Defined in Web.PathPieces | |
| PathPiece Int | |
Defined in Web.PathPieces | |
| PathPiece Int8 | |
Defined in Web.PathPieces | |
| PathPiece Int16 | |
Defined in Web.PathPieces | |
| PathPiece Int32 | |
Defined in Web.PathPieces | |
| PathPiece Int64 | |
Defined in Web.PathPieces | |
| PathPiece Integer | |
Defined in Web.PathPieces | |
| PathPiece Word | |
Defined in Web.PathPieces | |
| PathPiece Word8 | |
Defined in Web.PathPieces | |
| PathPiece Word16 | |
Defined in Web.PathPieces | |
| PathPiece Word32 | |
Defined in Web.PathPieces | |
| PathPiece Word64 | |
Defined in Web.PathPieces | |
| PathPiece () | |
Defined in Web.PathPieces | |
| PathPiece String | |
Defined in Web.PathPieces | |
| PathPiece Text | |
Defined in Web.PathPieces | |
| PathPiece Text | |
Defined in Web.PathPieces | |
| PathPiece Checkmark | |
Defined in Database.Persist.Types.Base | |
| PathPiece PersistValue | |
Defined in Database.Persist.Types.Base | |
| PathPiece Day | |
Defined in Web.PathPieces | |
| PathPiece a => PathPiece (Maybe a) | |
Defined in Web.PathPieces | |
class PathMultiPiece s where #
Minimal complete definition
Instances
| PathPiece a => PathMultiPiece [a] | |
Defined in Web.PathPieces | |
limitOffsetOrder :: PersistEntity val => [SelectOpt val] -> (Int, Int, [SelectOpt val]) #
FIXME What's this exactly?
toJsonText :: ToJSON j => j -> Text #
mapToJSON :: [(Text, PersistValue)] -> Text #
Convert map (list of tuples) into textual representation of JSON
object. This is a type-constrained synonym for toJsonText.
listToJSON :: [PersistValue] -> Text #
Convert list of PersistValues into textual representation of JSON
object. This is a type-constrained synonym for toJsonText.
(||.) :: [Filter v] -> [Filter v] -> [Filter v] infixl 3 #
The OR of two lists of filters. For example:
selectList
([ PersonAge >. 25
, PersonAge <. 30 ] ||.
[ PersonIncome >. 15000
, PersonIncome <. 25000 ])
[]will filter records where a person's age is between 25 and 30 or a person's income is between (15000 and 25000).
If you are looking for an (&&.) operator to do (A AND B AND (C OR D))
you can use the (++) operator instead as there is no (&&.). For
example:
selectList
([ PersonAge >. 25
, PersonAge <. 30 ] ++
([PersonCategory ==. 1] ||.
[PersonCategory ==. 5]))
[]will filter records where a person's age is between 25 and 30 and (person's category is either 1 or 5).
(/<-.) :: PersistField typ => EntityField v typ -> [typ] -> Filter v infix 4 #
Check if value is not in given list.
Example usage
selectSimon :: MonadIO m => ReaderT SqlBackend m [Entity User] selectSimon = selectList [UserAge /<-. [40]] []
The above query when applied on dataset-1, will produce this:
+-----+-----+-----+ |id |name |age | +-----+-----+-----+ |2 |Simon|41 | +-----+-----+-----+
(<-.) :: PersistField typ => EntityField v typ -> [typ] -> Filter v infix 4 #
Check if value is in given list.
Example usage
selectUsers :: MonadIO m => ReaderT SqlBackend m [Entity User] selectUsers = selectList [UserAge <-. [40, 41]] []
The above query when applied on dataset-1, will produce this:
+-----+-----+-----+ |id |name |age | +-----+-----+-----+ |1 |SPJ |40 | +-----+-----+-----+ |2 |Simon|41 | +-----+-----+-----+
selectSPJ :: MonadIO m => ReaderT SqlBackend m [Entity User] selectSPJ = selectList [UserAge <-. [40]] []
The above query when applied on dataset-1, will produce this:
+-----+-----+-----+ |id |name |age | +-----+-----+-----+ |1 |SPJ |40 | +-----+-----+-----+
(>=.) :: PersistField typ => EntityField v typ -> typ -> Filter v infix 4 #
Greater-than or equal check.
Example usage
selectGreaterEqualAge :: MonadIO m => ReaderT SqlBackend m [Entity User] selectGreaterEqualAge = selectList [UserAge >=. 41 ] []
The above query when applied on dataset-1, will produce this:
+-----+-----+-----+ |id |name |age | +-----+-----+-----+ |2 |Simon|41 | +-----+-----+-----+
(>.) :: PersistField typ => EntityField v typ -> typ -> Filter v infix 4 #
Greater-than check.
Example usage
selectGreaterAge :: MonadIO m => ReaderT SqlBackend m [Entity User] selectGreaterAge = selectList [UserAge >. 40 ] []
The above query when applied on dataset-1, will produce this:
+-----+-----+-----+ |id |name |age | +-----+-----+-----+ |2 |Simon|41 | +-----+-----+-----+
(<=.) :: PersistField typ => EntityField v typ -> typ -> Filter v infix 4 #
Less-than or equal check.
Example usage
selectLessEqualAge :: MonadIO m => ReaderT SqlBackend m [Entity User] selectLessEqualAge = selectList [UserAge <=. 40 ] []
The above query when applied on dataset-1, will produce this:
+-----+-----+-----+ |id |name |age | +-----+-----+-----+ |1 |SPJ |40 | +-----+-----+-----+
(<.) :: PersistField typ => EntityField v typ -> typ -> Filter v infix 4 #
Less-than check.
Example usage
selectLessAge :: MonadIO m => ReaderT SqlBackend m [Entity User] selectLessAge = selectList [UserAge <. 41 ] []
The above query when applied on dataset-1, will produce this:
+-----+-----+-----+ |id |name |age | +-----+-----+-----+ |1 |SPJ |40 | +-----+-----+-----+
(!=.) :: PersistField typ => EntityField v typ -> typ -> Filter v infix 4 #
Non-equality check.
Example usage
selectSimon :: MonadIO m => ReaderT SqlBackend m [Entity User] selectSimon = selectList [UserName !=. "SPJ" ] []
The above query when applied on dataset-1, will produce this:
+-----+-----+-----+ |id |name |age | +-----+-----+-----+ |2 |Simon|41 | +-----+-----+-----+
(==.) :: PersistField typ => EntityField v typ -> typ -> Filter v infix 4 #
Check for equality.
Example usage
selectSPJ :: MonadIO m => ReaderT SqlBackend m [Entity User] selectSPJ = selectList [UserName ==. "SPJ" ] []
The above query when applied on dataset-1, will produce this:
+-----+-----+-----+ |id |name |age | +-----+-----+-----+ |1 |SPJ |40 | +-----+-----+-----+
(/=.) :: PersistField typ => EntityField v typ -> typ -> Update v infixr 3 #
Assign a field by division (/=).
Example usage
divideAge :: MonadIO m => ReaderT SqlBackend m () divideAge = updateWhere [UserName ==. "SPJ" ] [UserAge /=. 2]
The above query when applied on dataset-1, will produce this:
+-----+-----+---------+ |id |name |age | +-----+-----+---------+ |1 |SPJ |40 -> 20 | +-----+-----+---------+ |2 |Simon|41 | +-----+-----+---------+
(*=.) :: PersistField typ => EntityField v typ -> typ -> Update v infixr 3 #
Assign a field by multiplication (*=).
Example usage
multiplyAge :: MonadIO m => ReaderT SqlBackend m () multiplyAge = updateWhere [UserName ==. "SPJ" ] [UserAge *=. 2]
The above query when applied on dataset-1, will produce this:
+-----+-----+--------+ |id |name |age | +-----+-----+--------+ |1 |SPJ |40 -> 80| +-----+-----+--------+ |2 |Simon|41 | +-----+-----+--------+
(-=.) :: PersistField typ => EntityField v typ -> typ -> Update v infixr 3 #
Assign a field by subtraction (-=).
Example usage
subtractAge :: MonadIO m => ReaderT SqlBackend m () subtractAge = updateWhere [UserName ==. "SPJ" ] [UserAge -=. 1]
The above query when applied on dataset-1, will produce this:
+-----+-----+---------+ |id |name |age | +-----+-----+---------+ |1 |SPJ |40 -> 39 | +-----+-----+---------+ |2 |Simon|41 | +-----+-----+---------+
(+=.) :: PersistField typ => EntityField v typ -> typ -> Update v infixr 3 #
Assign a field by addition (+=).
Example usage
addAge :: MonadIO m => ReaderT SqlBackend m () addAge = updateWhere [UserName ==. "SPJ" ] [UserAge +=. 1]
The above query when applied on dataset-1, will produce this:
+-----+-----+---------+ |id |name |age | +-----+-----+---------+ |1 |SPJ |40 -> 41 | +-----+-----+---------+ |2 |Simon|41 | +-----+-----+---------+
(=.) :: PersistField typ => EntityField v typ -> typ -> Update v infixr 3 #
Assign a field a value.
Example usage
updateAge :: MonadIO m => ReaderT SqlBackend m () updateAge = updateWhere [UserName ==. "SPJ" ] [UserAge =. 45]
Similar to updateWhere which is shown in the above example you can use other functions present in the module Database.Persist.Class. Note that the first parameter of updateWhere is [Filter val] and second parameter is [Update val]. By comparing this with the type of ==. and =., you can see that they match up in the above usage.
The above query when applied on dataset-1, will produce this:
+-----+-----+--------+ |id |name |age | +-----+-----+--------+ |1 |SPJ |40 -> 45| +-----+-----+--------+ |2 |Simon|41 | +-----+-----+--------+
type PersistUnique a = PersistUniqueWrite a #
A backwards-compatible alias for those that don't care about distinguishing between read and write queries. It signifies the assumption that, by default, a backend can write as well as read.
type PersistQuery a = PersistQueryWrite a #
A backwards-compatible alias for those that don't care about distinguishing between read and write queries. It signifies the assumption that, by default, a backend can write as well as read.
type PersistStore a = PersistStoreWrite a #
A backwards-compatible alias for those that don't care about distinguishing between read and write queries. It signifies the assumption that, by default, a backend can write as well as read.
deleteCascadeWhere :: (MonadIO m, DeleteCascade record backend, PersistQueryWrite backend) => [Filter record] -> ReaderT backend m () #
Cascade-deletion of entries satisfying given filters.
class (PersistStoreWrite backend, PersistEntity record, BaseBackend backend ~ PersistEntityBackend record) => DeleteCascade record backend where #
For combinations of backends and entities that support cascade-deletion. “Cascade-deletion” means that entries that depend on other entries to be deleted will be deleted as well.
Minimal complete definition
Methods
deleteCascade :: MonadIO m => Key record -> ReaderT backend m () #
Perform cascade-deletion of single database entry.
selectKeysList :: (MonadIO m, PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m [Key record] #
Call selectKeys but return the result as a list.
selectList :: (MonadIO m, PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m [Entity record] #
Call selectSource but return the result as a list.
selectKeys :: (PersistQueryRead (BaseBackend backend), MonadResource m, PersistEntity record, BaseBackend (BaseBackend backend) ~ PersistEntityBackend record, MonadReader backend m, HasPersistBackend backend) => [Filter record] -> [SelectOpt record] -> ConduitM () (Key record) m () #
Get the Keys of all records matching the given criterion.
selectSource :: (PersistQueryRead (BaseBackend backend), MonadResource m, PersistEntity record, PersistEntityBackend record ~ BaseBackend (BaseBackend backend), MonadReader backend m, HasPersistBackend backend) => [Filter record] -> [SelectOpt record] -> ConduitM () (Entity record) m () #
Get all records matching the given criterion in the specified order. Returns also the identifiers.
class (PersistCore backend, PersistStoreRead backend) => PersistQueryRead backend where #
Backends supporting conditional read operations.
Minimal complete definition
Methods
selectSourceRes :: (PersistRecordBackend record backend, MonadIO m1, MonadIO m2) => [Filter record] -> [SelectOpt record] -> ReaderT backend m1 (Acquire (ConduitM () (Entity record) m2 ())) #
Get all records matching the given criterion in the specified order. Returns also the identifiers.
selectFirst :: (MonadIO m, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record)) #
Get just the first record for the criterion.
selectKeysRes :: (MonadIO m1, MonadIO m2, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m1 (Acquire (ConduitM () (Key record) m2 ())) #
Get the Keys of all records matching the given criterion.
count :: (MonadIO m, PersistRecordBackend record backend) => [Filter record] -> ReaderT backend m Int #
The total number of records fulfilling the given criterion.
class (PersistQueryRead backend, PersistStoreWrite backend) => PersistQueryWrite backend where #
Backends supporting conditional write operations
Minimal complete definition
Methods
updateWhere :: (MonadIO m, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> ReaderT backend m () #
Update individual fields on any record matching the given criterion.
deleteWhere :: (MonadIO m, PersistRecordBackend record backend) => [Filter record] -> ReaderT backend m () #
Delete all records matching the given criterion.
checkUnique :: (MonadIO m, PersistRecordBackend record backend, PersistUniqueRead backend) => record -> ReaderT backend m (Maybe (Unique record)) #
Check whether there are any conflicts for unique keys with this entity and existing entities in the database.
Returns Nothing if the entity would be unique, and could thus safely be inserted.
on a conflict returns the conflicting key
replaceUnique :: (MonadIO m, Eq record, Eq (Unique record), PersistRecordBackend record backend, PersistUniqueWrite backend) => Key record -> record -> ReaderT backend m (Maybe (Unique record)) #
Attempt to replace the record of the given key with the given new record. First query the unique fields to make sure the replacement maintains uniqueness constraints.
Return Nothing if the replacement was made.
If uniqueness is violated, return a Just with the Unique violation
Since: persistent-1.2.2.0
getByValue :: (MonadIO m, PersistUniqueRead backend, PersistRecordBackend record backend) => record -> ReaderT backend m (Maybe (Entity record)) #
A modification of getBy, which takes the PersistEntity itself instead
of a Unique record. Returns a record matching one of the unique keys. This
function makes the most sense on entities with a single Unique
constructor.
onlyUnique :: (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ReaderT backend m (Unique record) #
Return the single unique key for a record.
insertUniqueEntity :: (MonadIO m, PersistRecordBackend record backend, PersistUniqueWrite backend) => record -> ReaderT backend m (Maybe (Entity record)) #
Like insertEntity, but returns Nothing when the record
couldn't be inserted because of a uniqueness constraint.
Since: persistent-2.7.1
insertBy :: (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend record backend) => record -> ReaderT backend m (Either (Entity record) (Key record)) #
class (PersistCore backend, PersistStoreRead backend) => PersistUniqueRead backend where #
Queries against Unique keys (other than the id Key).
Please read the general Persistent documentation to learn how to create
Unique keys.
Using this with an Entity without a Unique key leads to undefined
behavior. A few of these functions require a single Unique, so using
an Entity with multiple Uniques is also undefined. In these cases
persistent's goal is to throw an exception as soon as possible, but
persistent is still transitioning to that.
SQL backends automatically create uniqueness constraints, but for MongoDB you must manually place a unique index on a field to have a uniqueness constraint.
Minimal complete definition
class (PersistUniqueRead backend, PersistStoreWrite backend) => PersistUniqueWrite backend where #
Some functions in this module (insertUnique, insertBy, and
replaceUnique) first query the unique indexes to check for
conflicts. You could instead optimistically attempt to perform the
operation (e.g. replace instead of replaceUnique). However,
- there is some fragility to trying to catch the correct exception and determing the column of failure;
- an exception will automatically abort the current SQL transaction.
Minimal complete definition
Methods
deleteBy :: (MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m () #
Delete a specific record by unique key. Does nothing if no record matches.
insertUnique :: (MonadIO m, PersistRecordBackend record backend) => record -> ReaderT backend m (Maybe (Key record)) #
Like insert, but returns Nothing when the record
couldn't be inserted because of a uniqueness constraint.
Arguments
| :: (MonadIO m, PersistRecordBackend record backend) | |
| => record | new record to insert |
| -> [Update record] | updates to perform if the record already exists (leaving
this empty is the equivalent of performing a |
| -> ReaderT backend m (Entity record) | the record in the database after the operation |
Update based on a uniqueness constraint or insert:
- insert the new record if it does not exist;
- If the record exists (matched via it's uniqueness constraint), then update the existing record with the parameters which is passed on as list to the function.
Throws an exception if there is more than 1 uniqueness constraint.
Arguments
| :: (MonadIO m, PersistRecordBackend record backend) | |
| => Unique record | uniqueness constraint to find by |
| -> record | new record to insert |
| -> [Update record] | updates to perform if the record already exists (leaving
this empty is the equivalent of performing a |
| -> ReaderT backend m (Entity record) | the record in the database after the operation |
Update based on a given uniqueness constraint or insert:
- insert the new record if it does not exist;
- update the existing record that matches the given uniqueness constraint.
Arguments
| :: (MonadIO m, PersistRecordBackend record backend) | |
| => [record] | A list of the records you want to insert or replace. |
| -> ReaderT backend m () |
Put many records into db
- insert new records that do not exist (or violate any unique constraints)
- replace existing records (matching any unique constraint) @since 2.8.1
insertRecord :: (PersistEntityBackend record ~ BaseBackend backend, PersistEntity record, MonadIO m, PersistStoreWrite backend) => record -> ReaderT backend m record #
Like insertEntity but just returns the record instead of Entity.
Since: persistent-2.6.1
getEntity :: (PersistStoreRead backend, PersistRecordBackend e backend, MonadIO m) => Key e -> ReaderT backend m (Maybe (Entity e)) #
Like get, but returns the complete Entity.
insertEntity :: (PersistStoreWrite backend, PersistRecordBackend e backend, MonadIO m) => e -> ReaderT backend m (Entity e) #
Like insert, but returns the complete Entity.
belongsToJust :: (PersistStoreRead backend, PersistEntity ent1, PersistRecordBackend ent2 backend, MonadIO m) => (ent1 -> Key ent2) -> ent1 -> ReaderT backend m ent2 #
Same as belongsTo, but uses getJust and therefore is similarly unsafe.
belongsTo :: (PersistStoreRead backend, PersistEntity ent1, PersistRecordBackend ent2 backend, MonadIO m) => (ent1 -> Maybe (Key ent2)) -> ent1 -> ReaderT backend m (Maybe ent2) #
Curry this to make a convenience function that loads an associated model.
foreign = belongsTo foreignId
getJustEntity :: (PersistEntityBackend record ~ BaseBackend backend, MonadIO m, PersistEntity record, PersistStoreRead backend) => Key record -> ReaderT backend m (Entity record) #
getJust :: (PersistStoreRead backend, Show (Key record), PersistRecordBackend record backend, MonadIO m) => Key record -> ReaderT backend m record #
Same as get, but for a non-null (not Maybe) foreign key.
Unsafe unless your database is enforcing that the foreign key is valid.
liftPersist :: (MonadIO m, MonadReader backend m, HasPersistBackend backend) => ReaderT (BaseBackend backend) IO b -> m b #
class HasPersistBackend backend where #
Class which allows the plucking of a BaseBackend backend from some larger type.
For example,
instance HasPersistBackend (SqlReadBackend, Int) where
type BaseBackend (SqlReadBackend, Int) = SqlBackend
persistBackend = unSqlReadBackend . fst
Minimal complete definition
Associated Types
type BaseBackend backend :: * #
Methods
persistBackend :: backend -> BaseBackend backend #
Instances
| HasPersistBackend SqlBackend | |
Defined in Database.Persist.Sql.Types.Internal Associated Types type BaseBackend SqlBackend :: * # Methods | |
| HasPersistBackend SqlReadBackend | |
Defined in Database.Persist.Sql.Types.Internal Associated Types type BaseBackend SqlReadBackend :: * # Methods persistBackend :: SqlReadBackend -> BaseBackend SqlReadBackend # | |
| HasPersistBackend SqlWriteBackend | |
Defined in Database.Persist.Sql.Types.Internal Associated Types type BaseBackend SqlWriteBackend :: * # Methods persistBackend :: SqlWriteBackend -> BaseBackend SqlWriteBackend # | |
class HasPersistBackend backend => IsPersistBackend backend #
Class which witnesses that backend is essentially the same as BaseBackend backend.
That is, they're isomorphic and backend is just some wrapper over BaseBackend backend.
Minimal complete definition
Instances
| IsPersistBackend SqlBackend | |
Defined in Database.Persist.Sql.Types.Internal Methods | |
| IsPersistBackend SqlReadBackend | |
Defined in Database.Persist.Sql.Types.Internal Methods mkPersistBackend :: BaseBackend SqlReadBackend -> SqlReadBackend # | |
| IsPersistBackend SqlWriteBackend | |
Defined in Database.Persist.Sql.Types.Internal Methods mkPersistBackend :: BaseBackend SqlWriteBackend -> SqlWriteBackend # | |
class BackendCompatible sup sub where #
This class witnesses that two backend are compatible, and that you can
convert from the sub backend into the sup backend. This is similar
to the HasPersistBackend and IsPersistBackend classes, but where you
don't want to fix the type associated with the PersistEntityBackend of
a record.
Generally speaking, where you might have:
foo :: (PersistEntityrecord ,PeristEntityBackendrecord ~BaseBackendbackend ,IsSqlBackendbackend )
this can be replaced with:
foo :: (PersistEntityrecord, ,PersistEntityBackendrecord ~ backend ,BackendCompatibleSqlBackendbackend )
This works for SqlReadBackend because of the instance , without needing to go through the BackendCompatible SqlBackend SqlReadBackendBaseBackend type family.
Likewise, functions that are currently hardcoded to use SqlBackend can be generalized:
-- before: asdf ::ReaderTSqlBackendm () asdf = pure () -- after: asdf' ::BackendCompatibleSqlBackend backend => ReaderT backend m () asdf' = withReaderTprojectBackendasdf
Since: persistent-2.7.1
Minimal complete definition
Methods
projectBackend :: sub -> sup #
type PersistRecordBackend record backend = (PersistEntity record, PersistEntityBackend record ~ BaseBackend backend) #
A convenient alias for common type signatures
class (PersistEntity record, PersistEntityBackend record ~ backend, PersistCore backend) => ToBackendKey backend record where #
ToBackendKey converts a PersistEntity Key into a BackendKey
This can be used by each backend to convert between a Key and a plain
Haskell type. For Sql, that is done with toSqlKey and fromSqlKey.
By default, a PersistEntity uses the default BackendKey for its Key
and is an instance of ToBackendKey
A Key that instead uses a custom type will not be an instance of
ToBackendKey.
Minimal complete definition
Methods
toBackendKey :: Key record -> BackendKey backend #
fromBackendKey :: BackendKey backend -> Key record #
class PersistCore backend #
Associated Types
data BackendKey backend :: * #
class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistCore backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreRead backend where #
Minimal complete definition
Methods
get :: (MonadIO m, PersistRecordBackend record backend) => Key record -> ReaderT backend m (Maybe record) #
Get a record by identifier, if available.
getMany :: (MonadIO m, PersistRecordBackend record backend) => [Key record] -> ReaderT backend m (Map (Key record) record) #
Get many records by their respective identifiers, if available.
Since: persistent-2.8.1
class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistStoreRead backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreWrite backend where #
Methods
insert :: (MonadIO m, PersistRecordBackend record backend) => record -> ReaderT backend m (Key record) #
Create a new record in the database, returning an automatically created key (in SQL an auto-increment id).
insert_ :: (MonadIO m, PersistRecordBackend record backend) => record -> ReaderT backend m () #
Same as insert, but doesn't return a Key.
insertMany :: (MonadIO m, PersistRecordBackend record backend) => [record] -> ReaderT backend m [Key record] #
Create multiple records in the database and return their Keys.
If you don't need the inserted Keys, use insertMany_.
The MongoDB and PostgreSQL backends insert all records and retrieve their keys in one database query.
The SQLite and MySQL backends use the slow, default implementation of
mapM insert.
insertMany_ :: (MonadIO m, PersistRecordBackend record backend) => [record] -> ReaderT backend m () #
Same as insertMany, but doesn't return any Keys.
The MongoDB, PostgreSQL, SQLite and MySQL backends insert all records in one database query.
insertEntityMany :: (MonadIO m, PersistRecordBackend record backend) => [Entity record] -> ReaderT backend m () #
Same as insertMany_, but takes an Entity instead of just a record.
Useful when migrating data from one entity to another and want to preserve ids.
The MongoDB, PostgreSQL, SQLite and MySQL backends insert all records in one database query.
insertKey :: (MonadIO m, PersistRecordBackend record backend) => Key record -> record -> ReaderT backend m () #
Create a new record in the database using the given key.
repsert :: (MonadIO m, PersistRecordBackend record backend) => Key record -> record -> ReaderT backend m () #
Put the record in the database with the given key.
Unlike replace, if a record with the given key does not
exist then a new record will be inserted.
repsertMany :: (MonadIO m, PersistRecordBackend record backend) => [(Key record, record)] -> ReaderT backend m () #
Put many entities into the database.
Batch version of repsert for SQL backends.
Useful when migrating data from one entity to another and want to preserve ids.
Differs from insertEntityMany by gracefully skipping
pre-existing records matching key(s).
@since 2.8.1
replace :: (MonadIO m, PersistRecordBackend record backend) => Key record -> record -> ReaderT backend m () #
Replace the record in the database with the given
key. Note that the result is undefined if such record does
not exist, so you must use 'insertKey or repsert in
these cases.
delete :: (MonadIO m, PersistRecordBackend record backend) => Key record -> ReaderT backend m () #
Delete a specific record by identifier. Does nothing if record does not exist.
update :: (MonadIO m, PersistRecordBackend record backend) => Key record -> [Update record] -> ReaderT backend m () #
Update individual fields on a specific record.
updateGet :: (MonadIO m, PersistRecordBackend record backend) => Key record -> [Update record] -> ReaderT backend m record #
Update individual fields on a specific record, and retrieve the updated value from the database.
Note that this function will throw an exception if the given key is not found in the database.
fromPersistValueJSON :: FromJSON a => PersistValue -> Either Text a #
Convenience function for getting a free PersistField instance
from a type with JSON instances. The JSON parser used will accept JSON
values other that object and arrays. So, if your instance serializes the
data to a JSON string, this will still work.
Example usage in combination with toPersistValueJSON:
instance PersistField MyData where fromPersistValue = fromPersistValueJSON toPersistValue = toPersistValueJSON
toPersistValueJSON :: ToJSON a => a -> PersistValue #
Convenience function for getting a free PersistField instance
from a type with JSON instances.
Example usage in combination with fromPersistValueJSON:
instance PersistField MyData where fromPersistValue = fromPersistValueJSON toPersistValue = toPersistValueJSON
entityIdFromJSON :: (PersistEntity record, FromJSON record, FromJSON (Key record)) => Value -> Parser (Entity record) #
Predefined parseJSON. The input JSON looks like
{"id": 1, "name": ...}.
The typical usage is:
instance FromJSON (Entity User) where
parseJSON = entityIdFromJSON
entityIdToJSON :: (PersistEntity record, ToJSON record, ToJSON (Key record)) => Entity record -> Value #
Predefined toJSON. The resulting JSON looks like
{"id": 1, "name": ...}.
The typical usage is:
instance ToJSON (Entity User) where
toJSON = entityIdToJSON
keyValueEntityFromJSON :: (PersistEntity record, FromJSON record, FromJSON (Key record)) => Value -> Parser (Entity record) #
Predefined parseJSON. The input JSON looks like
{"key": 1, "value": {"name": ...}}.
The typical usage is:
instance FromJSON (Entity User) where
parseJSON = keyValueEntityFromJSON
keyValueEntityToJSON :: (PersistEntity record, ToJSON record, ToJSON (Key record)) => Entity record -> Value #
Predefined toJSON. The resulting JSON looks like
{"key": 1, "value": {"name": ...}}.
The typical usage is:
instance ToJSON (Entity User) where
toJSON = keyValueEntityToJSON
entityValues :: PersistEntity record => Entity record -> [PersistValue] #
Get list of values corresponding to given entity.
class (PersistField (Key record), ToJSON (Key record), FromJSON (Key record), Show (Key record), Read (Key record), Eq (Key record), Ord (Key record)) => PersistEntity record where #
Persistent serialized Haskell records to the database.
A Database Entity (A row in SQL, a document in MongoDB, etc)
corresponds to a Key plus a Haskell record.
For every Haskell record type stored in the database there is a
corresponding PersistEntity instance. An instance of PersistEntity
contains meta-data for the record. PersistEntity also helps abstract
over different record types. That way the same query interface can return
a PersistEntity, with each query returning different types of Haskell
records.
Some advanced type system capabilities are used to make this process type-safe. Persistent users usually don't need to understand the class associated data and functions.
Minimal complete definition
keyToValues, keyFromValues, persistIdField, entityDef, persistFieldDef, toPersistFields, fromPersistValues, persistUniqueKeys, persistUniqueToFieldNames, persistUniqueToValues, fieldLens
Associated Types
type PersistEntityBackend record :: * #
Persistent allows multiple different backends (databases).
By default, a backend will automatically generate the key Instead you can specify a Primary key made up of unique values.
data EntityField record a :: * #
An EntityField is parameterised by the Haskell record it belongs to
and the additional type of that field.
Unique keys besides the Key.
Methods
keyToValues :: Key record -> [PersistValue] #
A lower-level key operation.
keyFromValues :: [PersistValue] -> Either Text (Key record) #
A lower-level key operation.
persistIdField :: EntityField record (Key record) #
A meta-operation to retrieve the Key EntityField.
entityDef :: Monad m => m record -> EntityDef #
Retrieve the EntityDef meta-data for the record.
persistFieldDef :: EntityField record typ -> FieldDef #
Return meta-data for a given EntityField.
toPersistFields :: record -> [SomePersistField] #
A meta-operation to get the database fields of a record.
fromPersistValues :: [PersistValue] -> Either Text record #
A lower-level operation to convert from database values to a Haskell record.
persistUniqueKeys :: record -> [Unique record] #
A meta operation to retrieve all the Unique keys.
persistUniqueToFieldNames :: Unique record -> [(HaskellName, DBName)] #
A lower level operation.
persistUniqueToValues :: Unique record -> [PersistValue] #
A lower level operation.
fieldLens :: EntityField record field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity record -> f (Entity record) #
Use a PersistField as a lens.
type family BackendSpecificUpdate backend record :: * #
Updating a database entity.
Persistent users use combinators to create these.
Constructors
| Update :: Update record | |
| BackendUpdate :: Update record |
Query options.
Persistent users use these directly.
type family BackendSpecificFilter backend record :: * #
Filters which are available for select, updateWhere and
deleteWhere. Each filter constructor specifies the field being
filtered on, the type of comparison applied (equals, not equals, etc)
and the argument for the comparison.
Persistent users use combinators to create these.
Datatype that represents an entity, with both its Key and
its Haskell record representation.
When using a SQL-based backend (such as SQLite or
PostgreSQL), an Entity may take any number of columns
depending on how many fields it has. In order to reconstruct
your entity on the Haskell side, persistent needs all of
your entity columns and in the right order. Note that you
don't need to worry about this when using persistent's API
since everything is handled correctly behind the scenes.
However, if you want to issue a raw SQL command that returns
an Entity, then you have to be careful with the column
order. While you could use SELECT Entity.* WHERE ... and
that would work most of the time, there are times when the
order of the columns on your database is different from the
order that persistent expects (for example, if you add a new
field in the middle of you entity definition and then use the
migration code -- persistent will expect the column to be in
the middle, but your DBMS will put it as the last column).
So, instead of using a query like the one above, you may use
rawSql (from the
Database.Persist.GenericSql module) with its /entity
selection placeholder/ (a double question mark ??). Using
rawSql the query above must be written as SELECT ?? WHERE
... Then rawSql will replace ?? with the list of all
columns that we need from your entity in the right order. If
your query returns two entities (i.e. (Entity backend a,
Entity backend b)), then you must you use SELECT ??, ??
WHERE ..., and so on.
Instances
| (Eq (Key record), Eq record) => Eq (Entity record) | |
| (Ord (Key record), Ord record) => Ord (Entity record) | |
Defined in Database.Persist.Class.PersistEntity Methods compare :: Entity record -> Entity record -> Ordering # (<) :: Entity record -> Entity record -> Bool # (<=) :: Entity record -> Entity record -> Bool # (>) :: Entity record -> Entity record -> Bool # (>=) :: Entity record -> Entity record -> Bool # | |
| (Read (Key record), Read record) => Read (Entity record) | |
| (Show (Key record), Show record) => Show (Entity record) | |
| (Generic (Key record), Generic record) => Generic (Entity record) | |
| (PersistEntity record, PersistField record, PersistField (Key record)) => PersistField (Entity record) | |
Defined in Database.Persist.Class.PersistEntity Methods toPersistValue :: Entity record -> PersistValue # fromPersistValue :: PersistValue -> Either Text (Entity record) # | |
| type Rep (Entity record) | |
Defined in Database.Persist.Class.PersistEntity type Rep (Entity record) = D1 (MetaData "Entity" "Database.Persist.Class.PersistEntity" "persistent-2.8.2-5GdCMCJr0Xv9cjqIv6cezE" False) (C1 (MetaCons "Entity" PrefixI True) (S1 (MetaSel (Just "entityKey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Key record)) :*: S1 (MetaSel (Just "entityVal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 record))) | |
getPersistMap :: PersistValue -> Either Text [(Text, PersistValue)] #
FIXME Add documentation to that.
class PersistField a where #
This class teaches Persistent how to take a custom type and marshal it to and from a PersistValue, allowing it to be stored in a database.
Examples
Simple Newtype
You can use newtype to add more type safety/readability to a basis type like ByteString. In these cases, just derive PersistField and PersistFieldSql:
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
newtype HashedPassword = HashedPassword ByteString
deriving (Eq, Show, PersistField, PersistFieldSql)
Smart Constructor Newtype
In this example, we create a PersistField instance for a newtype following the "Smart Constructor" pattern.
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
import qualified Data.Text as T
import qualified Data.Char as C
-- | An American Social Security Number
newtype SSN = SSN Text
deriving (Eq, Show, PersistFieldSql)
mkSSN :: Text -> Either Text SSN
mkSSN t = if (T.length t == 9) && (T.all C.isDigit t)
then Right $ SSN t
else Left $ "Invalid SSN: " <> t
instance PersistField SSN where
toPersistValue (SSN t) = PersistText t
fromPersistValue (PersistText t) = mkSSN t
-- Handle cases where the database does not give us PersistText
fromPersistValue x = Left $ "File.hs: When trying to deserialize an SSN: expected PersistText, received: " <> T.pack (show x)
Tips:
- This file contain dozens of
PersistFieldinstances you can look at for examples. - Typically custom
PersistFieldinstances will only accept a singlePersistValueconstructor infromPersistValue. - Internal
PersistFieldinstances accept a wide variety ofPersistValues to accomodate e.g. storing booleans as integers, booleans or strings. - If you're making a custom instance and using a SQL database, you'll also need
PersistFieldSqlto specify the type of the database column.
Minimal complete definition
Instances
data SomePersistField where #
Constructors
| SomePersistField :: SomePersistField |
Instances
| PersistField SomePersistField | |
Defined in Database.Persist.Class.PersistField Methods toPersistValue :: SomePersistField -> PersistValue # fromPersistValue :: PersistValue -> Either Text SomePersistField # | |
keyAndEntityFields :: EntityDef -> [FieldDef] #
entityKeyFields :: EntityDef -> [FieldDef] #
entityPrimary :: EntityDef -> Maybe CompositeDef #
A Checkmark should be used as a field type whenever a
uniqueness constraint should guarantee that a certain kind of
record may appear at most once, but other kinds of records may
appear any number of times.
NOTE: You need to mark any Checkmark fields as nullable
(see the following example).
For example, suppose there's a Location entity that
represents where a user has lived:
Location
user UserId
name Text
current Checkmark nullable
UniqueLocation user current
The UniqueLocation constraint allows any number of
Inactive Locations to be current. However, there may be
at most one current Location per user (i.e., either zero
or one per user).
This data type works because of the way that SQL treats
NULLable fields within uniqueness constraints. The SQL
standard says that NULL values should be considered
different, so we represent Inactive as SQL NULL, thus
allowing any number of Inactive records. On the other hand,
we represent Active as TRUE, so the uniqueness constraint
will disallow more than one Active record.
Note: There may be DBMSs that do not respect the SQL
standard's treatment of NULL values on uniqueness
constraints, please check if this data type works before
relying on it.
The SQL BOOLEAN type is used because it's the smallest data
type available. Note that we never use FALSE, just TRUE
and NULL. Provides the same behavior Maybe () would if
() was a valid PersistField.
Constructors
| Active | When used on a uniqueness constraint, there
may be at most one |
| Inactive | When used on a uniqueness constraint, there
may be any number of |
Instances
data IsNullable #
Constructors
| Nullable !WhyNullable | |
| NotNullable |
Instances
| Eq IsNullable | |
Defined in Database.Persist.Types.Base | |
| Show IsNullable | |
Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> IsNullable -> ShowS # show :: IsNullable -> String # showList :: [IsNullable] -> ShowS # | |
data WhyNullable #
The reason why a field is nullable is very important. A
field that is nullable because of a Maybe tag will have its
type changed from A to Maybe A. OTOH, a field that is
nullable because of a nullable tag will remain with the same
type.
Constructors
| ByMaybeAttr | |
| ByNullableAttr |
Instances
| Eq WhyNullable | |
Defined in Database.Persist.Types.Base | |
| Show WhyNullable | |
Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> WhyNullable -> ShowS # show :: WhyNullable -> String # showList :: [WhyNullable] -> ShowS # | |
Constructors
| EntityDef | |
Fields
| |
Instances
| Eq EntityDef | |
| Ord EntityDef | |
| Read EntityDef | |
| Show EntityDef | |
newtype HaskellName #
Constructors
| HaskellName | |
Fields | |
Instances
| Eq HaskellName | |
Defined in Database.Persist.Types.Base | |
| Ord HaskellName | |
Defined in Database.Persist.Types.Base Methods compare :: HaskellName -> HaskellName -> Ordering # (<) :: HaskellName -> HaskellName -> Bool # (<=) :: HaskellName -> HaskellName -> Bool # (>) :: HaskellName -> HaskellName -> Bool # (>=) :: HaskellName -> HaskellName -> Bool # max :: HaskellName -> HaskellName -> HaskellName # min :: HaskellName -> HaskellName -> HaskellName # | |
| Read HaskellName | |
Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS HaskellName # readList :: ReadS [HaskellName] # readPrec :: ReadPrec HaskellName # readListPrec :: ReadPrec [HaskellName] # | |
| Show HaskellName | |
Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> HaskellName -> ShowS # show :: HaskellName -> String # showList :: [HaskellName] -> ShowS # | |
Constructors
| FTTypeCon (Maybe Text) Text | Optional module and name. |
| FTApp FieldType FieldType | |
| FTList FieldType |
Instances
| Eq FieldType | |
| Ord FieldType | |
| Read FieldType | |
| Show FieldType | |
Constructors
| FieldDef | |
Fields
| |
data ReferenceDef #
There are 3 kinds of references 1) composite (to fields that exist in the record) 2) single field 3) embedded
Constructors
| NoReference | |
| ForeignRef !HaskellName !FieldType | A ForeignRef has a late binding to the EntityDef it references via HaskellName and has the Haskell type of the foreign key in the form of FieldType |
| EmbedRef EmbedEntityDef | |
| CompositeRef CompositeDef | |
| SelfReference | A SelfReference stops an immediate cycle which causes non-termination at compile-time (issue #311). |
Instances
| Eq ReferenceDef | |
Defined in Database.Persist.Types.Base | |
| Ord ReferenceDef | |
Defined in Database.Persist.Types.Base Methods compare :: ReferenceDef -> ReferenceDef -> Ordering # (<) :: ReferenceDef -> ReferenceDef -> Bool # (<=) :: ReferenceDef -> ReferenceDef -> Bool # (>) :: ReferenceDef -> ReferenceDef -> Bool # (>=) :: ReferenceDef -> ReferenceDef -> Bool # max :: ReferenceDef -> ReferenceDef -> ReferenceDef # min :: ReferenceDef -> ReferenceDef -> ReferenceDef # | |
| Read ReferenceDef | |
Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS ReferenceDef # readList :: ReadS [ReferenceDef] # | |
| Show ReferenceDef | |
Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> ReferenceDef -> ShowS # show :: ReferenceDef -> String # showList :: [ReferenceDef] -> ShowS # | |
data EmbedEntityDef #
An EmbedEntityDef is the same as an EntityDef But it is only used for fieldReference so it only has data needed for embedding
Constructors
| EmbedEntityDef | |
Fields | |
Instances
| Eq EmbedEntityDef | |
Defined in Database.Persist.Types.Base Methods (==) :: EmbedEntityDef -> EmbedEntityDef -> Bool # (/=) :: EmbedEntityDef -> EmbedEntityDef -> Bool # | |
| Ord EmbedEntityDef | |
Defined in Database.Persist.Types.Base Methods compare :: EmbedEntityDef -> EmbedEntityDef -> Ordering # (<) :: EmbedEntityDef -> EmbedEntityDef -> Bool # (<=) :: EmbedEntityDef -> EmbedEntityDef -> Bool # (>) :: EmbedEntityDef -> EmbedEntityDef -> Bool # (>=) :: EmbedEntityDef -> EmbedEntityDef -> Bool # max :: EmbedEntityDef -> EmbedEntityDef -> EmbedEntityDef # min :: EmbedEntityDef -> EmbedEntityDef -> EmbedEntityDef # | |
| Read EmbedEntityDef | |
Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS EmbedEntityDef # readList :: ReadS [EmbedEntityDef] # | |
| Show EmbedEntityDef | |
Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> EmbedEntityDef -> ShowS # show :: EmbedEntityDef -> String # showList :: [EmbedEntityDef] -> ShowS # | |
data EmbedFieldDef #
An EmbedFieldDef is the same as a FieldDef But it is only used for embeddedFields so it only has data needed for embedding
Constructors
| EmbedFieldDef | |
Fields
| |
Instances
| Eq EmbedFieldDef | |
Defined in Database.Persist.Types.Base Methods (==) :: EmbedFieldDef -> EmbedFieldDef -> Bool # (/=) :: EmbedFieldDef -> EmbedFieldDef -> Bool # | |
| Ord EmbedFieldDef | |
Defined in Database.Persist.Types.Base Methods compare :: EmbedFieldDef -> EmbedFieldDef -> Ordering # (<) :: EmbedFieldDef -> EmbedFieldDef -> Bool # (<=) :: EmbedFieldDef -> EmbedFieldDef -> Bool # (>) :: EmbedFieldDef -> EmbedFieldDef -> Bool # (>=) :: EmbedFieldDef -> EmbedFieldDef -> Bool # max :: EmbedFieldDef -> EmbedFieldDef -> EmbedFieldDef # min :: EmbedFieldDef -> EmbedFieldDef -> EmbedFieldDef # | |
| Read EmbedFieldDef | |
Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS EmbedFieldDef # readList :: ReadS [EmbedFieldDef] # | |
| Show EmbedFieldDef | |
Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> EmbedFieldDef -> ShowS # show :: EmbedFieldDef -> String # showList :: [EmbedFieldDef] -> ShowS # | |
Constructors
| UniqueDef | |
Fields
| |
Instances
| Eq UniqueDef | |
| Ord UniqueDef | |
| Read UniqueDef | |
| Show UniqueDef | |
data CompositeDef #
Constructors
| CompositeDef | |
Fields
| |
Instances
| Eq CompositeDef | |
Defined in Database.Persist.Types.Base | |
| Ord CompositeDef | |
Defined in Database.Persist.Types.Base Methods compare :: CompositeDef -> CompositeDef -> Ordering # (<) :: CompositeDef -> CompositeDef -> Bool # (<=) :: CompositeDef -> CompositeDef -> Bool # (>) :: CompositeDef -> CompositeDef -> Bool # (>=) :: CompositeDef -> CompositeDef -> Bool # max :: CompositeDef -> CompositeDef -> CompositeDef # min :: CompositeDef -> CompositeDef -> CompositeDef # | |
| Read CompositeDef | |
Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS CompositeDef # readList :: ReadS [CompositeDef] # | |
| Show CompositeDef | |
Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> CompositeDef -> ShowS # show :: CompositeDef -> String # showList :: [CompositeDef] -> ShowS # | |
type ForeignFieldDef = (HaskellName, DBName) #
Used instead of FieldDef to generate a smaller amount of code
data ForeignDef #
Constructors
| ForeignDef | |
Fields | |
Instances
| Eq ForeignDef | |
Defined in Database.Persist.Types.Base | |
| Ord ForeignDef | |
Defined in Database.Persist.Types.Base Methods compare :: ForeignDef -> ForeignDef -> Ordering # (<) :: ForeignDef -> ForeignDef -> Bool # (<=) :: ForeignDef -> ForeignDef -> Bool # (>) :: ForeignDef -> ForeignDef -> Bool # (>=) :: ForeignDef -> ForeignDef -> Bool # max :: ForeignDef -> ForeignDef -> ForeignDef # min :: ForeignDef -> ForeignDef -> ForeignDef # | |
| Read ForeignDef | |
Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS ForeignDef # readList :: ReadS [ForeignDef] # readPrec :: ReadPrec ForeignDef # readListPrec :: ReadPrec [ForeignDef] # | |
| Show ForeignDef | |
Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> ForeignDef -> ShowS # show :: ForeignDef -> String # showList :: [ForeignDef] -> ShowS # | |
data PersistException #
Constructors
| PersistError Text | Generic Exception |
| PersistMarshalError Text | |
| PersistInvalidField Text | |
| PersistForeignConstraintUnmet Text | |
| PersistMongoDBError Text | |
| PersistMongoDBUnsupported Text |
Instances
| Show PersistException | |
Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> PersistException -> ShowS # show :: PersistException -> String # showList :: [PersistException] -> ShowS # | |
| Exception PersistException | |
Defined in Database.Persist.Types.Base Methods toException :: PersistException -> SomeException # | |
| Error PersistException | |
Defined in Database.Persist.Types.Base | |
data PersistValue #
A raw value which can be stored in any backend and can be marshalled to
and from a PersistField.
Constructors
| PersistText Text | |
| PersistByteString ByteString | |
| PersistInt64 Int64 | |
| PersistDouble Double | |
| PersistRational Rational | |
| PersistBool Bool | |
| PersistDay Day | |
| PersistTimeOfDay TimeOfDay | |
| PersistUTCTime UTCTime | |
| PersistNull | |
| PersistList [PersistValue] | |
| PersistMap [(Text, PersistValue)] | |
| PersistObjectId ByteString | Intended especially for MongoDB backend |
| PersistDbSpecific ByteString | Using data Geo = Geo ByteString
instance PersistField Geo where
toPersistValue (Geo t) = PersistDbSpecific t
fromPersistValue (PersistDbSpecific t) = Right $ Geo $ Data.ByteString.concat ["'", t, "'"]
fromPersistValue _ = Left "Geo values must be converted from PersistDbSpecific"
instance PersistFieldSql Geo where
sqlType _ = SqlOther "GEOGRAPHY(POINT,4326)"
toPoint :: Double -> Double -> Geo
toPoint lat lon = Geo $ Data.ByteString.concat ["'POINT(", ps $ lon, " ", ps $ lat, ")'"]
where ps = Data.Text.pack . show
If Foo has a geography field, we can then perform insertions like the following: insert $ Foo (toPoint 44 44) |
Instances
A SQL data type. Naming attempts to reflect the underlying Haskell datatypes, eg SqlString instead of SqlVarchar. Different SQL databases may have different translations for these types.
Constructors
| SqlString | |
| SqlInt32 | |
| SqlInt64 | |
| SqlReal | |
| SqlNumeric Word32 Word32 | |
| SqlBool | |
| SqlDay | |
| SqlTime | |
| SqlDayTime | Always uses UTC timezone |
| SqlBlob | |
| SqlOther Text | a backend-specific name |
data PersistFilter #
Instances
| Read PersistFilter | |
Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS PersistFilter # readList :: ReadS [PersistFilter] # | |
| Show PersistFilter | |
Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> PersistFilter -> ShowS # show :: PersistFilter -> String # showList :: [PersistFilter] -> ShowS # | |
data UpdateException #
Constructors
| KeyNotFound String | |
| UpsertError String |
Instances
| Show UpdateException | |
Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> UpdateException -> ShowS # show :: UpdateException -> String # showList :: [UpdateException] -> ShowS # | |
| Exception UpdateException | |
Defined in Database.Persist.Types.Base Methods toException :: UpdateException -> SomeException # | |
data OnlyUniqueException #
Constructors
| OnlyUniqueException String |
Instances
| Show OnlyUniqueException | |
Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> OnlyUniqueException -> ShowS # show :: OnlyUniqueException -> String # showList :: [OnlyUniqueException] -> ShowS # | |
| Exception OnlyUniqueException | |
Defined in Database.Persist.Types.Base Methods toException :: OnlyUniqueException -> SomeException # fromException :: SomeException -> Maybe OnlyUniqueException # | |
data PersistUpdate #
Instances
| Read PersistUpdate | |
Defined in Database.Persist.Types.Base Methods readsPrec :: Int -> ReadS PersistUpdate # readList :: ReadS [PersistUpdate] # | |
| Show PersistUpdate | |
Defined in Database.Persist.Types.Base Methods showsPrec :: Int -> PersistUpdate -> ShowS # show :: PersistUpdate -> String # showList :: [PersistUpdate] -> ShowS # | |
class PersistConfig c where #
Represents a value containing all the configuration options for a specific backend. This abstraction makes it easier to write code that can easily swap backends.
Minimal complete definition
Methods
loadConfig :: Value -> Parser c #
Load the config settings from a Value, most likely taken from a YAML
config file.
Modify the config settings based on environment variables.
createPoolConfig :: c -> IO (PersistConfigPool c) #
Create a new connection pool based on the given config settings.
runPool :: MonadUnliftIO m => c -> PersistConfigBackend c m a -> PersistConfigPool c -> m a #
Run a database action by taking a connection from the pool.
Instances
| (PersistConfig c1, PersistConfig c2, PersistConfigPool c1 ~ PersistConfigPool c2, PersistConfigBackend c1 ~ PersistConfigBackend c2) => PersistConfig (Either c1 c2) | |
Defined in Database.Persist.Class.PersistConfig Associated Types type PersistConfigBackend (Either c1 c2) :: (* -> *) -> * -> * # type PersistConfigPool (Either c1 c2) :: * # Methods loadConfig :: Value -> Parser (Either c1 c2) # applyEnv :: Either c1 c2 -> IO (Either c1 c2) # createPoolConfig :: Either c1 c2 -> IO (PersistConfigPool (Either c1 c2)) # runPool :: MonadUnliftIO m => Either c1 c2 -> PersistConfigBackend (Either c1 c2) m a -> PersistConfigPool (Either c1 c2) -> m a # | |
mkMigrate :: String -> [EntityDef] -> Q [Dec] #
Creates a single function to perform all migrations for the entities defined here. One thing to be aware of is dependencies: if you have entities with foreign references, make sure to place those definitions after the entities they reference.
derivePersistFieldJSON :: String -> Q [Dec] #
Automatically creates a valid PersistField instance for any datatype
that has valid ToJSON and FromJSON instances. For a datatype T it
generates instances similar to these:
instance PersistField T where
toPersistValue = PersistByteString . L.toStrict . encode
fromPersistValue = (left T.pack) . eitherDecodeStrict' <=< fromPersistValue
instance PersistFieldSql T where
sqlType _ = SqlString
derivePersistField :: String -> Q [Dec] #
Automatically creates a valid PersistField instance for any datatype
that has valid Show and Read instances. Can be very convenient for
Enum types.
mkDeleteCascade :: MkPersistSettings -> [EntityDef] -> Q [Dec] #
Generate a DeleteCascade instance for the given EntityDefs.
share :: [[EntityDef] -> Q [Dec]] -> [EntityDef] -> Q [Dec] #
Apply the given list of functions to the same EntityDefs.
This function is useful for cases such as:
>>>share [mkSave "myDefs", mkPersist sqlSettings] [persistLowerCase|...|]
persistFieldFromEntity :: MkPersistSettings -> EntityDef -> Q [Dec] #
produce code similar to the following:
instance PersistEntity e => PersistField e where
toPersistValue = PersistMap $ zip columNames (map toPersistValue . toPersistFields)
fromPersistValue (PersistMap o) =
let columns = HM.fromList o
in fromPersistValues $ map (name ->
case HM.lookup name columns of
Just v -> v
Nothing -> PersistNull
fromPersistValue x = Left $ "Expected PersistMap, received: " ++ show x
sqlType _ = SqlString
sqlOnlySettings :: MkPersistSettings #
Same as sqlSettings.
Since: persistent-template-1.1.1
sqlSettings :: MkPersistSettings #
Use the SqlPersist backend.
Arguments
| :: Type | Value for |
| -> MkPersistSettings |
Create an MkPersistSettings with default values.
mkPersist :: MkPersistSettings -> [EntityDef] -> Q [Dec] #
Create data types and appropriate PersistEntity instances for the given
EntityDefs. Works well with the persist quasi-quoter.
parseReferences :: PersistSettings -> Text -> Q Exp #
Since: persistent-template-2.5.3
persistManyFileWith :: PersistSettings -> [FilePath] -> Q Exp #
Same as persistFileWith, but uses several external files instead of
one. Splitting your Persistent definitions into multiple modules can
potentially dramatically speed up compile times.
Examples
Split your Persistent definitions into multiple files (models1, models2),
then create a new module for each new file and run mkPersist there:
-- Model1.hsshare[mkPersistsqlSettings] $(persistFileWithlowerCaseSettings"models1")
-- Model2.hsshare[mkPersistsqlSettings] $(persistFileWithlowerCaseSettings"models2")
Use persistManyFileWith to create your migrations:
-- Migrate.hsshare[mkMigrate"migrateAll"] $(persistManyFileWithlowerCaseSettings["models1","models2"])
Tip: To get the same import behavior as if you were declaring all your models in
one file, import your new files as Name into another file, then export module Name.
This approach may be used in the future to reduce memory usage during compilation, but so far we've only seen mild reductions.
See persistent#778 and persistent#791 for more details.
Since: persistent-template-2.5.4
persistFileWith :: PersistSettings -> FilePath -> Q Exp #
Same as persistWith, but uses an external file instead of a
quasiquotation.
persistLowerCase :: QuasiQuoter #
Apply persistWith to lowerCaseSettings.
persistUpperCase :: QuasiQuoter #
Apply persistWith to upperCaseSettings.
persistWith :: PersistSettings -> QuasiQuoter #
Converts a quasi-quoted syntax into a list of entity definitions, to be used as input to the template haskell generation code (mkPersist).
data MkPersistSettings #
Settings to be passed to the mkPersist function.
data EntityJSON #
Constructors
| EntityJSON | |
Fields
| |
Arguments
| :: String | master translation data type |
| -> String | existing type to add translations for |
| -> FilePath | path to translation folder |
| -> Lang | default language |
| -> Q [Dec] |
create an additional set of translations for a type created by mkMessage
Arguments
| :: String | master translation data type |
| -> String | existing type to add translations for |
| -> FilePath | path to translation folder |
| -> Lang | default language |
| -> Q [Dec] |
create RenderMessage instance for an existing data-type
Arguments
| :: String | base name to use for translation type |
| -> FilePath | subdirectory which contains the translation files |
| -> Lang | default translation language |
| -> Q [Dec] |
generate translations from translation files
This function will:
- look in the supplied subdirectory for files ending in
.msg - generate a type based on the constructors found
- create a
RenderMessageinstance
ToMessage is used to convert the value inside #{ } to Text
The primary purpose of this class is to allow the value in #{ } to
be a String or Text rather than forcing it to always be Text.
Minimal complete definition
class RenderMessage master message where #
the RenderMessage is used to provide translations for a message types
The master argument exists so that it is possible to provide more
than one set of translations for a message type. This is useful
if a library provides a default set of translations, but the user
of the library wants to provide a different set of translations.
Minimal complete definition
Methods
Instances
| RenderMessage master Text | |
Defined in Text.Shakespeare.I18N Methods renderMessage :: master -> [Lang] -> Text -> Text # | |
| RenderMessage App FormMessage # | |
Defined in Hledger.Web.Foundation Methods renderMessage :: App -> [Lang] -> FormMessage -> Text # | |
| master ~ master' => RenderMessage master (SomeMessage master') | |
Defined in Text.Shakespeare.I18N Methods renderMessage :: master -> [Lang] -> SomeMessage master' -> Text # | |
data SomeMessage master where #
Constructors
| SomeMessage :: SomeMessage master |
Instances
| master ~ master' => RenderMessage master (SomeMessage master') | |
Defined in Text.Shakespeare.I18N Methods renderMessage :: master -> [Lang] -> SomeMessage master' -> Text # | |
| IsString (SomeMessage master) | |
Defined in Text.Shakespeare.I18N Methods fromString :: String -> SomeMessage master # | |
cassius :: QuasiQuoter #
xhamlet :: QuasiQuoter #
Like hamlet, but produces XHTML.
hamlet :: QuasiQuoter #
Hamlet quasi-quoter. May only be used to generate expressions.
Generated expression have type HtmlUrl urlurl.
data MyRoute = Home render ::RenderMyRoute render Home _ = "/home" >>>putStrLn(renderHtml([hamlet|<a href=@{Home}>Home|] render)) <a href="/home">Home</a>
shamlet :: QuasiQuoter #
"Simple Hamlet" quasi-quoter. May only be used to generate expressions.
Generated expressions have type Html.
>>>putStrLn(renderHtml[shamlet|<div>Hello, world!|]) <div>Hello, world!</div>
type HtmlUrl url = Render url -> Html #
A function generating an Html given a URL-rendering function.
lucius :: QuasiQuoter #
>>>renderCss ([lucius|foo{bar:baz}|] undefined)"foo{bar:baz}"
julius :: QuasiQuoter #
renderJavascriptUrl :: (url -> [(Text, Text)] -> Text) -> JavascriptUrl url -> Text #
render with route interpolation. If using this module standalone, apart from type-safe routes, a dummy renderer can be used:
renderJavascriptUrl (\_ _ -> undefined) javascriptUrl
When using Yesod, a renderer is generated for you, which can be accessed
within the GHandler monad: getUrlRenderParams.
type JavascriptUrl url = (url -> [(Text, Text)] -> Text) -> Javascript #
Return type of template-reading functions.
formatTime :: FormatTime t => TimeLocale -> String -> t -> String #
Substitute various time-related information for each %-code in the string, as per formatCharacter.
The general form is %<modifier><width><specifier>, where <modifier> and <width> are optional.
<modifier>
glibc-style modifiers can be used before the specifier (here marked as z):
%-z- no padding
%_z- pad with spaces
%0z- pad with zeros
%^z- convert to upper case
%#z- convert to lower case (consistently, unlike glibc)
<width>
Width digits can also be used after any modifiers and before the specifier (here marked as z), for example:
%4z- pad to 4 characters (with default padding character)
%_12z- pad with spaces to 12 characters
<specifier>
For all types (note these three are done by formatTime, not by formatCharacter):
%%%%t- tab
%n- newline
TimeZone
For TimeZone (and ZonedTime and UTCTime):
%z- timezone offset in the format
-HHMM. %Z- timezone name
LocalTime
For LocalTime (and ZonedTime and UTCTime and UniversalTime):
%c- as
dateTimeFmtlocale(e.g.%a %b %e %H:%M:%S %Z %Y)
TimeOfDay
For TimeOfDay (and LocalTime and ZonedTime and UTCTime and UniversalTime):
%R- same as
%H:%M %T- same as
%H:%M:%S %X- as
timeFmtlocale(e.g.%H:%M:%S) %r- as
time12Fmtlocale(e.g.%I:%M:%S %p) %P- day-half of day from (
amPmlocale), converted to lowercase,am,pm %p- day-half of day from (
amPmlocale),AM,PM %H- hour of day (24-hour), 0-padded to two chars,
00-23 %k- hour of day (24-hour), space-padded to two chars,
0-23 %I- hour of day-half (12-hour), 0-padded to two chars,
01-12 %l- hour of day-half (12-hour), space-padded to two chars,
1-12 %M- minute of hour, 0-padded to two chars,
00-59 %S- second of minute (without decimal part), 0-padded to two chars,
00-60 %q- picosecond of second, 0-padded to twelve chars,
000000000000-999999999999. %Q- decimal point and fraction of second, up to 12 second decimals, without trailing zeros.
For a whole number of seconds,
%Qomits the decimal point unless padding is specified.
UTCTime and ZonedTime
%s- number of whole seconds since the Unix epoch. For times before
the Unix epoch, this is a negative number. Note that in
%s.%qand%s%Qthe decimals are positive, not negative. For example, 0.9 seconds before the Unix epoch is formatted as-1.1with%s%Q.
Day
For Day (and LocalTime and ZonedTime and UTCTime and UniversalTime):
%D- same as
%m/%d/%y %F- same as
%Y-%m-%d %x- as
dateFmtlocale(e.g.%m/%d/%y) %Y- year, no padding. Note
%0Yand%_Ypad to four chars %y- year of century, 0-padded to two chars,
00-99 %C- century, no padding. Note
%0Cand%_Cpad to two chars %B- month name, long form (
fstfrommonthslocale),January-December %b,%h- month name, short form (
sndfrommonthslocale),Jan-Dec %m- month of year, 0-padded to two chars,
01-12 %d- day of month, 0-padded to two chars,
01-31 %e- day of month, space-padded to two chars,
1-31 %j- day of year, 0-padded to three chars,
001-366 %f- century for Week Date format, no padding. Note
%0fand%_fpad to two chars %V- week of year for Week Date format, 0-padded to two chars,
01-53 %u- day of week for Week Date format,
1-7 %a- day of week, short form (
sndfromwDayslocale),Sun-Sat %A- day of week, long form (
fstfromwDayslocale),Sunday-Saturday %U- week of year where weeks start on Sunday (as
sundayStartWeek), 0-padded to two chars,00-53 %w- day of week number,
0(= Sunday) -6(= Saturday) %W- week of year where weeks start on Monday (as
mondayStartWeek), 0-padded to two chars,00-53
type NumericPadOption = Maybe Char #
class FormatTime t where #
Minimal complete definition
Methods
formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> t -> String) #
Instances
Arguments
| :: ParseTime t | |
| => TimeLocale | Time locale. |
| -> String | Format string. |
| -> String | Input string. |
| -> t | The time value. |
Arguments
| :: ParseTime t | |
| => Bool | Accept leading whitespace? |
| -> TimeLocale | Time locale. |
| -> String | Format string |
| -> ReadP t |
Parse a time value given a format string. See parseTimeM for details.
Arguments
| :: ParseTime t | |
| => Bool | Accept leading whitespace? |
| -> TimeLocale | Time locale. |
| -> String | Format string |
| -> ReadS t |
Parse a time value given a format string. See parseTimeM for details.
Arguments
| :: ParseTime t | |
| => Bool | Accept leading and trailing whitespace? |
| -> TimeLocale | Time locale. |
| -> String | Format string. |
| -> String | Input string. |
| -> t | The time value. |
Parse a time value given a format string. Fails if the input could
not be parsed using the given format. See parseTimeM for details.
Arguments
| :: (Monad m, ParseTime t) | |
| => Bool | Accept leading and trailing whitespace? |
| -> TimeLocale | Time locale. |
| -> String | Format string. |
| -> String | Input string. |
| -> m t | Return the time value, or fail if the input could not be parsed using the given format. |
Parses a time value given a format string.
Supports the same %-codes as formatTime, including %-, %_ and %0 modifiers, however padding widths are not supported.
Case is not significant in the input string.
Some variations in the input are accepted:
%z- accepts any of
-HHMMor-HH:MM. %Z- accepts any string of letters, or any of the formats accepted by
%z. %0Y- accepts exactly four digits.
%0G- accepts exactly four digits.
%0C- accepts exactly two digits.
%0f- accepts exactly two digits.
The class of types which can be parsed given a UNIX-style time format string.
Minimal complete definition
Methods
Arguments
| :: TimeLocale | The time locale. |
| -> [(Char, String)] | Pairs of format characters and the corresponding part of the input. |
| -> Maybe 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 %C or %Y, century is 1969 - 2068.
Instances
| ParseTime UTCTime | |
Defined in Data.Time.Format.Parse | |
| ParseTime ZonedTime | |
Defined in Data.Time.Format.Parse | |
| ParseTime LocalTime | |
Defined in Data.Time.Format.Parse | |
| ParseTime TimeOfDay | |
Defined in Data.Time.Format.Parse | |
| ParseTime TimeZone | |
Defined in Data.Time.Format.Parse | |
| ParseTime UniversalTime | |
Defined in Data.Time.Format.Parse Methods buildTime :: TimeLocale -> [(Char, String)] -> Maybe UniversalTime # | |
| ParseTime Day | |
Defined in Data.Time.Format.Parse | |
utcToLocalZonedTime :: UTCTime -> IO ZonedTime #
getZonedTime :: IO ZonedTime #
zonedTimeToUTC :: ZonedTime -> UTCTime #
utcToZonedTime :: TimeZone -> UTCTime -> ZonedTime #
A local time together with a time zone.
Constructors
| ZonedTime | |
Fields | |
Instances
| Data ZonedTime | |
Defined in Data.Time.LocalTime.Internal.ZonedTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ZonedTime -> c ZonedTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ZonedTime # toConstr :: ZonedTime -> Constr # dataTypeOf :: ZonedTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ZonedTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ZonedTime) # gmapT :: (forall b. Data b => b -> b) -> ZonedTime -> ZonedTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZonedTime -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZonedTime -> r # gmapQ :: (forall d. Data d => d -> u) -> ZonedTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ZonedTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ZonedTime -> m ZonedTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ZonedTime -> m ZonedTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ZonedTime -> m ZonedTime # | |
| Show ZonedTime | |
| ToJSON ZonedTime | |
Defined in Data.Aeson.Types.ToJSON | |
| ToJSONKey ZonedTime | |
Defined in Data.Aeson.Types.ToJSON | |
| FromJSON ZonedTime | Supported string formats:
The first space may instead be a |
| FromJSONKey ZonedTime | |
Defined in Data.Aeson.Types.FromJSON Methods | |
| NFData ZonedTime | |
Defined in Data.Time.LocalTime.Internal.ZonedTime | |
| FormatTime ZonedTime | |
Defined in Data.Time.Format Methods formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> ZonedTime -> String) # | |
| ParseTime ZonedTime | |
Defined in Data.Time.Format.Parse | |
Format string according to RFC822.
iso8601DateFormat :: Maybe String -> String #
Construct format string according to ISO-8601.
The Maybe String argument allows to supply an optional time specification. E.g.:
iso8601DateFormatNothing == "%Y-%m-%d" -- i.e.YYYY-MM-DDiso8601DateFormat(Just "%H:%M:%S") == "%Y-%m-%dT%H:%M:%S" -- i.e.YYYY-MM-DDTHH:MM:SS
defaultTimeLocale :: TimeLocale #
Locale representing American usage.
knownTimeZones contains only the ten time-zones mentioned in RFC 822 sec. 5:
"UT", "GMT", "EST", "EDT", "CST", "CDT", "MST", "MDT", "PST", "PDT".
Note that the parsing functions will regardless parse single-letter military time-zones and +HHMM format.
data TimeLocale #
Constructors
| TimeLocale | |
Fields
| |
Instances
| Eq TimeLocale | |
Defined in Data.Time.Format.Locale | |
| Ord TimeLocale | |
Defined in Data.Time.Format.Locale Methods compare :: TimeLocale -> TimeLocale -> Ordering # (<) :: TimeLocale -> TimeLocale -> Bool # (<=) :: TimeLocale -> TimeLocale -> Bool # (>) :: TimeLocale -> TimeLocale -> Bool # (>=) :: TimeLocale -> TimeLocale -> Bool # max :: TimeLocale -> TimeLocale -> TimeLocale # min :: TimeLocale -> TimeLocale -> TimeLocale # | |
| Show TimeLocale | |
Defined in Data.Time.Format.Locale Methods showsPrec :: Int -> TimeLocale -> ShowS # show :: TimeLocale -> String # showList :: [TimeLocale] -> ShowS # | |
localTimeToUT1 :: Rational -> LocalTime -> UniversalTime #
Get the UT1 time of a local time on a particular meridian (in degrees, positive is East).
ut1ToLocalTime :: Rational -> UniversalTime -> LocalTime #
Get the local time of a UT1 time on a particular meridian (in degrees, positive is East).
localTimeToUTC :: TimeZone -> LocalTime -> UTCTime #
Get the UTC time of a local time in a time zone.
utcToLocalTime :: TimeZone -> UTCTime -> LocalTime #
Get the local time of a UTC time in a time zone.
A simple day and time aggregate, where the day is of the specified parameter, and the time is a TimeOfDay. Conversion of this (as local civil time) to UTC depends on the time zone. Conversion of this (as local mean time) to UT1 depends on the longitude.
Constructors
| LocalTime | |
Fields
| |
Instances
timeOfDayToDayFraction :: TimeOfDay -> Rational #
Get the fraction of a day since midnight given a time of day.
dayFractionToTimeOfDay :: Rational -> TimeOfDay #
Get the time of day given the fraction of a day since midnight.
timeOfDayToTime :: TimeOfDay -> DiffTime #
Get the time since midnight for a given time of day.
timeToTimeOfDay :: DiffTime -> TimeOfDay #
Get the time of day given a time since midnight. Time more than 24h will be converted to leap-seconds.
localToUTCTimeOfDay :: TimeZone -> TimeOfDay -> (Integer, TimeOfDay) #
Convert a time of day in some timezone to a time of day in UTC, together with a day adjustment.
utcToLocalTimeOfDay :: TimeZone -> TimeOfDay -> (Integer, TimeOfDay) #
Convert a time of day in UTC to a time of day in some timezone, together with a day adjustment.
Time of day as represented in hour, minute and second (with picoseconds), typically used to express local time of day.
Constructors
| TimeOfDay | |
Instances
getCurrentTimeZone :: IO TimeZone #
Get the current time-zone.
getTimeZone :: UTCTime -> IO TimeZone #
Get the local time-zone for a given time (varying as per summertime adjustments).
timeZoneOffsetString :: TimeZone -> String #
Text representing the offset of this timezone, such as "-0800" or "+0400" (like %z in formatTime).
timeZoneOffsetString' :: Maybe Char -> TimeZone -> String #
Text representing the offset of this timezone, such as "-0800" or "+0400" (like %z in formatTime), with arbitrary padding.
hoursToTimeZone :: Int -> TimeZone #
Create a nameless non-summer timezone for this number of hours.
minutesToTimeZone :: Int -> TimeZone #
Create a nameless non-summer timezone for this number of minutes.
A TimeZone is a whole number of minutes offset from UTC, together with a name and a "just for summer" flag.
Constructors
| TimeZone | |
Fields
| |
Instances
| Eq TimeZone | |
| Data TimeZone | |
Defined in Data.Time.LocalTime.Internal.TimeZone Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TimeZone -> c TimeZone # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TimeZone # toConstr :: TimeZone -> Constr # dataTypeOf :: TimeZone -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TimeZone) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TimeZone) # gmapT :: (forall b. Data b => b -> b) -> TimeZone -> TimeZone # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TimeZone -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TimeZone -> r # gmapQ :: (forall d. Data d => d -> u) -> TimeZone -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TimeZone -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TimeZone -> m TimeZone # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TimeZone -> m TimeZone # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TimeZone -> m TimeZone # | |
| Ord TimeZone | |
Defined in Data.Time.LocalTime.Internal.TimeZone | |
| Show TimeZone | |
| NFData TimeZone | |
Defined in Data.Time.LocalTime.Internal.TimeZone | |
| FormatTime TimeZone | |
Defined in Data.Time.Format Methods formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> TimeZone -> String) # | |
| ParseTime TimeZone | |
Defined in Data.Time.Format.Parse | |
diffUTCTime :: UTCTime -> UTCTime -> NominalDiffTime #
diffUTCTime a b = a - b
addUTCTime :: NominalDiffTime -> UTCTime -> UTCTime #
addUTCTime a b = a + b
getCurrentTime :: IO UTCTime #
Get the current UTCTime from the system clock.
newtype UniversalTime #
The Modified Julian Date is the day with the fraction of the day, measured from UT midnight. It's used to represent UT1, which is time as measured by the earth's rotation, adjusted for various wobbles.
Constructors
| ModJulianDate | |
Fields | |
Instances
getTime_resolution :: DiffTime #
The resolution of getSystemTime, getCurrentTime, getPOSIXTime
nominalDay :: NominalDiffTime #
One day in NominalDiffTime.
data NominalDiffTime #
This is a length of time, as measured by UTC. Conversion functions will treat it as seconds. It has a precision of 10^-12 s. It ignores leap-seconds, so it's not necessarily a fixed amount of clock time. For instance, 23:00 UTC + 2 hours of NominalDiffTime = 01:00 UTC (+ 1 day), regardless of whether a leap-second intervened.
Instances
diffTimeToPicoseconds :: DiffTime -> Integer #
Get the number of picoseconds in a DiffTime.
picosecondsToDiffTime :: Integer -> DiffTime #
Create a DiffTime from a number of picoseconds.
secondsToDiffTime :: Integer -> DiffTime #
Create a DiffTime which represents an integral number of seconds.
addGregorianYearsRollOver :: Integer -> Day -> Day #
Add years, matching month and day, with Feb 29th rolled over to Mar 1st if necessary. For instance, 2004-02-29 + 2 years = 2006-03-01.
addGregorianYearsClip :: Integer -> Day -> Day #
Add years, matching month and day, with Feb 29th clipped to Feb 28th if necessary. For instance, 2004-02-29 + 2 years = 2006-02-28.
addGregorianMonthsRollOver :: Integer -> Day -> Day #
Add months, with days past the last day of the month rolling over to the next month. For instance, 2005-01-30 + 1 month = 2005-03-02.
addGregorianMonthsClip :: Integer -> Day -> Day #
Add months, with days past the last day of the month clipped to the last day. For instance, 2005-01-30 + 1 month = 2005-02-28.
gregorianMonthLength :: Integer -> Int -> Int #
The number of days in a given month according to the proleptic Gregorian calendar. First argument is year, second is month.
showGregorian :: Day -> String #
Show in ISO 8601 format (yyyy-mm-dd)
fromGregorianValid :: Integer -> Int -> Int -> Maybe Day #
Convert from proleptic Gregorian calendar. First argument is year, second month number (1-12), third day (1-31). Invalid values will return Nothing
fromGregorian :: Integer -> Int -> Int -> Day #
Convert from proleptic Gregorian calendar. First argument is year, second month number (1-12), third day (1-31). Invalid values will be clipped to the correct range, month first, then day.
toGregorian :: Day -> (Integer, Int, Int) #
Convert to proleptic Gregorian calendar. First element of result is year, second month number (1-12), third day (1-31).
isLeapYear :: Integer -> Bool #
Is this year a leap year according to the proleptic Gregorian calendar?
The Modified Julian Day is a standard count of days, with zero being the day 1858-11-17.
Constructors
| ModifiedJulianDay | |
Fields | |
Instances
| Enum Day | |
| Eq Day | |
| Data Day | |
Defined in Data.Time.Calendar.Days Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Day -> c Day # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Day # dataTypeOf :: Day -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Day) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Day) # gmapT :: (forall b. Data b => b -> b) -> Day -> Day # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Day -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Day -> r # gmapQ :: (forall d. Data d => d -> u) -> Day -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Day -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Day -> m Day # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Day -> m Day # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Day -> m Day # | |
| Ord Day | |
| Ix Day | |
| ToJSON Day | |
Defined in Data.Aeson.Types.ToJSON | |
| ToJSONKey Day | |
Defined in Data.Aeson.Types.ToJSON | |
| FromJSON Day | |
| FromJSONKey Day | |
Defined in Data.Aeson.Types.FromJSON | |
| NFData Day | |
Defined in Data.Time.Calendar.Days | |
| PathPiece Day | |
Defined in Web.PathPieces | |
| PersistField Day | |
Defined in Database.Persist.Class.PersistField | |
| FormatTime Day | |
Defined in Data.Time.Format Methods formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> Day -> String) # | |
| ParseTime Day | |
Defined in Data.Time.Format.Parse | |
type Application = Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived #
The WAI application.
Note that, since WAI 3.0, this type is structured in continuation passing
style to allow for proper safe resource handling. This was handled in the
past via other means (e.g., ResourceT). As a demonstration:
app :: Application
app req respond = bracket_
(putStrLn "Allocating scarce resource")
(putStrLn "Cleaning up")
(respond $ responseLBS status200 [] "Hello World")
Constructors
| DBRunner | |
Fields
| |
class YesodPersist site => YesodPersistRunner site where #
Since 1.2.0
Minimal complete definition
Methods
getDBRunner :: HandlerFor site (DBRunner site, HandlerFor site ()) #
This function differs from runDB in that it returns a database
runner function, as opposed to simply running a single action. This will
usually mean that a connection is taken from a pool and then reused for
each invocation. This can be useful for creating streaming responses;
see runDBSource.
It additionally returns a cleanup function to free the connection. If your code finishes successfully, you must call this cleanup to indicate changes should be committed. Otherwise, for SQL backends at least, a rollback will be used instead.
Since 1.2.0
class Monad (YesodDB site) => YesodPersist site where #
Minimal complete definition
Associated Types
type YesodPersistBackend site :: * #
Methods
runDB :: YesodDB site a -> HandlerFor site a #
type YesodDB site = ReaderT (YesodPersistBackend site) (HandlerFor site) #
defaultRunDB :: PersistConfig c => (site -> c) -> (site -> PersistConfigPool c) -> PersistConfigBackend c (HandlerFor site) a -> HandlerFor site a #
Helper for creating runDB.
Since 1.2.0
defaultGetDBRunner :: (IsSqlBackend backend, YesodPersistBackend site ~ backend) => (site -> Pool backend) -> HandlerFor site (DBRunner site, HandlerFor site ()) #
Helper for implementing getDBRunner.
Since 1.2.0
runDBSource :: YesodPersistRunner site => ConduitT () a (YesodDB site) () -> ConduitT () a (HandlerFor site) () #
Like runDB, but transforms a Source. See respondSourceDB for an
example, practical use case.
Since 1.2.0
respondSourceDB :: YesodPersistRunner site => ContentType -> ConduitT () (Flush Builder) (YesodDB site) () -> HandlerFor site TypedContent #
Extends respondSource to create a streaming database response body.
get404 :: (MonadIO m, PersistStoreRead backend, PersistRecordBackend val backend) => Key val -> ReaderT backend m val #
Get the given entity by ID, or return a 404 not found if it doesn't exist.
getBy404 :: (PersistUniqueRead backend, PersistRecordBackend val backend, MonadIO m) => Unique val -> ReaderT backend m (Entity val) #
Get the given entity by unique key, or return a 404 not found if it doesn't exist.
insert400 :: (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend val backend) => val -> ReaderT backend m (Key val) #
Create a new record in the database, returning an automatically created key, or raise a 400 bad request if a uniqueness constraint is violated.
Since: yesod-persistent-1.4.1
insert400_ :: (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend val backend) => val -> ReaderT backend m () #
Same as insert400, but doesn’t return a key.
Since: yesod-persistent-1.4.1
data FormMessage #
Constructors
Instances
| Eq FormMessage | |
Defined in Yesod.Form.Types | |
| Read FormMessage | |
Defined in Yesod.Form.Types Methods readsPrec :: Int -> ReadS FormMessage # readList :: ReadS [FormMessage] # readPrec :: ReadPrec FormMessage # readListPrec :: ReadPrec [FormMessage] # | |
| Show FormMessage | |
Defined in Yesod.Form.Types Methods showsPrec :: Int -> FormMessage -> ShowS # show :: FormMessage -> String # showList :: [FormMessage] -> ShowS # | |
| RenderMessage App FormMessage # | |
Defined in Hledger.Web.Foundation Methods renderMessage :: App -> [Lang] -> FormMessage -> Text # | |
Constructors
| Field | |
Fields
| |
type FieldViewFunc (m :: * -> *) a #
data FieldSettings master #
Constructors
| FieldSettings | |
Instances
| IsString (FieldSettings a) | |
Defined in Yesod.Form.Types Methods fromString :: String -> FieldSettings a # | |
newtype AForm (m :: * -> *) a #
Constructors
| AForm | |
Fields
| |
type WForm (m :: * -> *) a = MForm (WriterT [FieldView (HandlerSite m)] m) a #
MForm variant stacking a WriterT. The following code example using a
monadic form MForm:
formToAForm $ do
(field1F, field1V) <- mreq textField MsgField1 Nothing
(field2F, field2V) <- mreq (checkWith field1F textField) MsgField2 Nothing
(field3F, field3V) <- mreq (checkWith field1F textField) MsgField3 Nothing
return
( MyForm <$> field1F <*> field2F <*> field3F
, [field1V, field2V, field3V]
)Could be rewritten as follows using WForm:
wFormToAForm $ do field1F <- wreq textField MsgField1 Nothing field2F <- wreq (checkWith field1F textField) MsgField2 Nothing field3F <- wreq (checkWith field1F textField) MsgField3 Nothing return $ MyForm <$> field1F <*> field2F <*> field3F
Since: yesod-form-1.4.14
The encoding type required by a form. The ToHtml instance produces values
that can be inserted directly into HTML.
Constructors
| UrlEncoded | |
| Multipart |
Instances
| Bounded Enctype | |
| Enum Enctype | |
| Eq Enctype | |
| Semigroup Enctype | |
| Monoid Enctype | |
| ToValue Enctype | |
Defined in Yesod.Form.Types | |
| ToMarkup Enctype | |
Defined in Yesod.Form.Types | |
data FormResult a #
A form can produce three different results: there was no data available, the data was invalid, or there was a successful parse.
The Applicative instance will concatenate the failure messages in two
FormResults.
The Alternative instance will choose FormFailure before FormSuccess,
and FormMissing last of all.
Constructors
| FormMissing | |
| FormFailure [Text] | |
| FormSuccess a |
Instances
newtype FormInput (m :: * -> *) a #
Type for a form which parses a value of type a with the base monad m
(usually your Handler). Can compose this using its Applicative instance.
Constructors
| FormInput | |
Fields
| |
Instances
| Monad m => Functor (FormInput m) | |
| Monad m => Applicative (FormInput m) | |
Defined in Yesod.Form.Input | |
Arguments
| :: (Monad m, RenderMessage (HandlerSite m) FormMessage) | |
| => Field m a | |
| -> Text | name of the field |
| -> FormInput m a |
Promote a Field into a FormInput, requiring that the value be present
and valid.
iopt :: Monad m => Field m a -> Text -> FormInput m (Maybe a) #
Promote a Field into a FormInput, with its presence being optional. If
the value is present but does not parse correctly, the form will still fail.
runInputGet :: MonadHandler m => FormInput m a -> m a #
Run a FormInput on the GET parameters (i.e., query string). If parsing
fails, calls invalidArgs.
runInputGetResult :: MonadHandler m => FormInput m a -> m (FormResult a) #
Run a FormInput on the GET parameters (i.e., query string). Does not
throw exceptions on failure.
Since 1.4.1
runInputPost :: MonadHandler m => FormInput m a -> m a #
Run a FormInput on the POST parameters (i.e., request body). If parsing
fails, calls invalidArgs.
runInputPostResult :: MonadHandler m => FormInput m a -> m (FormResult a) #
Run a FormInput on the POST parameters (i.e., request body). Does not
throw exceptions on failure.
type FormRender (m :: * -> *) a = AForm m a -> Markup -> MForm m (FormResult a, WidgetFor (HandlerSite m) ()) #
newFormIdent :: Monad m => MForm m Text #
Get a unique identifier.
formToAForm :: (HandlerSite m ~ site, Monad m) => MForm m (FormResult a, [FieldView site]) -> AForm m a #
aFormToForm :: (Monad m, HandlerSite m ~ site) => AForm m a -> MForm m (FormResult a, [FieldView site] -> [FieldView site]) #
Arguments
| :: (RenderMessage site FormMessage, HandlerSite m ~ site, MonadHandler m) | |
| => Field m a | form field |
| -> FieldSettings site | settings for this field |
| -> Maybe a | optional default value |
| -> WForm m (FormResult a) |
Converts a form field into monadic form WForm. This field requires a
value and will return FormFailure if left empty.
Since: yesod-form-1.4.14
Arguments
| :: (MonadHandler m, HandlerSite m ~ site) | |
| => Field m a | form field |
| -> FieldSettings site | settings for this field |
| -> Maybe (Maybe a) | optional default value |
| -> WForm m (FormResult (Maybe a)) |
Arguments
| :: MonadHandler m | |
| => WForm m (FormResult a) | input form |
| -> AForm m a | output form |
Arguments
| :: (MonadHandler m, HandlerSite m ~ site) | |
| => WForm m a | input form |
| -> MForm m (a, [FieldView site]) | output form |
Arguments
| :: (MonadHandler m, HandlerSite m ~ site) | |
| => MForm m (a, FieldView site) | input form |
| -> WForm m a | output form |
Arguments
| :: (RenderMessage site FormMessage, HandlerSite m ~ site, MonadHandler m) | |
| => Field m a | form field |
| -> FieldSettings site | settings for this field |
| -> Maybe a | optional default value |
| -> MForm m (FormResult a, FieldView site) |
Converts a form field into monadic form. This field requires a value
and will return FormFailure if left empty.
mopt :: (site ~ HandlerSite m, MonadHandler m) => Field m a -> FieldSettings site -> Maybe (Maybe a) -> MForm m (FormResult (Maybe a), FieldView site) #
areq :: (RenderMessage site FormMessage, HandlerSite m ~ site, MonadHandler m) => Field m a -> FieldSettings site -> Maybe a -> AForm m a #
Applicative equivalent of mreq.
aopt :: MonadHandler m => Field m a -> FieldSettings (HandlerSite m) -> Maybe (Maybe a) -> AForm m (Maybe a) #
Applicative equivalent of mopt.
runFormPost :: (RenderMessage (HandlerSite m) FormMessage, MonadResource m, MonadHandler m) => (Markup -> MForm m (FormResult a, xml)) -> m ((FormResult a, xml), Enctype) #
This function is used to both initially render a form and to later extract results from it. Note that, due to CSRF protection and a few other issues, forms submitted via GET and POST are slightly different. As such, be sure to call the relevant function based on how the form will be submitted, not the current request method.
For example, a common case is displaying a form on a GET request and having
the form submit to a POST page. In such a case, both the GET and POST
handlers should use runFormPost.
generateFormPost :: (RenderMessage (HandlerSite m) FormMessage, MonadHandler m) => (Markup -> MForm m (FormResult a, xml)) -> m (xml, Enctype) #
Similar to runFormPost, except it always ignores the currently available
environment. This is necessary in cases like a wizard UI, where a single
page will both receive and incoming form and produce a new, blank form. For
general usage, you can stick with runFormPost.
runFormPostNoToken :: MonadHandler m => (Markup -> MForm m a) -> m (a, Enctype) #
runFormGet :: MonadHandler m => (Markup -> MForm m a) -> m (a, Enctype) #
generateFormGet' :: MonadHandler m => (Markup -> MForm m (FormResult a, xml)) -> m (xml, Enctype) #
Since 1.3.11
generateFormGet :: MonadHandler m => (Markup -> MForm m a) -> m (a, Enctype) #
Arguments
| :: Monad m | |
| => Text | Form identification string. |
| -> (Markup -> MForm m (FormResult a, WidgetFor (HandlerSite m) ())) | |
| -> Markup | |
| -> MForm m (FormResult a, WidgetFor (HandlerSite m) ()) |
Creates a hidden field on the form that identifies it. This identification is then used to distinguish between missing and wrong form data when a single handler contains more than one form.
For instance, if you have the following code on your handler:
((fooRes, fooWidget), fooEnctype) <- runFormPost fooForm ((barRes, barWidget), barEnctype) <- runFormPost barForm
Then replace it with
((fooRes, fooWidget), fooEnctype) <- runFormPost $ identifyForm "foo" fooForm ((barRes, barWidget), barEnctype) <- runFormPost $ identifyForm "bar" barForm
Note that it's your responsibility to ensure that the identification strings are unique (using the same one twice on a single handler will not generate any errors). This allows you to create a variable number of forms and still have them work even if their number or order change between the HTML generation and the form submission.
renderTable :: Monad m => FormRender m a #
Render a form into a series of tr tags. Note that, in order to allow you to add extra rows to the table, this function does not wrap up the resulting HTML in a table tag; you must do that yourself.
renderDivs :: Monad m => FormRender m a #
render a field inside a div
renderDivsNoLabels :: Monad m => FormRender m a #
render a field inside a div, not displaying any label
renderBootstrap2 :: Monad m => FormRender m a #
Render a form using Bootstrap v2-friendly shamlet syntax. If you're using Bootstrap v3, then you should use the functions from module Yesod.Form.Bootstrap3.
Sample Hamlet:
<form .form-horizontal method=post action=@{ActionR} enctype=#{formEnctype}>
<fieldset>
<legend>_{MsgLegend}
$case result
$of FormFailure reasons
$forall reason <- reasons
<div .alert .alert-error>#{reason}
$of _
^{formWidget}
<div .form-actions>
<input .btn .primary type=submit value=_{MsgSubmit}>Since 1.3.14
renderBootstrap :: Monad m => FormRender m a #
Deprecated synonym for renderBootstrap2.
check :: (Monad m, RenderMessage (HandlerSite m) msg) => (a -> Either msg a) -> Field m a -> Field m a #
checkBool :: (Monad m, RenderMessage (HandlerSite m) msg) => (a -> Bool) -> msg -> Field m a -> Field m a #
Return the given error message if the predicate is false.
checkM :: (Monad m, RenderMessage (HandlerSite m) msg) => (a -> m (Either msg a)) -> Field m a -> Field m a #
checkMMap :: (Monad m, RenderMessage (HandlerSite m) msg) => (a -> m (Either msg b)) -> (b -> a) -> Field m a -> Field m b #
Same as checkM, but modifies the datatype.
In order to make this work, you must provide a function to convert back from the new datatype to the old one (the second argument to this function).
Since 1.1.2
customErrorMessage :: Monad m => SomeMessage (HandlerSite m) -> Field m a -> Field m a #
Allows you to overwrite the error message on parse error.
fieldSettingsLabel :: RenderMessage site msg => msg -> FieldSettings site #
Generate a FieldSettings from the given label.
parseHelper :: (Monad m, RenderMessage site FormMessage) => (Text -> Either FormMessage a) -> [Text] -> [FileInfo] -> m (Either (SomeMessage site) (Maybe a)) #
A helper function for creating custom fields.
This is intended to help with the common case where a single input value is required, such as when parsing a text field.
Since 1.1
parseHelperGen :: (Monad m, RenderMessage site msg) => (Text -> Either msg a) -> [Text] -> [FileInfo] -> m (Either (SomeMessage site) (Maybe a)) #
A generalized version of parseHelper, allowing any type for the message
indicating a bad parse.
Since 1.3.6
convertField :: Functor m => (a -> b) -> (b -> a) -> Field m a -> Field m b #
Since a Field cannot be a Functor, it is not obvious how to "reuse" a Field
on a newtype or otherwise equivalent type. This function allows you to convert
a Field m a to a Field m b assuming you provide a bidirectional
conversion between the two, through the first two functions.
A simple example:
import Data.Monoid sumField :: (Functor m, Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m (Sum Int) sumField = convertField Sum getSum intField
Another example, not using a newtype, but instead creating a Lazy Text field:
import qualified Data.Text.Lazy as TL TextField :: (Functor m, Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m TL.Text lazyTextField = convertField TL.fromStrict TL.toStrict textField
Since 1.3.16
Constructors
| Option | |
Fields
| |
data OptionList a #
A structure holding a list of options. Typically you can use a convenience function like mkOptionList or optionsPairs instead of creating this directly.
Constructors
| OptionList | |
Fields
| |
Instances
| Functor OptionList | Since 1.4.6 |
Defined in Yesod.Form.Fields Methods fmap :: (a -> b) -> OptionList a -> OptionList b # (<$) :: a -> OptionList b -> OptionList a # | |
A newtype wrapper around a Text whose ToMarkup instance converts newlines to HTML <br> tags.
(When text is entered into a <textarea>, newline characters are used to separate lines.
If this text is then placed verbatim into HTML, the lines won't be separated, thus the need for replacing with <br> tags).
If you don't need this functionality, simply use unTextarea to access the raw text.
Constructors
| Textarea | |
Fields
| |
Instances
| Eq Textarea | |
| Ord Textarea | |
Defined in Yesod.Form.Fields | |
| Read Textarea | |
| Show Textarea | |
| ToJSON Textarea | |
Defined in Yesod.Form.Fields | |
| FromJSON Textarea | |
| ToMarkup Textarea | |
Defined in Yesod.Form.Fields | |
| PersistFieldSql Textarea | |
| PersistField Textarea | |
Defined in Yesod.Form.Fields Methods toPersistValue :: Textarea -> PersistValue # | |
defaultFormMessage :: FormMessage -> Text #
intField :: (Monad m, Integral i, RenderMessage (HandlerSite m) FormMessage) => Field m i #
Creates a input with type="number" and step=1.
doubleField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Double #
Creates a input with type="number" and step=any.
dayField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Day #
Creates an input with type="date", validating the input using the parseDate function.
Add the time package and import the Data.Time.Calendar module to use this function.
timeField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m TimeOfDay #
An alias for timeFieldTypeTime.
timeFieldTypeTime :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m TimeOfDay #
Creates an input with type="time". Browsers not supporting this type will fallback to a text field, and Yesod will parse the time as described in timeFieldTypeText.
Add the time package and import the Data.Time.LocalTime module to use this function.
Since 1.4.2
timeFieldTypeText :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m TimeOfDay #
Creates an input with type="text", parsing the time from an [H]H:MM[:SS] format, with an optional AM or PM (if not given, AM is assumed for compatibility with the 24 hour clock system).
This function exists for backwards compatibility with the old implementation of timeField, which used to use type="text". Consider using timeField or timeFieldTypeTime for improved UX and validation from the browser.
Add the time package and import the Data.Time.LocalTime module to use this function.
Since 1.4.2
htmlField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Html #
Creates a <textarea> tag whose input is sanitized to prevent XSS attacks and is validated for having balanced tags.
textareaField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Textarea #
:: (Monad m, PathPiece p, RenderMessage (HandlerSite m) FormMessage) => Field m p #
Creates an input with type="hidden"; you can use this to store information in a form that users shouldn't see (for example, Yesod stores CSRF tokens in a hidden field).
textField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Text #
Creates a input with type="text".
passwordField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Text #
Creates an input with type="password".
emailField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Text #
Creates an input with type="email". Yesod will validate the email's correctness according to RFC5322 and canonicalize it by removing comments and whitespace (see Text.Email.Validate).
multiEmailField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m [Text] #
Creates an input with type="email" with the multiple attribute; browsers might implement this as taking a comma separated list of emails. Each email address is validated as described in emailField.
Since 1.3.7
searchField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => AutoFocus -> Field m Text #
Creates an input with type="search". For browsers without autofocus support, a JS fallback is used if AutoFocus is true.
urlField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Text #
Creates an input with type="url", validating the URL according to RFC3986.
selectFieldList :: (Eq a, RenderMessage site FormMessage, RenderMessage site msg) => [(msg, a)] -> Field (HandlerFor site) a #
Creates a <select> tag for selecting one option. Example usage:
areq (selectFieldList [("Value 1" :: Text, "value1"),("Value 2", "value2")]) "Which value?" NothingselectField :: (Eq a, RenderMessage site FormMessage) => HandlerFor site (OptionList a) -> Field (HandlerFor site) a #
Creates a <select> tag for selecting one option. Example usage:
areq (selectField $ optionsPairs [(MsgValue1, "value1"),(MsgValue2, "value2")]) "Which value?" Nothing
multiSelectFieldList :: (Eq a, RenderMessage site msg) => [(msg, a)] -> Field (HandlerFor site) [a] #
Creates a <select> tag for selecting multiple options.
multiSelectField :: Eq a => HandlerFor site (OptionList a) -> Field (HandlerFor site) [a] #
Creates a <select> tag for selecting multiple options.
radioFieldList :: (Eq a, RenderMessage site FormMessage, RenderMessage site msg) => [(msg, a)] -> Field (HandlerFor site) a #
Creates an input with type="radio" for selecting one option.
checkboxesFieldList :: (Eq a, RenderMessage site msg) => [(msg, a)] -> Field (HandlerFor site) [a] #
Creates an input with type="checkbox" for selecting multiple options.
checkboxesField :: Eq a => HandlerFor site (OptionList a) -> Field (HandlerFor site) [a] #
Creates an input with type="checkbox" for selecting multiple options.
radioField :: (Eq a, RenderMessage site FormMessage) => HandlerFor site (OptionList a) -> Field (HandlerFor site) a #
Creates an input with type="radio" for selecting one option.
boolField :: (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Bool #
Creates a group of radio buttons to answer the question given in the message. Radio buttons are used to allow differentiating between an empty response (Nothing) and a no response (Just False). Consider using the simpler checkBoxField if you don't need to make this distinction.
If this field is optional, the first radio button is labeled "<None>", the second "Yes" and the third "No".
If this field is required, the first radio button is labeled "Yes" and the second "No".
(Exact label titles will depend on localization).
checkBoxField :: Monad m => Field m Bool #
Creates an input with type="checkbox".
While the default boolFieldNothing) and a no
response (Just False), this simpler checkbox field returns an empty
response as Just False.
Note that this makes the field always optional.
mkOptionList :: [Option a] -> OptionList a #
Creates an OptionList, using a Map to implement the olReadExternal function.
optionsPairs :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => [(msg, a)] -> m (OptionList a) #
Creates an OptionList from a list of (display-value, internal value) pairs.
optionsEnum :: (MonadHandler m, Show a, Enum a, Bounded a) => m (OptionList a) #
Creates an OptionList from an Enum, using its Show instance for the user-facing value.
optionsPersist :: (YesodPersist site, PersistQueryRead backend, PathPiece (Key a), RenderMessage site msg, YesodPersistBackend site ~ backend, PersistRecordBackend a backend) => [Filter a] -> [SelectOpt a] -> (a -> msg) -> HandlerFor site (OptionList (Entity a)) #
Selects a list of Entitys with the given Filter and SelectOpts. The (a -> msg) function is then used to derive the display value for an OptionList. Example usage:
Country name Text deriving Eq -- Must derive Eq
data CountryForm = CountryForm
{ country :: Entity Country
}
countryNameForm :: AForm Handler CountryForm
countryNameForm = CountryForm
<$> areq (selectField countries) "Which country do you live in?" Nothing
where
countries = optionsPersist [] [Asc CountryName] countryNameoptionsPersistKey :: (YesodPersist site, PersistQueryRead backend, PathPiece (Key a), RenderMessage site msg, backend ~ YesodPersistBackend site, PersistRecordBackend a backend) => [Filter a] -> [SelectOpt a] -> (a -> msg) -> HandlerFor site (OptionList (Key a)) #
An alternative to optionsPersist which returns just the Key instead of
the entire Entity.
Since 1.3.2
fileAFormReq :: (MonadHandler m, RenderMessage (HandlerSite m) FormMessage) => FieldSettings (HandlerSite m) -> AForm m FileInfo #
fileAFormOpt :: MonadHandler m => FieldSettings (HandlerSite m) -> AForm m (Maybe FileInfo) #
formatRFC1123 :: UTCTime -> Text #
Format as per RFC 1123.
formatRFC822 :: UTCTime -> Text #
Format as per RFC 822.
class RenderRoute a => RouteAttrs a where #
Minimal complete definition
Instances
| RouteAttrs App # | |
Defined in Hledger.Web.Foundation | |
class RenderRoute a => ParseRoute a where #
Minimal complete definition
Methods
Instances
| ParseRoute WaiSubsiteWithAuth | |
Defined in Yesod.Core.Types Methods parseRoute :: ([Text], [(Text, Text)]) -> Maybe (Route WaiSubsiteWithAuth) # | |
| ParseRoute WaiSubsite | |
Defined in Yesod.Core.Types Methods parseRoute :: ([Text], [(Text, Text)]) -> Maybe (Route WaiSubsite) # | |
| ParseRoute LiteApp | |
Defined in Yesod.Core.Internal.LiteApp | |
| ParseRoute Static | |
Defined in Yesod.Static | |
| ParseRoute App # | |
Defined in Hledger.Web.Foundation | |
The type-safe URLs associated with a site argument.
Instances
data SubHandlerFor sub master a #
A handler monad for subsite
Since: yesod-core-1.6.0
Instances
| Monad (SubHandlerFor child master) | |
Defined in Yesod.Core.Types Methods (>>=) :: SubHandlerFor child master a -> (a -> SubHandlerFor child master b) -> SubHandlerFor child master b # (>>) :: SubHandlerFor child master a -> SubHandlerFor child master b -> SubHandlerFor child master b # return :: a -> SubHandlerFor child master a # fail :: String -> SubHandlerFor child master a # | |
| Functor (SubHandlerFor sub master) | |
Defined in Yesod.Core.Types Methods fmap :: (a -> b) -> SubHandlerFor sub master a -> SubHandlerFor sub master b # (<$) :: a -> SubHandlerFor sub master b -> SubHandlerFor sub master a # | |
| Applicative (SubHandlerFor child master) | |
Defined in Yesod.Core.Types Methods pure :: a -> SubHandlerFor child master a # (<*>) :: SubHandlerFor child master (a -> b) -> SubHandlerFor child master a -> SubHandlerFor child master b # liftA2 :: (a -> b -> c) -> SubHandlerFor child master a -> SubHandlerFor child master b -> SubHandlerFor child master c # (*>) :: SubHandlerFor child master a -> SubHandlerFor child master b -> SubHandlerFor child master b # (<*) :: SubHandlerFor child master a -> SubHandlerFor child master b -> SubHandlerFor child master a # | |
| MonadThrow (SubHandlerFor child master) | |
Defined in Yesod.Core.Types Methods throwM :: Exception e => e -> SubHandlerFor child master a # | |
| MonadIO (SubHandlerFor child master) | |
Defined in Yesod.Core.Types Methods liftIO :: IO a -> SubHandlerFor child master a # | |
| MonadUnliftIO (SubHandlerFor child master) | Since: yesod-core-1.4.38 |
Defined in Yesod.Core.Types Methods askUnliftIO :: SubHandlerFor child master (UnliftIO (SubHandlerFor child master)) # withRunInIO :: ((forall a. SubHandlerFor child master a -> IO a) -> IO b) -> SubHandlerFor child master b # | |
| MonadResource (SubHandlerFor child master) | |
Defined in Yesod.Core.Types Methods liftResourceT :: ResourceT IO a -> SubHandlerFor child master a # | |
| MonadLogger (SubHandlerFor child master) | |
Defined in Yesod.Core.Types Methods monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> SubHandlerFor child master () # | |
| MonadLoggerIO (SubHandlerFor child master) | |
Defined in Yesod.Core.Types Methods askLoggerIO :: SubHandlerFor child master (Loc -> LogSource -> LogLevel -> LogStr -> IO ()) # | |
| MonadHandler (SubHandlerFor sub master) | |
Defined in Yesod.Core.Class.Handler Associated Types type HandlerSite (SubHandlerFor sub master) :: * # type SubHandlerSite (SubHandlerFor sub master) :: * # Methods liftHandler :: HandlerFor (HandlerSite (SubHandlerFor sub master)) a -> SubHandlerFor sub master a # liftSubHandler :: SubHandlerFor (SubHandlerSite (SubHandlerFor sub master)) (HandlerSite (SubHandlerFor sub master)) a -> SubHandlerFor sub master a # | |
| MonadReader (HandlerData child master) (SubHandlerFor child master) | |
Defined in Yesod.Core.Types Methods ask :: SubHandlerFor child master (HandlerData child master) # local :: (HandlerData child master -> HandlerData child master) -> SubHandlerFor child master a -> SubHandlerFor child master a # reader :: (HandlerData child master -> a) -> SubHandlerFor child master a # | |
| type SubHandlerSite (SubHandlerFor sub master) | |
Defined in Yesod.Core.Class.Handler | |
| type HandlerSite (SubHandlerFor sub master) | |
Defined in Yesod.Core.Class.Handler | |
Headers to be added to a Result.
Constructors
| AddCookie !SetCookie | |
| DeleteCookie !ByteString !ByteString | name and path |
| Header !(CI ByteString) !ByteString | key and value |
data ErrorResponse #
Responses to indicate some form of an error occurred.
Constructors
| NotFound | |
| InternalError !Text | |
| InvalidArgs ![Text] | |
| NotAuthenticated | |
| PermissionDenied !Text | |
| BadMethod !Method |
Instances
newtype DontFullyEvaluate a #
Prevents a response body from being fully evaluated before sending the request.
Since 1.1.0
Constructors
| DontFullyEvaluate | |
Fields
| |
Instances
| ToTypedContent a => ToTypedContent (DontFullyEvaluate a) | |
Defined in Yesod.Core.Content Methods toTypedContent :: DontFullyEvaluate a -> TypedContent # | |
| HasContentType a => HasContentType (DontFullyEvaluate a) | |
Defined in Yesod.Core.Content Methods getContentType :: Monad m => m (DontFullyEvaluate a) -> ContentType # | |
| ToContent a => ToContent (DontFullyEvaluate a) | |
Defined in Yesod.Core.Content Methods toContent :: DontFullyEvaluate a -> Content # | |
type ContentType = ByteString #
Instances
| ToTypedContent RepXml | |
Defined in Yesod.Core.Content Methods toTypedContent :: RepXml -> TypedContent # | |
| HasContentType RepXml | |
Defined in Yesod.Core.Content Methods getContentType :: Monad m => m RepXml -> ContentType # | |
| ToContent RepXml | |
Defined in Yesod.Core.Content | |
Instances
| ToTypedContent RepPlain | |
Defined in Yesod.Core.Content Methods toTypedContent :: RepPlain -> TypedContent # | |
| HasContentType RepPlain | |
Defined in Yesod.Core.Content Methods getContentType :: Monad m => m RepPlain -> ContentType # | |
| ToContent RepPlain | |
Defined in Yesod.Core.Content | |
Instances
| ToTypedContent RepJson | |
Defined in Yesod.Core.Content Methods toTypedContent :: RepJson -> TypedContent # | |
| HasContentType RepJson | |
Defined in Yesod.Core.Content Methods getContentType :: Monad m => m RepJson -> ContentType # | |
| ToContent RepJson | |
Defined in Yesod.Core.Content | |
data TypedContent #
Constructors
| TypedContent !ContentType !Content |
Instances
| ToTypedContent TypedContent | |
Defined in Yesod.Core.Content Methods | |
| ToContent TypedContent | |
Defined in Yesod.Core.Content Methods toContent :: TypedContent -> Content # | |
Constructors
| ContentBuilder !Builder !(Maybe Int) | The content and optional content length. |
| ContentSource !(ConduitT () (Flush Builder) (ResourceT IO) ()) | |
| ContentFile !FilePath !(Maybe FilePart) | |
| ContentDontEvaluate !Content |
Instances
| IsString Content | |
Defined in Yesod.Core.Types Methods fromString :: String -> Content # | |
| ToContent Content | |
Defined in Yesod.Core.Content | |
| ToTypedContent (ContentType, Content) | |
Defined in Yesod.Core.Content Methods toTypedContent :: (ContentType, Content) -> TypedContent # | |
| ToContent (ContentType, Content) | |
Defined in Yesod.Core.Content Methods toContent :: (ContentType, Content) -> Content # | |
data PageContent url #
Content for a web page. By providing this datatype, we can easily create generic site templates, which would have the type signature:
PageContent url -> HtmlUrl url
newtype CssBuilder #
Newtype wrapper allowing injection of arbitrary content into CSS.
Usage:
toWidget $ CssBuilder "p { color: red }"Since: 1.1.3
Constructors
| CssBuilder | |
Fields | |
Instances
| ToWidgetHead site CssBuilder | |
Defined in Yesod.Core.Widget Methods toWidgetHead :: (MonadWidget m, HandlerSite m ~ site) => CssBuilder -> m () # | |
| ToWidgetMedia site CssBuilder | |
Defined in Yesod.Core.Widget Methods toWidgetMedia :: (MonadWidget m, HandlerSite m ~ site) => Text -> CssBuilder -> m () # | |
| ToWidget site CssBuilder | |
Defined in Yesod.Core.Widget Methods toWidget :: (MonadWidget m, HandlerSite m ~ site) => CssBuilder -> m () # | |
| render ~ RY site => ToWidgetHead site (render -> CssBuilder) | |
Defined in Yesod.Core.Widget Methods toWidgetHead :: (MonadWidget m, HandlerSite m ~ site) => (render -> CssBuilder) -> m () # | |
| render ~ RY site => ToWidgetMedia site (render -> CssBuilder) | |
Defined in Yesod.Core.Widget Methods toWidgetMedia :: (MonadWidget m, HandlerSite m ~ site) => Text -> (render -> CssBuilder) -> m () # | |
| render ~ RY site => ToWidget site (render -> CssBuilder) | |
Defined in Yesod.Core.Widget Methods toWidget :: (MonadWidget m, HandlerSite m ~ site) => (render -> CssBuilder) -> m () # | |
A generic widget, allowing specification of both the subsite and master
site datatypes. While this is simply a WriterT, we define a newtype for
better error messages.
Instances
data HandlerFor site a #
A generic handler monad, which can have a different subsite and master site. We define a newtype for better error message.
Instances
newtype WaiSubsiteWithAuth #
Like WaiSubsite, but applies parent site's middleware and isAuthorized.
Since: yesod-core-1.4.34
Constructors
| WaiSubsiteWithAuth | |
Fields | |
Instances
newtype WaiSubsite #
Wrap up a normal WAI application as a Yesod subsite. Ignore parent site's middleware and isAuthorized.
Constructors
| WaiSubsite | |
Fields | |
Instances
type BottomOfHeadAsync master #
data ScriptLoadPosition master #
Constructors
| BottomOfBody | |
| BottomOfHeadBlocking | |
| BottomOfHeadAsync !(BottomOfHeadAsync master) |
data AuthResult #
Constructors
| Authorized | |
| AuthenticationRequired | |
| Unauthorized !Text |
Instances
| Eq AuthResult | |
Defined in Yesod.Core.Types | |
| Read AuthResult | |
Defined in Yesod.Core.Types Methods readsPrec :: Int -> ReadS AuthResult # readList :: ReadS [AuthResult] # readPrec :: ReadPrec AuthResult # readListPrec :: ReadPrec [AuthResult] # | |
| Show AuthResult | |
Defined in Yesod.Core.Types Methods showsPrec :: Int -> AuthResult -> ShowS # show :: AuthResult -> String # showList :: [AuthResult] -> ShowS # | |
How to determine the root of the application for constructing URLs.
Note that future versions of Yesod may add new constructors without bumping
the major version number. As a result, you should not pattern match on
Approot values.
Constructors
| ApprootRelative | No application root. |
| ApprootStatic !Text | |
| ApprootMaster !(master -> Text) | |
| ApprootRequest !(master -> Request -> Text) |
data FileUpload #
Constructors
| FileUploadMemory !(BackEnd ByteString) | |
| FileUploadDisk !(InternalState -> BackEnd FilePath) | |
| FileUploadSource !(BackEnd (ConduitT () ByteString (ResourceT IO) ())) |
type RequestBodyContents = ([(Text, Text)], [(Text, FileInfo)]) #
A tuple containing both the POST parameters and submitted files.
data YesodRequest #
The parsed request information. This type augments the standard WAI
Request with additional information.
Constructors
| YesodRequest | |
Fields
| |
newtype SessionBackend #
Constructors
| SessionBackend | |
Fields
| |
type SessionMap = Map Text ByteString #
Arguments
| :: NominalDiffTime | Inactive session validity. |
| -> IO (IO ClientSessionDateCache, IO ()) |
class ToContent a => ToTypedContent a where #
Any type which can be converted to TypedContent.
Since 1.2.0
Minimal complete definition
Methods
toTypedContent :: a -> TypedContent #
Instances
class ToTypedContent a => HasContentType a where #
Minimal complete definition
Methods
getContentType :: Monad m => m a -> ContentType #
Instances
class ToFlushBuilder a where #
A class for all data which can be sent in a streaming response. Note that for textual data, instances must use UTF-8 encoding.
Since 1.2.0
Minimal complete definition
Methods
toFlushBuilder :: a -> Flush Builder #
Instances
Anything which can be converted into Content. Most of the time, you will
want to use the ContentBuilder constructor. An easier approach will be to use
a pre-defined toContent function, such as converting your data into a lazy
bytestring and then calling toContent on that.
Please note that the built-in instances for lazy data structures (String,
lazy ByteString, lazy Text and Html) will not automatically include
the content length for the ContentBuilder constructor.
Minimal complete definition
Instances
emptyContent :: Content #
Zero-length enumerator.
typeHtml :: ContentType #
typeJson :: ContentType #
typeXml :: ContentType #
typeAtom :: ContentType #
typeRss :: ContentType #
typeJpeg :: ContentType #
typePng :: ContentType #
typeGif :: ContentType #
typeSvg :: ContentType #
typeCss :: ContentType #
typeFlv :: ContentType #
typeOgv :: ContentType #
simpleContentType :: ContentType -> ContentType #
Removes "extra" information at the end of a content type string. In particular, removes everything after the semicolon, if present.
For example, "text/html; charset=utf-8" is commonly used to specify the character encoding for HTML data. This function would return "text/html".
contentTypeTypes :: ContentType -> (ByteString, ByteString) #
Give just the media types as a pair.
For example, "text/html; charset=utf-8" returns ("text", "html")
class MonadHandler m => MonadWidget (m :: * -> *) where #
Minimal complete definition
Methods
liftWidget :: WidgetFor (HandlerSite m) a -> m a #
Instances
class (MonadResource m, MonadLogger m) => MonadHandler (m :: * -> *) where #
Minimal complete definition
Methods
liftHandler :: HandlerFor (HandlerSite m) a -> m a #
liftSubHandler :: SubHandlerFor (SubHandlerSite m) (HandlerSite m) a -> m a #
Instances
data ProvidedRep (m :: * -> *) #
Internal representation of a single provided representation.
Since: yesod-core-1.2.0
Add a fragment identifier to a route to be used when redirecting. For example:
redirect (NewsfeedR :#: storyId)
@since 1.2.9.
Constructors
| a :#: b |
Instances
| (RedirectUrl master a, PathPiece b) => RedirectUrl master (Fragment a b) | |
Defined in Yesod.Core.Handler Methods toTextUrl :: (MonadHandler m, HandlerSite m ~ master) => Fragment a b -> m Text # | |
| (Show a, Show b) => Show (Fragment a b) | |
class RedirectUrl master a where #
Some value which can be turned into a URL for redirects.
Minimal complete definition
Methods
toTextUrl :: (MonadHandler m, HandlerSite m ~ master) => a -> m Text #
Converts the value to the URL and a list of query-string parameters.
Instances
| RedirectUrl master String | |
Defined in Yesod.Core.Handler Methods toTextUrl :: (MonadHandler m, HandlerSite m ~ master) => String -> m Text # | |
| RedirectUrl master Text | |
Defined in Yesod.Core.Handler Methods toTextUrl :: (MonadHandler m, HandlerSite m ~ master) => Text -> m Text # | |
| RedirectUrl master (Route master) | |
Defined in Yesod.Core.Handler Methods toTextUrl :: (MonadHandler m, HandlerSite m ~ master) => Route master -> m Text # | |
| (RedirectUrl master a, PathPiece b) => RedirectUrl master (Fragment a b) | |
Defined in Yesod.Core.Handler Methods toTextUrl :: (MonadHandler m, HandlerSite m ~ master) => Fragment a b -> m Text # | |
| (key ~ Text, val ~ Text) => RedirectUrl master (Route master, [(key, val)]) | |
Defined in Yesod.Core.Handler Methods toTextUrl :: (MonadHandler m, HandlerSite m ~ master) => (Route master, [(key, val)]) -> m Text # | |
| (key ~ Text, val ~ Text) => RedirectUrl master (Route master, Map key val) | |
Defined in Yesod.Core.Handler Methods toTextUrl :: (MonadHandler m, HandlerSite m ~ master) => (Route master, Map key val) -> m Text # | |
type HandlerT site (m :: * -> *) = HandlerFor site #
getRequest :: MonadHandler m => m YesodRequest #
runRequestBody :: MonadHandler m => m RequestBodyContents #
getYesod :: MonadHandler m => m (HandlerSite m) #
Get the master site application argument.
getsYesod :: MonadHandler m => (HandlerSite m -> a) -> m a #
Get a specific component of the master site application argument.
Analogous to the gets function for operating on StateT.
getUrlRender :: MonadHandler m => m (Route (HandlerSite m) -> Text) #
Get the URL rendering function.
getUrlRenderParams :: MonadHandler m => m (Route (HandlerSite m) -> [(Text, Text)] -> Text) #
The URL rendering function with query-string parameters.
getPostParams :: MonadHandler m => m [(Text, Text)] #
Get all the post parameters passed to the handler. To also get
the submitted files (if any), you have to use runRequestBody
instead of this function.
Since: yesod-core-1.4.33
getCurrentRoute :: MonadHandler m => m (Maybe (Route (HandlerSite m))) #
Get the route requested by the user. If this is a 404 response- where the
user requested an invalid route- this function will return Nothing.
handlerToIO :: MonadIO m => HandlerFor site (HandlerFor site a -> m a) #
Returns a function that runs HandlerT actions inside IO.
Sometimes you want to run an inner HandlerT action outside
the control flow of an HTTP request (on the outer HandlerT
action). For example, you may want to spawn a new thread:
getFooR :: Handler RepHtml
getFooR = do
runInnerHandler <- handlerToIO
liftIO $ forkIO $ runInnerHandler $ do
Code here runs inside GHandler but on a new thread.
This is the inner GHandler.
...
Code here runs inside the request's control flow.
This is the outer GHandler.
...
Another use case for this function is creating a stream of
server-sent events using GHandler actions (see
yesod-eventsource).
Most of the environment from the outer GHandler is preserved
on the inner GHandler, however:
- The request body is cleared (otherwise it would be very difficult to prevent huge memory leaks).
- The cache is cleared (see
CacheKey).
Changes to the response made inside the inner GHandler are
ignored (e.g., session variables, cookies, response headers).
This allows the inner GHandler to outlive the outer
GHandler (e.g., on the forkIO example above, a response
may be sent to the client without killing the new thread).
Arguments
| :: (SomeException -> HandlerFor site ()) | error handler |
| -> HandlerFor site () | |
| -> HandlerFor site () |
forkIO for a Handler (run an action in the background)
Uses handlerToIO, liftResourceT, and resourceForkIO
for correctness and efficiency
Since: yesod-core-1.2.8
redirect :: (MonadHandler m, RedirectUrl (HandlerSite m) url) => url -> m a #
Redirect to the given route. HTTP status code 303 for HTTP 1.1 clients and 302 for HTTP 1.0 This is the appropriate choice for a get-following-post technique, which should be the usual use case.
If you want direct control of the final status code, or need a different
status code, please use redirectWith.
redirectWith :: (MonadHandler m, RedirectUrl (HandlerSite m) url) => Status -> url -> m a #
Redirect to the given URL with the specified status code.
setUltDest :: (MonadHandler m, RedirectUrl (HandlerSite m) url) => url -> m () #
Sets the ultimate destination variable to the given route.
An ultimate destination is stored in the user session and can be loaded
later by redirectUltDest.
setUltDestCurrent :: MonadHandler m => m () #
Same as setUltDest, but uses the current page.
If this is a 404 handler, there is no current page, and then this call does nothing.
setUltDestReferer :: MonadHandler m => m () #
Sets the ultimate destination to the referer request header, if present.
This function will not overwrite an existing ultdest.
Arguments
| :: (RedirectUrl (HandlerSite m) url, MonadHandler m) | |
| => url | default destination if nothing in session |
| -> m a |
Redirect to the ultimate destination in the user's session. Clear the value from the session.
The ultimate destination is set with setUltDest.
This function uses redirect, and thus will perform a temporary redirect to
a GET request.
clearUltDest :: MonadHandler m => m () #
Remove a previously set ultimate destination. See setUltDest.
Arguments
| :: MonadHandler m | |
| => Text | status |
| -> Html | message |
| -> m () |
addMessageI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => Text -> msg -> m () #
Adds a message in the user's session but uses RenderMessage to allow for i18n
See getMessages.
Since: yesod-core-1.4.20
getMessages :: MonadHandler m => m [(Text, Html)] #
Gets all messages in the user's session, and then clears the variable.
See addMessage.
Since: yesod-core-1.4.20
setMessage :: MonadHandler m => Html -> m () #
Calls addMessage with an empty status
setMessageI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => msg -> m () #
Calls addMessageI with an empty status
getMessage :: MonadHandler m => m (Maybe Html) #
Gets just the last message in the user's session, discards the rest and the status
sendFile :: MonadHandler m => ContentType -> FilePath -> m a #
Bypass remaining handler code and output the given file.
For some backends, this is more efficient than reading in the file to memory, since they can optimize file sending via a system call to sendfile.
Arguments
| :: MonadHandler m | |
| => ContentType | |
| -> FilePath | |
| -> Integer | offset |
| -> Integer | count |
| -> m a |
Same as sendFile, but only sends part of a file.
sendResponse :: (MonadHandler m, ToTypedContent c) => c -> m a #
Bypass remaining handler code and output the given content with a 200 status code.
sendResponseStatus :: (MonadHandler m, ToTypedContent c) => Status -> c -> m a #
Bypass remaining handler code and output the given content with the given status code.
sendStatusJSON :: (MonadHandler m, ToJSON c) => Status -> c -> m a #
Bypass remaining handler code and output the given JSON with the given status code.
Since: yesod-core-1.4.18
sendResponseCreated :: MonadHandler m => Route (HandlerSite m) -> m a #
Send a 201 Created response with the given route as the Location response header.
sendWaiResponse :: MonadHandler m => Response -> m b #
Send a Response. Please note: this function is rarely
necessary, and will disregard any changes to response headers and session
that you have already specified. This function short-circuits. It should be
considered only for very specific needs. If you are not sure if you need it,
you don't.
sendWaiApplication :: MonadHandler m => Application -> m b #
Switch over to handling the current request with a WAI Application.
Since: yesod-core-1.2.17
sendRawResponseNoConduit :: (MonadHandler m, MonadUnliftIO m) => (IO ByteString -> (ByteString -> IO ()) -> m ()) -> m a #
Send a raw response without conduit. This is used for cases such as WebSockets. Requires WAI 3.0 or later, and a web server which supports raw responses (e.g., Warp).
Since: yesod-core-1.2.16
sendRawResponse :: (MonadHandler m, MonadUnliftIO m) => (ConduitT () ByteString IO () -> ConduitT ByteString Void IO () -> m ()) -> m a #
Send a raw response. This is used for cases such as WebSockets. Requires WAI 2.1 or later, and a web server which supports raw responses (e.g., Warp).
Since: yesod-core-1.2.7
notModified :: MonadHandler m => m a #
Send a 304 not modified response immediately. This is a short-circuiting action.
Since: yesod-core-1.4.4
notFound :: MonadHandler m => m a #
Return a 404 not found page. Also denotes no handler available.
badMethod :: MonadHandler m => m a #
Return a 405 method not supported page.
notAuthenticated :: MonadHandler m => m a #
Return a 401 status code
permissionDenied :: MonadHandler m => Text -> m a #
Return a 403 permission denied page.
permissionDeniedI :: (RenderMessage (HandlerSite m) msg, MonadHandler m) => msg -> m a #
Return a 403 permission denied page.
invalidArgs :: MonadHandler m => [Text] -> m a #
Return a 400 invalid arguments page.
invalidArgsI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => [msg] -> m a #
Return a 400 invalid arguments page.
setCookie :: MonadHandler m => SetCookie -> m () #
Set the cookie on the client.
Helper function for setCookieExpires value
Arguments
| :: MonadHandler m | |
| => Text | key |
| -> Text | path |
| -> m () |
Unset the cookie on the client.
Note: although the value used for key and path is Text, you should only
use ASCII values to be HTTP compliant.
setLanguage :: MonadHandler m => Text -> m () #
Set the language in the user session. Will show up in languages on the
next request.
addContentDispositionFileName :: MonadHandler m => Text -> m () #
addHeader :: MonadHandler m => Text -> Text -> m () #
Set an arbitrary response header.
Note that, while the data type used here is Text, you must provide only
ASCII value to be HTTP compliant.
Since: yesod-core-1.2.0
setHeader :: MonadHandler m => Text -> Text -> m () #
Deprecated synonym for addHeader.
replaceOrAddHeader :: MonadHandler m => Text -> Text -> m () #
Replace an existing header with a new value or add a new header if not present.
Note that, while the data type used here is Text, you must provide only
ASCII value to be HTTP compliant.
Since: yesod-core-1.4.36
cacheSeconds :: MonadHandler m => Int -> m () #
Set the Cache-Control header to indicate this response should be cached for the given number of seconds.
neverExpires :: MonadHandler m => m () #
Set the Expires header to some date in 2037. In other words, this content is never (realistically) expired.
alreadyExpired :: MonadHandler m => m () #
Set an Expires header in the past, meaning this content should not be cached.
expiresAt :: MonadHandler m => UTCTime -> m () #
Set an Expires header to the given date.
setEtag :: MonadHandler m => Text -> m () #
Check the if-none-match header and, if it matches the given value, return a 304 not modified response. Otherwise, set the etag header to the given value.
Note that it is the responsibility of the caller to ensure that the provided value is a valid etag value, no sanity checking is performed by this function.
Since: yesod-core-1.4.4
setWeakEtag :: MonadHandler m => Text -> m () #
Check the if-none-match header and, if it matches the given value, return a 304 not modified response. Otherwise, set the etag header to the given value.
A weak etag is only expected to be semantically identical to the prior content, but doesn't have to be byte-for-byte identical. Therefore it can be useful for dynamically generated content that may be difficult to perform bytewise hashing upon.
Note that it is the responsibility of the caller to ensure that the provided value is a valid etag value, no sanity checking is performed by this function.
Since: yesod-core-1.4.37
Arguments
| :: MonadHandler m | |
| => Text | key |
| -> Text | value |
| -> m () |
Set a variable in the user's session.
The session is handled by the clientsession package: it sets an encrypted and hashed cookie on the client. This ensures that all data is secure and not tampered with.
setSessionBS :: MonadHandler m => Text -> ByteString -> m () #
Same as setSession, but uses binary data for the value.
deleteSession :: MonadHandler m => Text -> m () #
Unsets a session variable. See setSession.
clearSession :: MonadHandler m => m () #
Clear all session variables.
@since: 1.0.1
lookupSession :: MonadHandler m => Text -> m (Maybe Text) #
Lookup for session data.
lookupSessionBS :: MonadHandler m => Text -> m (Maybe ByteString) #
Lookup for session data in binary format.
getSession :: MonadHandler m => m SessionMap #
Get all session variables.
newIdent :: MonadHandler m => m Text #
Get a unique identifier.
redirectToPost :: (MonadHandler m, RedirectUrl (HandlerSite m) url) => url -> m a #
Redirect to a POST resource.
This is not technically a redirect; instead, it returns an HTML page with a POST form, and some Javascript to automatically submit the form. This can be useful when you need to post a plain link somewhere that needs to cause changes on the server.
hamletToRepHtml :: MonadHandler m => HtmlUrl (Route (HandlerSite m)) -> m Html #
giveUrlRenderer :: MonadHandler m => ((Route (HandlerSite m) -> [(Text, Text)] -> Text) -> output) -> m output #
Deprecated synonym for withUrlRenderer.
Since: yesod-core-1.2.0
withUrlRenderer :: MonadHandler m => ((Route (HandlerSite m) -> [(Text, Text)] -> Text) -> output) -> m output #
Provide a URL rendering function to the given function and return the result. Useful for processing Shakespearean templates.
Since: yesod-core-1.2.20
waiRequest :: MonadHandler m => m Request #
Get the request's Request value.
getMessageRender :: (MonadHandler m, RenderMessage (HandlerSite m) message) => m (message -> Text) #
cached :: (MonadHandler m, Typeable a) => m a -> m a #
Use a per-request cache to avoid performing the same action multiple times. Values are stored by their type, the result of typeOf from Typeable. Therefore, you should use different newtype wrappers at each cache site.
For example, yesod-auth uses an un-exported newtype, CachedMaybeAuth and exports functions that utilize it such as maybeAuth. This means that another module can create its own newtype wrapper to cache the same type from a different action without any cache conflicts.
See the original announcement: http://www.yesodweb.com/blog/2013/03/yesod-1-2-cleaner-internals
Since: yesod-core-1.2.0
cachedBy :: (MonadHandler m, Typeable a) => ByteString -> m a -> m a #
a per-request cache. just like cached.
cached can only cache a single value per type.
cachedBy stores multiple values per type by usage of a ByteString key
cached is ideal to cache an action that has only one value of a type, such as the session's current user
cachedBy is required if the action has parameters and can return multiple values per type.
You can turn those parameters into a ByteString cache key.
For example, caching a lookup of a Link by a token where multiple token lookups might be performed.
Since: yesod-core-1.4.0
languages :: MonadHandler m => m [Text] #
Get the list of supported languages supplied by the user.
Languages are determined based on the following (in descending order of preference):
- The _LANG user session variable.
- The _LANG get parameter.
- The _LANG cookie.
- Accept-Language HTTP header.
Yesod will seek the first language from the returned list matched with languages supporting by your application. This language will be used to render i18n templates. If a matching language is not found the default language will be used.
This is handled by parseWaiRequest (not exposed).
lookupHeader :: MonadHandler m => CI ByteString -> m (Maybe ByteString) #
Lookup a request header.
Since: yesod-core-1.2.2
lookupHeaders :: MonadHandler m => CI ByteString -> m [ByteString] #
Lookup a request header.
Since: yesod-core-1.2.2
lookupBasicAuth :: MonadHandler m => m (Maybe (Text, Text)) #
Lookup basic authentication data from Authorization header of request. Returns user name and password
Since: yesod-core-1.4.9
lookupBearerAuth :: MonadHandler m => m (Maybe Text) #
Lookup bearer authentication datafrom Authorization header of request. Returns bearer token value
Since: yesod-core-1.4.9
lookupGetParams :: MonadHandler m => Text -> m [Text] #
Lookup for GET parameters.
lookupGetParam :: MonadHandler m => Text -> m (Maybe Text) #
Lookup for GET parameters.
lookupPostParams :: (MonadResource m, MonadHandler m) => Text -> m [Text] #
Lookup for POST parameters.
lookupPostParam :: (MonadResource m, MonadHandler m) => Text -> m (Maybe Text) #
lookupFile :: MonadHandler m => Text -> m (Maybe FileInfo) #
Lookup for POSTed files.
lookupFiles :: MonadHandler m => Text -> m [FileInfo] #
Lookup for POSTed files.
lookupCookie :: MonadHandler m => Text -> m (Maybe Text) #
Lookup for cookie data.
lookupCookies :: MonadHandler m => Text -> m [Text] #
Lookup for cookie data.
selectRep :: MonadHandler m => Writer (Endo [ProvidedRep m]) () -> m TypedContent #
Select a representation to send to the client based on the representations
provided inside this do-block. Should be used together with provideRep.
Since: yesod-core-1.2.0
provideRep :: (Monad m, HasContentType a) => m a -> Writer (Endo [ProvidedRep m]) () #
Provide a single representation to be used, based on the request of the
client. Should be used together with selectRep.
Since: yesod-core-1.2.0
provideRepType :: (Monad m, ToContent a) => ContentType -> m a -> Writer (Endo [ProvidedRep m]) () #
Same as provideRep, but instead of determining the content type from the
type of the value itself, you provide the content type separately. This can
be a convenience instead of creating newtype wrappers for uncommonly used
content types.
provideRepType "application/x-special-format" "This is the content"
Since: yesod-core-1.2.0
rawRequestBody :: MonadHandler m => ConduitT i ByteString m () #
Stream in the raw request body without any parsing.
Since: yesod-core-1.2.0
fileSource :: MonadResource m => FileInfo -> ConduitT () ByteString m () #
Stream the data from the file. Since Yesod 1.2, this has been generalized
to work in any MonadResource.
fileSourceByteString :: MonadResource m => FileInfo -> m ByteString #
Extract a strict ByteString body from a FileInfo.
This function will block while reading the file.
do
fileByteString <- fileSourceByteString fileInfoSince: yesod-core-1.6.5
respond :: (Monad m, ToContent a) => ContentType -> a -> m TypedContent #
Provide a pure value for the response body.
respond ct = return . TypedContent ct . toContent
Since: yesod-core-1.2.0
respondSource :: ContentType -> ConduitT () (Flush Builder) (HandlerFor site) () -> HandlerFor site TypedContent #
Use a Source for the response body.
Note that, for ease of use, the underlying monad is a HandlerT. This
implies that you can run any HandlerT action. However, since a streaming
response occurs after the response headers have already been sent, some
actions make no sense here. For example: short-circuit responses, setting
headers, changing status codes, etc.
Since: yesod-core-1.2.0
sendChunk :: (Monad m, ToFlushBuilder a) => a -> ConduitT i (Flush Builder) m () #
In a streaming response, send a single chunk of data. This function works
on most datatypes, such as ByteString and Html.
Since: yesod-core-1.2.0
sendFlush :: Monad m => ConduitT i (Flush Builder) m () #
In a streaming response, send a flush command, causing all buffered data to be immediately sent to the client.
Since: yesod-core-1.2.0
sendChunkBS :: Monad m => ByteString -> ConduitT i (Flush Builder) m () #
Type-specialized version of sendChunk for strict ByteStrings.
Since: yesod-core-1.2.0
sendChunkLBS :: Monad m => ByteString -> ConduitT i (Flush Builder) m () #
Type-specialized version of sendChunk for lazy ByteStrings.
Since: yesod-core-1.2.0
sendChunkText :: Monad m => Text -> ConduitT i (Flush Builder) m () #
Type-specialized version of sendChunk for strict Texts.
Since: yesod-core-1.2.0
sendChunkLazyText :: Monad m => Text -> ConduitT i (Flush Builder) m () #
Type-specialized version of sendChunk for lazy Texts.
Since: yesod-core-1.2.0
sendChunkHtml :: Monad m => Html -> ConduitT i (Flush Builder) m () #
Type-specialized version of sendChunk for Htmls.
Since: yesod-core-1.2.0
defaultCsrfCookieName :: ByteString #
The default cookie name for the CSRF token ("XSRF-TOKEN").
Since: yesod-core-1.4.14
setCsrfCookie :: MonadHandler m => m () #
Sets a cookie with a CSRF token, using defaultCsrfCookieName for the cookie name.
The cookie's path is set to /, making it valid for your whole website.
Since: yesod-core-1.4.14
setCsrfCookieWithCookie :: MonadHandler m => SetCookie -> m () #
Takes a SetCookie and overrides its value with a CSRF token, then sets the cookie.
Make sure to set the setCookiePath to the root path of your application, otherwise you'll generate a new CSRF token for every path of your app. If your app is run from from e.g. www.example.com/app1, use app1. The vast majority of sites will just use /.
Since: yesod-core-1.4.14
defaultCsrfHeaderName :: CI ByteString #
The default header name for the CSRF token ("X-XSRF-TOKEN").
Since: yesod-core-1.4.14
checkCsrfHeaderNamed :: MonadHandler m => CI ByteString -> m () #
Takes a header name to lookup a CSRF token. If the value doesn't match the token stored in the session,
this function throws a PermissionDenied error.
Since: yesod-core-1.4.14
hasValidCsrfHeaderNamed :: MonadHandler m => CI ByteString -> m Bool #
Takes a header name to lookup a CSRF token, and returns whether the value matches the token stored in the session.
Since: yesod-core-1.4.14
defaultCsrfParamName :: Text #
The default parameter name for the CSRF token ("_token")
Since: yesod-core-1.4.14
checkCsrfParamNamed :: MonadHandler m => Text -> m () #
Takes a POST parameter name to lookup a CSRF token. If the value doesn't match the token stored in the session,
this function throws a PermissionDenied error.
Since: yesod-core-1.4.14
hasValidCsrfParamNamed :: MonadHandler m => Text -> m Bool #
Takes a POST parameter name to lookup a CSRF token, and returns whether the value matches the token stored in the session.
Since: yesod-core-1.4.14
Arguments
| :: (MonadHandler m, MonadLogger m) | |
| => CI ByteString | The header name to lookup the CSRF token |
| -> Text | The POST parameter name to lookup the CSRF token |
| -> m () |
Checks that a valid CSRF token is present in either the request headers or POST parameters.
If the value doesn't match the token stored in the session, this function throws a PermissionDenied error.
Since: yesod-core-1.4.14
getSubYesod :: MonadHandler m => m (SubHandlerSite m) #
getRouteToParent :: MonadHandler m => m (Route (SubHandlerSite m) -> Route (HandlerSite m)) #
getSubCurrentRoute :: MonadHandler m => m (Maybe (Route (SubHandlerSite m))) #
class ToWidgetHead site a where #
Minimal complete definition
Methods
toWidgetHead :: (MonadWidget m, HandlerSite m ~ site) => a -> m () #
Instances
| ToWidgetHead site Html | |
Defined in Yesod.Core.Widget Methods toWidgetHead :: (MonadWidget m, HandlerSite m ~ site) => Html -> m () # | |
| ToWidgetHead site Javascript | |
Defined in Yesod.Core.Widget Methods toWidgetHead :: (MonadWidget m, HandlerSite m ~ site) => Javascript -> m () # | |
| ToWidgetHead site CssBuilder | |
Defined in Yesod.Core.Widget Methods toWidgetHead :: (MonadWidget m, HandlerSite m ~ site) => CssBuilder -> m () # | |
| ToWidgetHead site Css | |
Defined in Yesod.Core.Widget Methods toWidgetHead :: (MonadWidget m, HandlerSite m ~ site) => Css -> m () # | |
| render ~ RY site => ToWidgetHead site (render -> Html) | |
Defined in Yesod.Core.Widget Methods toWidgetHead :: (MonadWidget m, HandlerSite m ~ site) => (render -> Html) -> m () # | |
| render ~ RY site => ToWidgetHead site (render -> Css) | |
Defined in Yesod.Core.Widget Methods toWidgetHead :: (MonadWidget m, HandlerSite m ~ site) => (render -> Css) -> m () # | |
| render ~ RY site => ToWidgetHead site (render -> CssBuilder) | |
Defined in Yesod.Core.Widget Methods toWidgetHead :: (MonadWidget m, HandlerSite m ~ site) => (render -> CssBuilder) -> m () # | |
| render ~ RY site => ToWidgetHead site (render -> Javascript) | |
Defined in Yesod.Core.Widget Methods toWidgetHead :: (MonadWidget m, HandlerSite m ~ site) => (render -> Javascript) -> m () # | |
class ToWidgetBody site a where #
Minimal complete definition
Methods
toWidgetBody :: (MonadWidget m, HandlerSite m ~ site) => a -> m () #
Instances
| ToWidgetBody site Html | |
Defined in Yesod.Core.Widget Methods toWidgetBody :: (MonadWidget m, HandlerSite m ~ site) => Html -> m () # | |
| ToWidgetBody site Javascript | |
Defined in Yesod.Core.Widget Methods toWidgetBody :: (MonadWidget m, HandlerSite m ~ site) => Javascript -> m () # | |
| render ~ RY site => ToWidgetBody site (render -> Html) | |
Defined in Yesod.Core.Widget Methods toWidgetBody :: (MonadWidget m, HandlerSite m ~ site) => (render -> Html) -> m () # | |
| render ~ RY site => ToWidgetBody site (render -> Javascript) | |
Defined in Yesod.Core.Widget Methods toWidgetBody :: (MonadWidget m, HandlerSite m ~ site) => (render -> Javascript) -> m () # | |
class ToWidgetMedia site a where #
Allows adding some CSS to the page with a specific media type.
Since 1.2
Minimal complete definition
Methods
Arguments
| :: (MonadWidget m, HandlerSite m ~ site) | |
| => Text | media value |
| -> a | |
| -> m () |
Add the given content to the page, but only for the given media type.
Since 1.2
Instances
| ToWidgetMedia site CssBuilder | |
Defined in Yesod.Core.Widget Methods toWidgetMedia :: (MonadWidget m, HandlerSite m ~ site) => Text -> CssBuilder -> m () # | |
| ToWidgetMedia site Css | |
Defined in Yesod.Core.Widget Methods toWidgetMedia :: (MonadWidget m, HandlerSite m ~ site) => Text -> Css -> m () # | |
| render ~ RY site => ToWidgetMedia site (render -> Css) | |
Defined in Yesod.Core.Widget Methods toWidgetMedia :: (MonadWidget m, HandlerSite m ~ site) => Text -> (render -> Css) -> m () # | |
| render ~ RY site => ToWidgetMedia site (render -> CssBuilder) | |
Defined in Yesod.Core.Widget Methods toWidgetMedia :: (MonadWidget m, HandlerSite m ~ site) => Text -> (render -> CssBuilder) -> m () # | |
Minimal complete definition
Methods
toWidget :: (MonadWidget m, HandlerSite m ~ site) => a -> m () #
Instances
| ToWidget site Html | |
Defined in Yesod.Core.Widget Methods toWidget :: (MonadWidget m, HandlerSite m ~ site) => Html -> m () # | |
| ToWidget site Text | Since: yesod-core-1.4.28 |
Defined in Yesod.Core.Widget Methods toWidget :: (MonadWidget m, HandlerSite m ~ site) => Text -> m () # | |
| ToWidget site Text | Since: yesod-core-1.4.28 |
Defined in Yesod.Core.Widget Methods toWidget :: (MonadWidget m, HandlerSite m ~ site) => Text -> m () # | |
| ToWidget site Javascript | |
Defined in Yesod.Core.Widget Methods toWidget :: (MonadWidget m, HandlerSite m ~ site) => Javascript -> m () # | |
| ToWidget site CssBuilder | |
Defined in Yesod.Core.Widget Methods toWidget :: (MonadWidget m, HandlerSite m ~ site) => CssBuilder -> m () # | |
| ToWidget site Css | |
Defined in Yesod.Core.Widget Methods toWidget :: (MonadWidget m, HandlerSite m ~ site) => Css -> m () # | |
| ToWidget site Builder | Since: yesod-core-1.4.28 |
Defined in Yesod.Core.Widget Methods toWidget :: (MonadWidget m, HandlerSite m ~ site) => Builder -> m () # | |
| (site' ~ site, a ~ ()) => ToWidget site' (WidgetFor site a) | |
Defined in Yesod.Core.Widget Methods toWidget :: (MonadWidget m, HandlerSite m ~ site') => WidgetFor site a -> m () # | |
| render ~ RY site => ToWidget site (render -> Html) | |
Defined in Yesod.Core.Widget Methods toWidget :: (MonadWidget m, HandlerSite m ~ site) => (render -> Html) -> m () # | |
| render ~ RY site => ToWidget site (render -> Css) | |
Defined in Yesod.Core.Widget Methods toWidget :: (MonadWidget m, HandlerSite m ~ site) => (render -> Css) -> m () # | |
| render ~ RY site => ToWidget site (render -> CssBuilder) | |
Defined in Yesod.Core.Widget Methods toWidget :: (MonadWidget m, HandlerSite m ~ site) => (render -> CssBuilder) -> m () # | |
| render ~ RY site => ToWidget site (render -> Javascript) | |
Defined in Yesod.Core.Widget Methods toWidget :: (MonadWidget m, HandlerSite m ~ site) => (render -> Javascript) -> m () # | |
setTitle :: MonadWidget m => Html -> m () #
Set the page title. Calling setTitle multiple times overrides previously
set values.
setTitleI :: (MonadWidget m, RenderMessage (HandlerSite m) msg) => msg -> m () #
Set the page title. Calling setTitle multiple times overrides previously
set values.
addStylesheet :: MonadWidget m => Route (HandlerSite m) -> m () #
Link to the specified local stylesheet.
addStylesheetAttrs :: MonadWidget m => Route (HandlerSite m) -> [(Text, Text)] -> m () #
Link to the specified local stylesheet.
addStylesheetRemote :: MonadWidget m => Text -> m () #
Link to the specified remote stylesheet.
addStylesheetRemoteAttrs :: MonadWidget m => Text -> [(Text, Text)] -> m () #
Link to the specified remote stylesheet.
addStylesheetEither :: MonadWidget m => Either (Route (HandlerSite m)) Text -> m () #
addScriptEither :: MonadWidget m => Either (Route (HandlerSite m)) Text -> m () #
addScript :: MonadWidget m => Route (HandlerSite m) -> m () #
Link to the specified local script.
addScriptAttrs :: MonadWidget m => Route (HandlerSite m) -> [(Text, Text)] -> m () #
Link to the specified local script.
addScriptRemote :: MonadWidget m => Text -> m () #
Link to the specified remote script.
addScriptRemoteAttrs :: MonadWidget m => Text -> [(Text, Text)] -> m () #
Link to the specified remote script.
whamlet :: QuasiQuoter #
whamletFile :: FilePath -> Q Exp #
whamletFileWithSettings :: HamletSettings -> FilePath -> Q Exp #
ihamletToRepHtml :: (MonadHandler m, RenderMessage (HandlerSite m) message) => HtmlUrlI18n message (Route (HandlerSite m)) -> m Html #
ihamletToHtml :: (MonadHandler m, RenderMessage (HandlerSite m) message) => HtmlUrlI18n message (Route (HandlerSite m)) -> m Html #
handlerToWidget :: HandlerFor site a -> WidgetFor site a #
class RenderRoute site => Yesod site where #
Define settings for a Yesod applications. All methods have intelligent defaults, and therefore no implementation is required.
Methods
An absolute URL to the root of the application. Do not include trailing slash.
Default value: guessApproot. If you know your application root
statically, it will be more efficient and more reliable to instead use
ApprootStatic or ApprootMaster. If you do not need full absolute
URLs, you can use ApprootRelative instead.
Note: Prior to yesod-core 1.5, the default value was ApprootRelative.
errorHandler :: ErrorResponse -> HandlerFor site TypedContent #
Output error response pages.
Default value: defaultErrorHandler.
defaultLayout :: WidgetFor site () -> HandlerFor site Html #
Applies some form of layout to the contents of a page.
Override the rendering function for a particular URL and query string parameters. One use case for this is to offload static hosting to a different domain name to avoid sending cookies.
For backward compatibility default implementation is in terms of
urlRenderOverride, probably ineffective
Since 1.4.23
Arguments
| :: Route site | |
| -> Bool | is this a write request? |
| -> HandlerFor site AuthResult |
Determine if a request is authorized or not.
Return Authorized if the request is authorized,
Unauthorized a message if unauthorized.
If authentication is required, return AuthenticationRequired.
isWriteRequest :: Route site -> HandlerFor site Bool #
Determines whether the current request is a write request. By default, this assumes you are following RESTful principles, and determines this from request method. In particular, all except the following request methods are considered write: GET HEAD OPTIONS TRACE.
This function is used to determine if a request is authorized; see
isAuthorized.
authRoute :: site -> Maybe (Route site) #
The default route for authentication.
Used in particular by isAuthorized, but library users can do whatever
they want with it.
cleanPath :: site -> [Text] -> Either [Text] [Text] #
A function used to clean up path segments. It returns Right with a
clean path or Left with a new set of pieces the user should be
redirected to. The default implementation enforces:
- No double slashes
- There is no trailing slash.
Note that versions of Yesod prior to 0.7 used a different set of rules involing trailing slashes.
Builds an absolute URL by concatenating the application root with the
pieces of a path and a query string, if any.
Note that the pieces of the path have been previously cleaned up by cleanPath.
Arguments
| :: Text | filename extension |
| -> Text | mime-type |
| -> ByteString | content |
| -> HandlerFor site (Maybe (Either Text (Route site, [(Text, Text)]))) |
This function is used to store some static content to be served as an external file. The most common case of this is stashing CSS and JavaScript content in an external file; the Yesod.Widget module uses this feature.
The return value is Nothing if no storing was performed; this is the
default implementation. A Just Left gives the absolute URL of the
file, whereas a Just Right gives the type-safe URL. The former is
necessary when you are serving the content outside the context of a
Yesod application, such as via memcached.
maximumContentLength :: site -> Maybe (Route site) -> Maybe Word64 #
Maximum allowed length of the request body, in bytes.
If Nothing, no maximum is applied.
Default: 2 megabytes.
makeLogger :: site -> IO Logger #
Creates a Logger to use for log messages.
Note that a common technique (endorsed by the scaffolding) is to create
a Logger value and place it in your foundation datatype, and have this
method return that already created value. That way, you can use that
same Logger for printing messages during app initialization.
Default: the defaultMakeLogger function.
Arguments
| :: site | |
| -> Logger | |
| -> Loc | position in source code |
| -> LogSource | |
| -> LogLevel | |
| -> LogStr | message |
| -> IO () |
Send a message to the Logger provided by getLogger.
Default: the defaultMessageLoggerSource function, using
shouldLogIO to check whether we should log.
jsLoader :: site -> ScriptLoadPosition site #
Where to Load sripts from. We recommend the default value,
BottomOfBody.
jsAttributes :: site -> [(Text, Text)] #
Default attributes to put on the JavaScript script tag generated for julius files
makeSessionBackend :: site -> IO (Maybe SessionBackend) #
Create a session backend. Returning Nothing disables
sessions. If you'd like to change the way that the session
cookies are created, take a look at
customizeSessionCookies.
Default: Uses clientsession with a 2 hour timeout.
fileUpload :: site -> RequestBodyLength -> FileUpload #
How to store uploaded files.
Default: When the request body is greater than 50kb, store in a temp file. For chunked request bodies, store in a temp file. Otherwise, store in memory.
shouldLogIO :: site -> LogSource -> LogLevel -> IO Bool #
Should we log the given log source/level combination.
Default: the defaultShouldLogIO function.
Since 1.2.4
yesodMiddleware :: ToTypedContent res => HandlerFor site res -> HandlerFor site res #
A Yesod middleware, which will wrap every handler function. This allows you to run code before and after a normal handler.
Default: the defaultYesodMiddleware function.
Since: 1.1.6
yesodWithInternalState :: site -> Maybe (Route site) -> (InternalState -> IO a) -> IO a #
How to allocate an InternalState for each request.
The default implementation is almost always what you want. However, if
you know that you are never taking advantage of the MonadResource
instance in your handler functions, setting this to a dummy
implementation can provide a small optimization. Only do this if you
really know what you're doing, otherwise you can turn safe code into a
runtime error!
Since 1.4.2
defaultMessageWidget :: Html -> HtmlUrl (Route site) -> WidgetFor site () #
Convert a title and HTML snippet into a Widget. Used
primarily for wrapping up error messages for better display.
Since: yesod-core-1.4.30
Instances
defaultMakeLogger :: IO Logger #
Default implementation of makeLogger. Sends to stdout and
automatically flushes on each write.
Since 1.4.10
Arguments
| :: (LogSource -> LogLevel -> IO Bool) | Check whether we should log this |
| -> Logger | |
| -> Loc | position in source code |
| -> LogSource | |
| -> LogLevel | |
| -> LogStr | message |
| -> IO () |
Default implementation of messageLoggerSource. Checks if the
message should be logged using the provided function, and if so,
formats using formatLogMessage. You can use defaultShouldLogIO
as the provided function.
Since 1.4.10
defaultShouldLogIO :: LogSource -> LogLevel -> IO Bool #
Default implementation of shouldLog. Logs everything at or
above LevelInfo.
Since 1.4.10
defaultYesodMiddleware :: Yesod site => HandlerFor site res -> HandlerFor site res #
Default implementation of yesodMiddleware. Adds the response header
"Vary: Accept, Accept-Language" and performs authorization checks.
Since 1.2.0
sslOnlySessions :: IO (Maybe SessionBackend) -> IO (Maybe SessionBackend) #
Defends against session hijacking by setting the secure bit on session
cookies so that browsers will not transmit them over http. With this
setting on, it follows that the server will regard requests made over
http as sessionless, because the session cookie will not be included in
the request. Use this as part of a total security measure which also
includes disabling HTTP traffic to the site or issuing redirects from
HTTP urls, and composing sslOnlyMiddleware with the site's
yesodMiddleware.
Since 1.4.7
laxSameSiteSessions :: IO (Maybe SessionBackend) -> IO (Maybe SessionBackend) #
Helps defend against CSRF attacks by setting the SameSite attribute on session cookies to Lax. With the Lax setting, the cookie will be sent with same-site requests, and with cross-site top-level navigations.
This option is liable to change in future versions of Yesod as the spec evolves. View more information here.
Since: yesod-core-1.4.23
strictSameSiteSessions :: IO (Maybe SessionBackend) -> IO (Maybe SessionBackend) #
Helps defend against CSRF attacks by setting the SameSite attribute on session cookies to Strict. With the Strict setting, the cookie will only be sent with same-site requests.
This option is liable to change in future versions of Yesod as the spec evolves. View more information here.
Since: yesod-core-1.4.23
Arguments
| :: Int | minutes |
| -> HandlerFor site res | |
| -> HandlerFor site res |
Apply a Strict-Transport-Security header with the specified timeout to all responses so that browsers will rewrite all http links to https until the timeout expires. For security, the max-age of the STS header should always equal or exceed the client sessions timeout. This defends against SSL-stripping man-in-the-middle attacks. It is only effective if a secure connection has already been made; Strict-Transport-Security headers are ignored over HTTP.
Since 1.4.7
authorizationCheck :: Yesod site => HandlerFor site () #
Check if a given request is authorized via isAuthorized and
isWriteRequest.
Since 1.2.0
defaultCsrfCheckMiddleware :: Yesod site => HandlerFor site res -> HandlerFor site res #
Calls csrfCheckMiddleware with isWriteRequest, defaultCsrfHeaderName, and defaultCsrfParamName as parameters.
Since 1.4.14
Arguments
| :: HandlerFor site res | |
| -> HandlerFor site Bool | Whether or not to perform the CSRF check. |
| -> CI ByteString | The header name to lookup the CSRF token from. |
| -> Text | The POST parameter name to lookup the CSRF token from. |
| -> HandlerFor site res |
Looks up the CSRF token from the request headers or POST parameters. If the value doesn't match the token stored in the session,
this function throws a PermissionDenied error.
For details, see the "AJAX CSRF protection" section of Yesod.Core.Handler.
Since 1.4.14
defaultCsrfSetCookieMiddleware :: HandlerFor site res -> HandlerFor site res #
Calls csrfSetCookieMiddleware with the defaultCsrfCookieName.
The cookie's path is set to /, making it valid for your whole website.
Since 1.4.14
csrfSetCookieMiddleware :: HandlerFor site res -> SetCookie -> HandlerFor site res #
Takes a SetCookie and overrides its value with a CSRF token, then sets the cookie. See setCsrfCookieWithCookie.
For details, see the "AJAX CSRF protection" section of Yesod.Core.Handler.
Make sure to set the setCookiePath to the root path of your application, otherwise you'll generate a new CSRF token for every path of your app. If your app is run from from e.g. www.example.com/app1, use app1. The vast majority of sites will just use /.
Since 1.4.14
defaultCsrfMiddleware :: Yesod site => HandlerFor site res -> HandlerFor site res #
Calls defaultCsrfSetCookieMiddleware and defaultCsrfCheckMiddleware.
For details, see the "AJAX CSRF protection" section of Yesod.Core.Handler.
You can chain this middleware together with other middleware like so:
yesodMiddleware=defaultYesodMiddleware.defaultCsrfMiddleware
or:
yesodMiddlewareapp =defaultYesodMiddleware$defaultCsrfMiddleware$ app
Since 1.4.14
widgetToPageContent :: Yesod site => WidgetFor site () -> HandlerFor site (PageContent (Route site)) #
Convert a widget to a PageContent.
defaultErrorHandler :: Yesod site => ErrorResponse -> HandlerFor site TypedContent #
The default error handler for errorHandler.
Default formatting for log messages. When you use
the template haskell logging functions for to log with information
about the source location, that information will be appended to
the end of the log. When you use the non-TH logging functions,
like logDebugN, this function does not include source
information. This currently works by checking to see if the
package name is the string "<unknown>". This is a hack,
but it removes some of the visual clutter from non-TH logs.
Since 1.4.10
customizeSessionCookies :: (SetCookie -> SetCookie) -> SessionBackend -> SessionBackend #
Customize the cookies used by the session backend. You may
use this function on your definition of makeSessionBackend.
For example, you could set the cookie domain so that it would work across many subdomains:
makeSessionBackend site =
(fmap . fmap) (customizeSessionCookies addDomain) ...
where
addDomain cookie = cookie { setCookieDomain = Just ".example.com" }
Default: Do not customize anything (id).
Arguments
| :: Int | minutes |
| -> FilePath | key file |
| -> IO SessionBackend |
Arguments
| :: Int | minutes |
| -> String | environment variable name |
| -> IO SessionBackend |
Create a SessionBackend which reads the session key from the named
environment variable.
This can be useful if:
- You can't rely on a persistent file system (e.g. Heroku)
- Your application is open source (e.g. you can't commit the key)
By keeping a consistent value in the environment variable, your users will have consistent sessions without relying on the file system.
Note: A suitable value should only be obtained in one of two ways:
- Run this code without the variable set, a value will be generated and
printed on
devstdout/ - Use
clientsession-generate
Since 1.4.5
Arguments
| :: Key | The encryption key |
| -> IO ClientSessionDateCache | |
| -> SessionBackend |
Arguments
| :: Key | |
| -> IO ClientSessionDateCache | |
| -> ByteString | session name |
| -> Request | |
| -> IO (SessionMap, SaveSession) |
guessApproot :: Approot site #
Guess the approot based on request headers. For more information, see Network.Wai.Middleware.Approot
In the case of headers being unavailable, it falls back to ApprootRelative
Since 1.4.16
guessApprootOr :: Approot site -> Approot site #
Guess the approot based on request headers, with fall back to the
specified AppRoot.
Since 1.4.16
getApprootText :: Approot site -> site -> Request -> Text #
Get the textual application root from an Approot value.
Since 1.4.17
Arguments
| :: (Yesod site, ToJSON a) | |
| => WidgetFor site () | HTML |
| -> HandlerFor site a | JSON |
| -> HandlerFor site TypedContent |
Provide both an HTML and JSON representation for a piece of
data, using the default layout for the HTML output
(defaultLayout).
Since: yesod-core-0.3.0
jsonToRepJson :: (Monad m, ToJSON a) => a -> m Value #
Wraps a data type in a RepJson. The data type must
support conversion to JSON via ToJSON.
Since: yesod-core-0.3.0
returnJson :: (Monad m, ToJSON a) => a -> m Value #
Convert a value to a JSON representation via aeson's toJSON function.
Since: yesod-core-1.2.1
returnJsonEncoding :: (Monad m, ToJSON a) => a -> m Encoding #
Convert a value to a JSON representation via aeson's toEncoding function.
Since: yesod-core-1.4.21
provideJson :: (Monad m, ToJSON a) => a -> Writer (Endo [ProvidedRep m]) () #
Provide a JSON representation for usage with selectReps, using aeson's
toJSON (aeson >= 0.11: toEncoding) function to perform the conversion.
Since: yesod-core-1.2.1
parseJsonBody :: (MonadHandler m, FromJSON a) => m (Result a) #
Parse the request body to a data type as a JSON value. The
data type must support conversion from JSON via FromJSON.
If you want the raw JSON value, just ask for a Result
Value
Note that this function will consume the request body. As such, calling it twice will result in a parse error on the second call, since the request body will no longer be available.
Since: yesod-core-0.3.0
parseCheckJsonBody :: (MonadHandler m, FromJSON a) => m (Result a) #
Same as parseJsonBody, but ensures that the mime type indicates
JSON content.
parseJsonBody_ :: (MonadHandler m, FromJSON a) => m a #
Same as parseJsonBody, but return an invalid args response on a parse
error.
requireJsonBody :: (MonadHandler m, FromJSON a) => m a #
Same as parseJsonBody, but return an invalid args response on a parse
error.
requireCheckJsonBody :: (MonadHandler m, FromJSON a) => m a #
Same as requireJsonBody, but ensures that the mime type
indicates JSON content.
Arguments
| :: (MonadHandler m, ToJSON a) | |
| => Route (HandlerSite m) | Redirect target |
| -> a | Data to send via JSON |
| -> m Value |
jsonOrRedirect simplifies the scenario where a POST handler sends a different response based on Accept headers:
- 200 with JSON data if the client prefers
application/json(e.g. AJAX, seeacceptsJSON). - 3xx otherwise, following the PRG pattern.
Arguments
| :: (MonadHandler m, ToJSON a) | |
| => Route (HandlerSite m) | Redirect target |
| -> a | Data to send via JSON |
| -> m Encoding |
jsonEncodingOrRedirect simplifies the scenario where a POST handler sends a different response based on Accept headers:
- 200 with JSON data if the client prefers
application/json(e.g. AJAX, seeacceptsJSON). - 3xx otherwise, following the PRG pattern. @since 1.4.21
acceptsJson :: MonadHandler m => m Bool #
Returns True if the client prefers application/json as
indicated by the Accept HTTP header.
yesodRunner :: (ToTypedContent res, Yesod site) => HandlerFor site res -> YesodRunnerEnv site -> Maybe (Route site) -> Application #
class YesodSubDispatch sub master where #
Minimal complete definition
Methods
yesodSubDispatch :: YesodSubRunnerEnv sub master -> Application #
Instances
| YesodSubDispatch WaiSubsiteWithAuth master | |
Defined in Yesod.Core.Class.Dispatch Methods yesodSubDispatch :: YesodSubRunnerEnv WaiSubsiteWithAuth master -> Application # | |
| YesodSubDispatch WaiSubsite master | |
Defined in Yesod.Core.Class.Dispatch Methods yesodSubDispatch :: YesodSubRunnerEnv WaiSubsite master -> Application # | |
| YesodSubDispatch Static master | |
Defined in Yesod.Static Methods yesodSubDispatch :: YesodSubRunnerEnv Static master -> Application # | |
class Yesod site => YesodDispatch site where #
This class is automatically instantiated when you use the template haskell mkYesod function. You should never need to deal with it directly.
Minimal complete definition
Methods
yesodDispatch :: YesodRunnerEnv site -> Application #
Instances
| YesodDispatch LiteApp | |
Defined in Yesod.Core.Internal.LiteApp Methods | |
| YesodDispatch App # | |
Defined in Hledger.Web.Application Methods | |
type LiteWidget = WidgetFor LiteApp #
type LiteHandler = HandlerFor LiteApp #
Constructors
| LiteApp | |
Fields
| |
Instances
dispatchTo :: ToTypedContent a => LiteHandler a -> Writer LiteApp () #
withDynamicMulti :: PathMultiPiece ps => (ps -> Writer LiteApp ()) -> Writer LiteApp () #
class YesodBreadcrumbs site where #
A type-safe, concise method of creating breadcrumbs for pages. For each resource, you declare the title of the page and the parent resource (if present).
Minimal complete definition
Methods
breadcrumb :: Route site -> HandlerFor site (Text, Maybe (Route site)) #
Returns the title and the parent resource, if available. If you return
a Nothing, then this is considered a top-level page.
breadcrumbs :: YesodBreadcrumbs site => HandlerFor site (Text, [(Route site, Text)]) #
Gets the title of the current page and the hierarchy of parent pages, along with their respective titles.
A quasi-quoter to parse a string into a list of Resources. Checks for
overlapping routes, failing if present; use parseRoutesNoCheck to skip the
checking. See documentation site for details on syntax.
parseRoutesFile :: FilePath -> Q Exp #
parseRoutesFileNoCheck :: FilePath -> Q Exp #
parseRoutesNoCheck :: QuasiQuoter #
Same as parseRoutes, but performs no overlap checking.
Arguments
| :: String | name of the argument datatype |
| -> [ResourceTree String] | |
| -> Q [Dec] |
Generates URL datatype and site function for the given Resources. This
is used for creating sites, not subsites. See mkYesodSubData and mkYesodSubDispatch for the latter.
Use parseRoutes to create the Resources.
Contexts and type variables in the name of the datatype are parsed.
For example, a datatype App a with typeclass constraint MyClass a can be written as "(MyClass a) => App a".
Arguments
| :: [[String]] | list of contexts |
| -> String | name of the argument datatype |
| -> [String] | list of type variables |
| -> [ResourceTree String] | |
| -> Q [Dec] |
Similar to mkYesod, except contexts and type variables are not parsed.
Instead, they are explicitly provided.
You can write (MyClass a) => App a with mkYesodWith [["MyClass","a"]] "App" ["a"] ....
mkYesodData :: String -> [ResourceTree String] -> Q [Dec] #
Sometimes, you will want to declare your routes in one file and define
your handlers elsewhere. For example, this is the only way to break up a
monolithic file into smaller parts. Use this function, paired with
mkYesodDispatch, to do just that.
mkYesodSubData :: String -> [ResourceTree String] -> Q [Dec] #
mkYesodDispatch :: String -> [ResourceTree String] -> Q [Dec] #
See mkYesodData.
mkYesodSubDispatch :: [ResourceTree a] -> Q Exp #
toWaiAppPlain :: YesodDispatch site => site -> IO Application #
Convert the given argument into a WAI application, executable with any WAI
handler. This function will provide no middlewares; if you want commonly
used middlewares, please use toWaiApp.
toWaiAppYre :: YesodDispatch site => YesodRunnerEnv site -> Application #
Pure low level function to construct WAI application. Usefull when you need not standard way to run your app, or want to embed it inside another app.
Since: yesod-core-1.4.29
toWaiApp :: YesodDispatch site => site -> IO Application #
Same as toWaiAppPlain, but provides a default set of middlewares. This
set may change with future releases, but currently covers:
- Logging
- GZIP compression
- Automatic HEAD method handling
- Request method override with the _method query string parameter
- Accept header override with the _accept query string parameter
warp :: YesodDispatch site => Int -> site -> IO () #
A convenience method to run an application using the Warp webserver on the
specified port. Automatically calls toWaiApp. Provides a default set of
middlewares. This set may change at any point without a breaking version
number. Currently, it includes:
If you need more fine-grained control of middlewares, please use toWaiApp
directly.
Since 1.2.0
mkDefaultMiddlewares :: Logger -> IO Middleware #
A default set of middlewares.
Since 1.2.0
defaultMiddlewaresNoLogging :: Middleware #
All of the default middlewares, excluding logging.
Since 1.2.12
warpEnv :: YesodDispatch site => site -> IO () #
Runs your application using default middlewares (i.e., via toWaiApp). It
reads port information from the PORT environment variable, as used by tools
such as Keter and the FP Complete School of Haskell.
Note that the exact behavior of this function may be modified slightly over time to work correctly with external tools, without a change to the type signature.
getGetMaxExpires :: IO (IO Text) #
Default constructor for yreGetMaxExpires field. Low level
function for simple manual construction of YesodRunnerEnv.
Since: yesod-core-1.4.29
runFakeHandler :: (Yesod site, MonadIO m) => SessionMap -> (site -> Logger) -> site -> HandlerT site IO a -> m (Either ErrorResponse a) #
unauthorizedI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => msg -> m AuthResult #
Return an Unauthorized value, with the given i18n message.
yesodVersion :: String #
Arguments
| :: Yesod site | |
| => Route site | |
| -> Bool | is this a write request? |
| -> HandlerT site IO (Maybe (Route site)) |
Return the same URL if the user is authorized to see it.
Built on top of isAuthorized. This is useful for building page that only
contain links to pages the user is allowed to see.
showIntegral :: Integral a => a -> String #
readIntegral :: Num a => String -> Maybe a #
Constructors
| Extra | |
Fields
| |
development :: Bool Source #
production :: Bool Source #
hledgerorgurl :: Text Source #
staticDir :: FilePath Source #
The location of static files on your system. This is a file system path. The default value works properly with your scaffolded site.
staticRoot :: AppConfig DefaultEnv Extra -> Text Source #
The base URL for your static files. As you can see by the default value, this can simply be "static" appended to your application root. A powerful optimization can be serving static files from a separate domain name. This allows you to use a web server optimized for static files, more easily set expires and cache values, and avoid possibly costly transference of cookies on static files. For more information, please see: http://code.google.com/speed/page-speed/docs/request.html#ServeFromCookielessDomain
If you change the resource pattern for StaticR in Foundation.hs, you will have to make a corresponding change here.
To see how this value is used, see urlRenderOverride in Foundation.hs
widgetFileSettings :: WidgetFileSettings Source #
Settings for widgetFile, such as which template languages to support and
default Hamlet settings.
parseExtra :: DefaultEnv -> Object -> Parser Extra Source #
staticSite :: IO Static Source #
data Capability Source #
Instances
The site argument for your application. This can be a good place to keep settings and values requiring initialization before your application starts running, such as database connections. Every handler will have access to the data present here.
Constructors
| App | |
Fields
| |
Instances
A bundle of data useful for hledger-web request handlers and templates.
Constructors
| VD | |
Fields
| |
type Form x = Html -> MForm (HandlerFor App) (FormResult x, Widget) Source #
type Handler = HandlerFor App Source #
getViewData :: Handler ViewData Source #
Gather data used by handlers and templates in the current request.
shouldShowSidebar :: Handler Bool Source #
Find out if the sidebar should be visible. Show it, unless there is a showsidebar cookie set to "0", or a ?sidebar=0 query parameter.