Functor

Functor

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

fmap

Methods

fmap :: (a -> b) -> f a -> f b

(<$) :: a -> f b -> f a infixl 4

Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.

Instances

Functor []

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a -> b) -> [a] -> [b]

(<$) :: a -> [b] -> [a]

Functor Maybe

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a -> b) -> Maybe a -> Maybe b

(<$) :: a -> Maybe b -> Maybe a

Functor IO

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a -> b) -> IO a -> IO b

(<$) :: a -> IO b -> IO a

Functor Par1

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> Par1 a -> Par1 b

(<$) :: a -> Par1 b -> Par1 a

Functor Q

Defined in Language.Haskell.TH.Syntax

Methods

fmap :: (a -> b) -> Q a -> Q b

(<$) :: a -> Q b -> Q a

Functor FromJSONKeyFunction

Only law abiding up to interpretation

Defined in Data.Aeson.Types.FromJSON

Methods

fmap :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b

(<$) :: a -> FromJSONKeyFunction b -> FromJSONKeyFunction a

Functor IResult

Defined in Data.Aeson.Types.Internal

Methods

fmap :: (a -> b) -> IResult a -> IResult b

(<$) :: a -> IResult b -> IResult a

Functor Result

Defined in Data.Aeson.Types.Internal

Methods

fmap :: (a -> b) -> Result a -> Result b

(<$) :: a -> Result b -> Result a

Functor Parser

Defined in Data.Aeson.Types.Internal

Methods

fmap :: (a -> b) -> Parser a -> Parser b

(<$) :: a -> Parser b -> Parser a

Functor Approximate

Defined in Data.Approximate.Type

Methods

fmap :: (a -> b) -> Approximate a -> Approximate b

(<$) :: a -> Approximate b -> Approximate a

Functor Async

Defined in Control.Concurrent.Async

Methods

fmap :: (a -> b) -> Async a -> Async b

(<$) :: a -> Async b -> Async a

Functor Concurrently

Defined in Control.Concurrent.Async

Methods

fmap :: (a -> b) -> Concurrently a -> Concurrently b

(<$) :: a -> Concurrently b -> Concurrently a

Functor Complex

Defined in Data.Complex

Methods

fmap :: (a -> b) -> Complex a -> Complex b

(<$) :: a -> Complex b -> Complex a

Functor Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fmap :: (a -> b) -> Min a -> Min b

(<$) :: a -> Min b -> Min a

Functor Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fmap :: (a -> b) -> Max a -> Max b

(<$) :: a -> Max b -> Max a

Functor First

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fmap :: (a -> b) -> First a -> First b

(<$) :: a -> First b -> First a

Functor Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fmap :: (a -> b) -> Last a -> Last b

(<$) :: a -> Last b -> Last a

Functor Option

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fmap :: (a -> b) -> Option a -> Option b

(<$) :: a -> Option b -> Option a

Functor ZipList

Defined in Control.Applicative

Methods

fmap :: (a -> b) -> ZipList a -> ZipList b

(<$) :: a -> ZipList b -> ZipList a

Functor Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

fmap :: (a -> b) -> Identity a -> Identity b

(<$) :: a -> Identity b -> Identity a

Functor Handler

Since: base-4.6.0.0

Defined in Control.Exception

Methods

fmap :: (a -> b) -> Handler a -> Handler b

(<$) :: a -> Handler b -> Handler a

Functor STM

Since: base-4.3.0.0

Defined in GHC.Conc.Sync

Methods

fmap :: (a -> b) -> STM a -> STM b

(<$) :: a -> STM b -> STM a

Functor First

Defined in Data.Monoid

Methods

fmap :: (a -> b) -> First a -> First b

(<$) :: a -> First b -> First a

Functor Last

Defined in Data.Monoid

Methods

fmap :: (a -> b) -> Last a -> Last b

(<$) :: a -> Last b -> Last a

Functor Dual

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

fmap :: (a -> b) -> Dual a -> Dual b

(<$) :: a -> Dual b -> Dual a

Functor Sum

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

fmap :: (a -> b) -> Sum a -> Sum b

(<$) :: a -> Sum b -> Sum a

Functor Product

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

fmap :: (a -> b) -> Product a -> Product b

(<$) :: a -> Product b -> Product a

Functor Down

Since: base-4.11.0.0

Defined in Data.Ord

Methods

fmap :: (a -> b) -> Down a -> Down b

(<$) :: a -> Down b -> Down a

Functor ReadPrec

Since: base-2.1

Defined in Text.ParserCombinators.ReadPrec

Methods

fmap :: (a -> b) -> ReadPrec a -> ReadPrec b

(<$) :: a -> ReadPrec b -> ReadPrec a

Functor ReadP

Since: base-2.1

Defined in Text.ParserCombinators.ReadP

Methods

fmap :: (a -> b) -> ReadP a -> ReadP b

(<$) :: a -> ReadP b -> ReadP a

Functor NonEmpty

Since: base-4.9.0.0

Defined in GHC.Base

Methods

fmap :: (a -> b) -> NonEmpty a -> NonEmpty b

(<$) :: a -> NonEmpty b -> NonEmpty a

Functor Put

Defined in Data.ByteString.Builder.Internal

Methods

fmap :: (a -> b) -> Put a -> Put b

(<$) :: a -> Put b -> Put a

Functor IntMap

Defined in Data.IntMap.Internal

Methods

fmap :: (a -> b) -> IntMap a -> IntMap b

(<$) :: a -> IntMap b -> IntMap a

Functor SCC

Since: containers-0.5.4

Defined in Data.Graph

Methods

fmap :: (a -> b) -> SCC a -> SCC b

(<$) :: a -> SCC b -> SCC a

Functor Tree

Defined in Data.Tree

Methods

fmap :: (a -> b) -> Tree a -> Tree b

(<$) :: a -> Tree b -> Tree a

Functor Seq

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> Seq a -> Seq b

(<$) :: a -> Seq b -> Seq a

Functor FingerTree

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> FingerTree a -> FingerTree b

(<$) :: a -> FingerTree b -> FingerTree a

Functor Digit

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> Digit a -> Digit b

(<$) :: a -> Digit b -> Digit a

Functor Node

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> Node a -> Node b

(<$) :: a -> Node b -> Node a

Functor Elem

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> Elem a -> Elem b

(<$) :: a -> Elem b -> Elem a

Functor ViewL

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> ViewL a -> ViewL b

(<$) :: a -> ViewL b -> ViewL a

Functor ViewR

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> ViewR a -> ViewR b

(<$) :: a -> ViewR b -> ViewR a

Functor DList

Defined in Data.DList

Methods

fmap :: (a -> b) -> DList a -> DList b

(<$) :: a -> DList b -> DList a

Functor NonGreedy

Defined in Language.Haskell.Exts.Parser

Methods

fmap :: (a -> b) -> NonGreedy a -> NonGreedy b

(<$) :: a -> NonGreedy b -> NonGreedy a

Functor ListOf

Defined in Language.Haskell.Exts.Parser

Methods

fmap :: (a -> b) -> ListOf a -> ListOf b

(<$) :: a -> ListOf b -> ListOf a

Functor ModuleName

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ModuleName a -> ModuleName b

(<$) :: a -> ModuleName b -> ModuleName a

Functor SpecialCon

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> SpecialCon a -> SpecialCon b

(<$) :: a -> SpecialCon b -> SpecialCon a

Functor QName

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> QName a -> QName b

(<$) :: a -> QName b -> QName a

Functor Name

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Name a -> Name b

(<$) :: a -> Name b -> Name a

Functor IPName

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> IPName a -> IPName b

(<$) :: a -> IPName b -> IPName a

Functor QOp

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> QOp a -> QOp b

(<$) :: a -> QOp b -> QOp a

Functor Op

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Op a -> Op b

(<$) :: a -> Op b -> Op a

Functor CName

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> CName a -> CName b

(<$) :: a -> CName b -> CName a

Functor Module

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Module a -> Module b

(<$) :: a -> Module b -> Module a

Functor ModuleHead

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ModuleHead a -> ModuleHead b

(<$) :: a -> ModuleHead b -> ModuleHead a

Functor ExportSpecList

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ExportSpecList a -> ExportSpecList b

(<$) :: a -> ExportSpecList b -> ExportSpecList a

Functor ExportSpec

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ExportSpec a -> ExportSpec b

(<$) :: a -> ExportSpec b -> ExportSpec a

Functor EWildcard

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> EWildcard a -> EWildcard b

(<$) :: a -> EWildcard b -> EWildcard a

Functor Namespace

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Namespace a -> Namespace b

(<$) :: a -> Namespace b -> Namespace a

Functor ImportDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ImportDecl a -> ImportDecl b

(<$) :: a -> ImportDecl b -> ImportDecl a

Functor ImportSpecList

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ImportSpecList a -> ImportSpecList b

(<$) :: a -> ImportSpecList b -> ImportSpecList a

Functor ImportSpec

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ImportSpec a -> ImportSpec b

(<$) :: a -> ImportSpec b -> ImportSpec a

Functor Assoc

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Assoc a -> Assoc b

(<$) :: a -> Assoc b -> Assoc a

Functor Decl

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Decl a -> Decl b

(<$) :: a -> Decl b -> Decl a

Functor PatternSynDirection

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> PatternSynDirection a -> PatternSynDirection b

(<$) :: a -> PatternSynDirection b -> PatternSynDirection a

Functor TypeEqn

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> TypeEqn a -> TypeEqn b

(<$) :: a -> TypeEqn b -> TypeEqn a

Functor Annotation

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Annotation a -> Annotation b

(<$) :: a -> Annotation b -> Annotation a

Functor BooleanFormula

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> BooleanFormula a -> BooleanFormula b

(<$) :: a -> BooleanFormula b -> BooleanFormula a

Functor Role

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Role a -> Role b

(<$) :: a -> Role b -> Role a

Functor DataOrNew

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> DataOrNew a -> DataOrNew b

(<$) :: a -> DataOrNew b -> DataOrNew a

Functor InjectivityInfo

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> InjectivityInfo a -> InjectivityInfo b

(<$) :: a -> InjectivityInfo b -> InjectivityInfo a

Functor ResultSig

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ResultSig a -> ResultSig b

(<$) :: a -> ResultSig b -> ResultSig a

Functor DeclHead

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> DeclHead a -> DeclHead b

(<$) :: a -> DeclHead b -> DeclHead a

Functor InstRule

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> InstRule a -> InstRule b

(<$) :: a -> InstRule b -> InstRule a

Functor InstHead

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> InstHead a -> InstHead b

(<$) :: a -> InstHead b -> InstHead a

Functor Deriving

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Deriving a -> Deriving b

(<$) :: a -> Deriving b -> Deriving a

Functor DerivStrategy

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> DerivStrategy a -> DerivStrategy b

(<$) :: a -> DerivStrategy b -> DerivStrategy a

Functor Binds

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Binds a -> Binds b

(<$) :: a -> Binds b -> Binds a

Functor IPBind

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> IPBind a -> IPBind b

(<$) :: a -> IPBind b -> IPBind a

Functor Match

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Match a -> Match b

(<$) :: a -> Match b -> Match a

Functor QualConDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> QualConDecl a -> QualConDecl b

(<$) :: a -> QualConDecl b -> QualConDecl a

Functor ConDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ConDecl a -> ConDecl b

(<$) :: a -> ConDecl b -> ConDecl a

Functor FieldDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> FieldDecl a -> FieldDecl b

(<$) :: a -> FieldDecl b -> FieldDecl a

Functor GadtDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> GadtDecl a -> GadtDecl b

(<$) :: a -> GadtDecl b -> GadtDecl a

Functor ClassDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ClassDecl a -> ClassDecl b

(<$) :: a -> ClassDecl b -> ClassDecl a

Functor InstDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> InstDecl a -> InstDecl b

(<$) :: a -> InstDecl b -> InstDecl a

Functor BangType

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> BangType a -> BangType b

(<$) :: a -> BangType b -> BangType a

Functor Unpackedness

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Unpackedness a -> Unpackedness b

(<$) :: a -> Unpackedness b -> Unpackedness a

Functor Rhs

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Rhs a -> Rhs b

(<$) :: a -> Rhs b -> Rhs a

Functor GuardedRhs

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> GuardedRhs a -> GuardedRhs b

(<$) :: a -> GuardedRhs b -> GuardedRhs a

Functor Type

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Type a -> Type b

(<$) :: a -> Type b -> Type a

Functor MaybePromotedName

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> MaybePromotedName a -> MaybePromotedName b

(<$) :: a -> MaybePromotedName b -> MaybePromotedName a

Functor Promoted

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Promoted a -> Promoted b

(<$) :: a -> Promoted b -> Promoted a

Functor TyVarBind

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> TyVarBind a -> TyVarBind b

(<$) :: a -> TyVarBind b -> TyVarBind a

Functor Kind

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Kind a -> Kind b

(<$) :: a -> Kind b -> Kind a

Functor FunDep

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> FunDep a -> FunDep b

(<$) :: a -> FunDep b -> FunDep a

Functor Context

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Context a -> Context b

(<$) :: a -> Context b -> Context a

Functor Asst

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Asst a -> Asst b

(<$) :: a -> Asst b -> Asst a

Functor Literal

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Literal a -> Literal b

(<$) :: a -> Literal b -> Literal a

Functor Sign

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Sign a -> Sign b

(<$) :: a -> Sign b -> Sign a

Functor Exp

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Exp a -> Exp b

(<$) :: a -> Exp b -> Exp a

Functor XName

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> XName a -> XName b

(<$) :: a -> XName b -> XName a

Functor XAttr

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> XAttr a -> XAttr b

(<$) :: a -> XAttr b -> XAttr a

Functor Bracket

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Bracket a -> Bracket b

(<$) :: a -> Bracket b -> Bracket a

Functor Splice

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Splice a -> Splice b

(<$) :: a -> Splice b -> Splice a

Functor Safety

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Safety a -> Safety b

(<$) :: a -> Safety b -> Safety a

Functor CallConv

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> CallConv a -> CallConv b

(<$) :: a -> CallConv b -> CallConv a

Functor ModulePragma

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ModulePragma a -> ModulePragma b

(<$) :: a -> ModulePragma b -> ModulePragma a

Functor Overlap

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Overlap a -> Overlap b

(<$) :: a -> Overlap b -> Overlap a

Functor Activation

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Activation a -> Activation b

(<$) :: a -> Activation b -> Activation a

Functor Rule

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Rule a -> Rule b

(<$) :: a -> Rule b -> Rule a

Functor RuleVar

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> RuleVar a -> RuleVar b

(<$) :: a -> RuleVar b -> RuleVar a

Functor WarningText

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> WarningText a -> WarningText b

(<$) :: a -> WarningText b -> WarningText a

Functor Pat

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Pat a -> Pat b

(<$) :: a -> Pat b -> Pat a

Functor PXAttr

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> PXAttr a -> PXAttr b

(<$) :: a -> PXAttr b -> PXAttr a

Functor RPatOp

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> RPatOp a -> RPatOp b

(<$) :: a -> RPatOp b -> RPatOp a

Functor RPat

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> RPat a -> RPat b

(<$) :: a -> RPat b -> RPat a

Functor PatField

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> PatField a -> PatField b

(<$) :: a -> PatField b -> PatField a

Functor Stmt

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Stmt a -> Stmt b

(<$) :: a -> Stmt b -> Stmt a

Functor QualStmt

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> QualStmt a -> QualStmt b

(<$) :: a -> QualStmt b -> QualStmt a

Functor FieldUpdate

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> FieldUpdate a -> FieldUpdate b

(<$) :: a -> FieldUpdate b -> FieldUpdate a

Functor Alt

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Alt a -> Alt b

(<$) :: a -> Alt b -> Alt a

Functor Concrete

Defined in Hedgehog.Internal.State

Methods

fmap :: (a -> b) -> Concrete a -> Concrete b

(<$) :: a -> Concrete b -> Concrete a

Functor Range

Defined in Hedgehog.Internal.Range

Methods

fmap :: (a -> b) -> Range a -> Range b

(<$) :: a -> Range b -> Range a

Functor Eval

Defined in Control.Parallel.Strategies

Methods

fmap :: (a -> b) -> Eval a -> Eval b

(<$) :: a -> Eval b -> Eval a

Functor Vector

Defined in Data.Vector

Methods

fmap :: (a -> b) -> Vector a -> Vector b

(<$) :: a -> Vector b -> Vector a

Functor Log

Defined in Numeric.Log

Methods

fmap :: (a -> b) -> Log a -> Log b

(<$) :: a -> Log b -> Log a

Functor Managed

Defined in Control.Monad.Managed

Methods

fmap :: (a -> b) -> Managed a -> Managed b

(<$) :: a -> Managed b -> Managed a

Functor ErrorItem

Defined in Text.Megaparsec.Error

Methods

fmap :: (a -> b) -> ErrorItem a -> ErrorItem b

(<$) :: a -> ErrorItem b -> ErrorItem a

Functor ErrorFancy

Defined in Text.Megaparsec.Error

Methods

fmap :: (a -> b) -> ErrorFancy a -> ErrorFancy b

(<$) :: a -> ErrorFancy b -> ErrorFancy a

Functor ParserInfo

Defined in Options.Applicative.Types

Methods

fmap :: (a -> b) -> ParserInfo a -> ParserInfo b

(<$) :: a -> ParserInfo b -> ParserInfo a

Functor Option

Defined in Options.Applicative.Types

Methods

fmap :: (a -> b) -> Option a -> Option b

(<$) :: a -> Option b -> Option a

Functor ReadM

Defined in Options.Applicative.Types

Methods

fmap :: (a -> b) -> ReadM a -> ReadM b

(<$) :: a -> ReadM b -> ReadM a

Functor CReader

Defined in Options.Applicative.Types

Methods

fmap :: (a -> b) -> CReader a -> CReader b

(<$) :: a -> CReader b -> CReader a

Functor OptReader

Defined in Options.Applicative.Types

Methods

fmap :: (a -> b) -> OptReader a -> OptReader b

(<$) :: a -> OptReader b -> OptReader a

Functor Parser

Defined in Options.Applicative.Types

Methods

fmap :: (a -> b) -> Parser a -> Parser b

(<$) :: a -> Parser b -> Parser a

Functor ParserM

Defined in Options.Applicative.Types

Methods

fmap :: (a -> b) -> ParserM a -> ParserM b

(<$) :: a -> ParserM b -> ParserM a

Functor ParserFailure

Defined in Options.Applicative.Types

Methods

fmap :: (a -> b) -> ParserFailure a -> ParserFailure b

(<$) :: a -> ParserFailure b -> ParserFailure a

Functor ParserResult

Defined in Options.Applicative.Types

Methods

fmap :: (a -> b) -> ParserResult a -> ParserResult b

(<$) :: a -> ParserResult b -> ParserResult a

Functor Doc

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

fmap :: (a -> b) -> Doc a -> Doc b

(<$) :: a -> Doc b -> Doc a

Functor AnnotDetails

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

fmap :: (a -> b) -> AnnotDetails a -> AnnotDetails b

(<$) :: a -> AnnotDetails b -> AnnotDetails a

Functor Span

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

fmap :: (a -> b) -> Span a -> Span b

(<$) :: a -> Span b -> Span a

Functor Doc

Alter the document’s annotations.

This instance makes Doc more flexible (because it can be used in Functor-polymorphic values), but fmap is much less readable compared to using reAnnotate in code that only works for Doc anyway. Consider using the latter when the type does not matter.

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

fmap :: (a -> b) -> Doc a -> Doc b

(<$) :: a -> Doc b -> Doc a

Functor SimpleDocStream

Alter the document’s annotations.

This instance makes SimpleDocStream more flexible (because it can be used in Functor-polymorphic values), but fmap is much less readable compared to using reAnnotateST in code that only works for SimpleDocStream anyway. Consider using the latter when the type does not matter.

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

fmap :: (a -> b) -> SimpleDocStream a -> SimpleDocStream b

(<$) :: a -> SimpleDocStream b -> SimpleDocStream a

Functor SmallArray

Defined in Data.Primitive.SmallArray

Methods

fmap :: (a -> b) -> SmallArray a -> SmallArray b

(<$) :: a -> SmallArray b -> SmallArray a

Functor Array

Defined in Data.Primitive.Array

Methods

fmap :: (a -> b) -> Array a -> Array b

(<$) :: a -> Array b -> Array a

Functor Event

The function fmap applies a function f to every value. Semantically,

fmap :: (a -> b) -> Event a -> Event b
fmap f e = [(time, f a) | (time, a) <- e]

Defined in Reactive.Banana.Types

Methods

fmap :: (a -> b) -> Event a -> Event b

(<$) :: a -> Event b -> Event a

Functor Behavior

The function fmap applies a function f at every point in time. Semantically,

fmap :: (a -> b) -> Behavior a -> Behavior b
fmap f b = \time -> f (b time)

Defined in Reactive.Banana.Types

Methods

fmap :: (a -> b) -> Behavior a -> Behavior b

(<$) :: a -> Behavior b -> Behavior a

Functor Future

Defined in Reactive.Banana.Types

Methods

fmap :: (a -> b) -> Future a -> Future b

(<$) :: a -> Future b -> Future a

Functor Moment

Defined in Reactive.Banana.Types

Methods

fmap :: (a -> b) -> Moment a -> Moment b

(<$) :: a -> Moment b -> Moment a

Functor MomentIO

Defined in Reactive.Banana.Types

Methods

fmap :: (a -> b) -> MomentIO a -> MomentIO b

(<$) :: a -> MomentIO b -> MomentIO a

Functor AddHandler

Defined in Control.Event.Handler

Methods

fmap :: (a -> b) -> AddHandler a -> AddHandler b

(<$) :: a -> AddHandler b -> AddHandler a

Functor Bound

Defined in Data.Semilattice.Bound

Methods

fmap :: (a -> b) -> Bound a -> Bound b

(<$) :: a -> Bound b -> Bound a

Functor Order

Defined in Data.Semilattice.Order

Methods

fmap :: (a -> b) -> Order a -> Order b

(<$) :: a -> Order b -> Order a

Functor Meeting

Defined in Data.Semilattice.Meet

Methods

fmap :: (a -> b) -> Meeting a -> Meeting b

(<$) :: a -> Meeting b -> Meeting a

Functor GreaterThan

Defined in Data.Semilattice.Meet

Methods

fmap :: (a -> b) -> GreaterThan a -> GreaterThan b

(<$) :: a -> GreaterThan b -> GreaterThan a

Functor Joining

Defined in Data.Semilattice.Join

Methods

fmap :: (a -> b) -> Joining a -> Joining b

(<$) :: a -> Joining b -> Joining a

Functor LessThan

Defined in Data.Semilattice.Join

Methods

fmap :: (a -> b) -> LessThan a -> LessThan b

(<$) :: a -> LessThan b -> LessThan a

Functor Cleanup

Defined in System.Process.Typed

Methods

fmap :: (a -> b) -> Cleanup a -> Cleanup b

(<$) :: a -> Cleanup b -> Cleanup a

Functor Element

Defined in Control.Concurrent.Chan.Unagi.NoBlocking.Types

Methods

fmap :: (a -> b) -> Element a -> Element b

(<$) :: a -> Element b -> Element a

Functor Weigh

Defined in Weigh

Methods

fmap :: (a -> b) -> Weigh a -> Weigh b

(<$) :: a -> Weigh b -> Weigh a

Functor Grouped

Defined in Weigh

Methods

fmap :: (a -> b) -> Grouped a -> Grouped b

(<$) :: a -> Grouped b -> Grouped a

Functor P

Defined in Text.ParserCombinators.ReadP

Methods

fmap :: (a -> b) -> P a -> P b

(<$) :: a -> P b -> P a

Functor Forest

Defined in Data.Heap

Methods

fmap :: (a -> b) -> Forest a -> Forest b

(<$) :: a -> Forest b -> Forest a

Functor Tree

Defined in Data.Heap

Methods

fmap :: (a -> b) -> Tree a -> Tree b

(<$) :: a -> Tree b -> Tree a

Class () (Functor f)

Defined in Data.Constraint

Methods

cls :: Functor f :- ()

() :=> (Functor ((->) a :: * -> *))

Defined in Data.Constraint

Methods

ins :: () :- Functor ((->) a)

() :=> (Functor [])

Defined in Data.Constraint

Methods

ins :: () :- Functor []

() :=> (Functor Maybe)

Defined in Data.Constraint

Methods

ins :: () :- Functor Maybe

() :=> (Functor IO)

Defined in Data.Constraint

Methods

ins :: () :- Functor IO

() :=> (Functor (Either a))

Defined in Data.Constraint

Methods

ins :: () :- Functor (Either a)

() :=> (Functor ((,) a))

Defined in Data.Constraint

Methods

ins :: () :- Functor ((,) a)

() :=> (Functor Identity)

Defined in Data.Constraint

Methods

ins :: () :- Functor Identity

() :=> (Functor (Const a :: * -> *))

Defined in Data.Constraint

Methods

ins :: () :- Functor (Const a)

Functor (Either a)

Since: base-3.0

Defined in Data.Either

Methods

fmap :: (a0 -> b) -> Either a a0 -> Either a b

(<$) :: a0 -> Either a b -> Either a a0

Functor (V1 :: * -> *)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> V1 a -> V1 b

(<$) :: a -> V1 b -> V1 a

Functor (U1 :: * -> *)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> U1 a -> U1 b

(<$) :: a -> U1 b -> U1 a

Functor ((,) a)

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a0 -> b) -> (a, a0) -> (a, b)

(<$) :: a0 -> (a, b) -> (a, a0)

Functor (ST s)

Since: base-2.1

Defined in GHC.ST

Methods

fmap :: (a -> b) -> ST s a -> ST s b

(<$) :: a -> ST s b -> ST s a

Functor (Results s)

Defined in Text.Earley.Parser.Internal

Methods

fmap :: (a -> b) -> Results s a -> Results s b

(<$) :: a -> Results s b -> Results s a

Functor (Grammar r)

Defined in Text.Earley.Grammar

Methods

fmap :: (a -> b) -> Grammar r a -> Grammar r b

(<$) :: a -> Grammar r b -> Grammar r a

Functor f => Functor (Co f)

Defined in Data.Functor.Rep

Methods

fmap :: (a -> b) -> Co f a -> Co f b

(<$) :: a -> Co f b -> Co f a

Functor (HashMap k)

Defined in Data.HashMap.Base

Methods

fmap :: (a -> b) -> HashMap k a -> HashMap k b

(<$) :: a -> HashMap k b -> HashMap k a

Functor (Map k)

Defined in Data.Map.Internal

Methods

fmap :: (a -> b) -> Map k a -> Map k b

(<$) :: a -> Map k b -> Map k a

Functor (Array i)

Since: base-2.1

Defined in GHC.Arr

Methods

fmap :: (a -> b) -> Array i a -> Array i b

(<$) :: a -> Array i b -> Array i a

Functor (Arg a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fmap :: (a0 -> b) -> Arg a a0 -> Arg a b

(<$) :: a0 -> Arg a b -> Arg a a0

Monad m => Functor (WrappedMonad m)

Since: base-2.1

Defined in Control.Applicative

Methods

fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b

(<$) :: a -> WrappedMonad m b -> WrappedMonad m a

Arrow a => Functor (ArrowMonad a)

Since: base-4.6.0.0

Defined in Control.Arrow

Methods

fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b

(<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0

Functor (Proxy :: * -> *)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

fmap :: (a -> b) -> Proxy a -> Proxy b

(<$) :: a -> Proxy b -> Proxy a

Functor (Parser e)

Defined in Env.Internal.Parser

Methods

fmap :: (a -> b) -> Parser e a -> Parser e b

(<$) :: a -> Parser e b -> Parser e a

Functor (VarF e)

Defined in Env.Internal.Parser

Methods

fmap :: (a -> b) -> VarF e a -> VarF e b

(<$) :: a -> VarF e b -> VarF e a

Functor m => Functor (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

fmap :: (a -> b) -> MaybeT m a -> MaybeT m b

(<$) :: a -> MaybeT m b -> MaybeT m a

Monad m => Functor (Handler m)

Defined in Control.Monad.Catch

Methods

fmap :: (a -> b) -> Handler m a -> Handler m b

(<$) :: a -> Handler m b -> Handler m a

Functor (Fold a)

Defined in Control.Foldl

Methods

fmap :: (a0 -> b) -> Fold a a0 -> Fold a b

(<$) :: a0 -> Fold a b -> Fold a a0

Functor f => Functor (Cofree f)

Defined in Control.Comonad.Cofree

Methods

fmap :: (a -> b) -> Cofree f a -> Cofree f b

(<$) :: a -> Cofree f b -> Cofree f a

Functor f => Functor (Free f)

Defined in Control.Monad.Free

Methods

fmap :: (a -> b) -> Free f a -> Free f b

(<$) :: a -> Free f b -> Free f a

Functor (Ap f)

Defined in Control.Applicative.Free

Methods

fmap :: (a -> b) -> Ap f a -> Ap f b

(<$) :: a -> Ap f b -> Ap f a

Functor (Entry p)

Defined in Data.Heap

Methods

fmap :: (a -> b) -> Entry p a -> Entry p b

(<$) :: a -> Entry p b -> Entry p a

Functor m => Functor (PropertyT m)

Defined in Hedgehog.Internal.Property

Methods

fmap :: (a -> b) -> PropertyT m a -> PropertyT m b

(<$) :: a -> PropertyT m b -> PropertyT m a

Functor m => Functor (TestT m)

Defined in Hedgehog.Internal.Property

Methods

fmap :: (a -> b) -> TestT m a -> TestT m b

(<$) :: a -> TestT m b -> TestT m a

Functor m => Functor (GenT m)

Defined in Hedgehog.Internal.Gen

Methods

fmap :: (a -> b) -> GenT m a -> GenT m b

(<$) :: a -> GenT m b -> GenT m a

Functor (Vec n)

Defined in Hedgehog.Internal.Gen

Methods

fmap :: (a -> b) -> Vec n a -> Vec n b

(<$) :: a -> Vec n b -> Vec n a

Functor (Yoneda f)

Defined in Data.Functor.Yoneda

Methods

fmap :: (a -> b) -> Yoneda f a -> Yoneda f b

(<$) :: a -> Yoneda f b -> Yoneda f a

Functor (ReifiedGetter s)

Defined in Control.Lens.Reified

Methods

fmap :: (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b

(<$) :: a -> ReifiedGetter s b -> ReifiedGetter s a

Functor (ReifiedFold s)

Defined in Control.Lens.Reified

Methods

fmap :: (a -> b) -> ReifiedFold s a -> ReifiedFold s b

(<$) :: a -> ReifiedFold s b -> ReifiedFold s a

Functor f => Functor (Indexing f)

Defined in Control.Lens.Internal.Indexed

Methods

fmap :: (a -> b) -> Indexing f a -> Indexing f b

(<$) :: a -> Indexing f b -> Indexing f a

Functor f => Functor (Indexing64 f)

Defined in Control.Lens.Internal.Indexed

Methods

fmap :: (a -> b) -> Indexing64 f a -> Indexing64 f b

(<$) :: a -> Indexing64 f b -> Indexing64 f a

Monad m => Functor (ListT m)

Defined in List.Transformer

Methods

fmap :: (a -> b) -> ListT m a -> ListT m b

(<$) :: a -> ListT m b -> ListT m a

Monad m => Functor (Step m)

Defined in List.Transformer

Methods

fmap :: (a -> b) -> Step m a -> Step m b

(<$) :: a -> Step m b -> Step m a

Functor (LogicT f)

Defined in Control.Monad.Logic

Methods

fmap :: (a -> b) -> LogicT f a -> LogicT f b

(<$) :: a -> LogicT f b -> LogicT f a

Profunctor p => Functor (Prep p)

Defined in Data.Profunctor.Rep

Methods

fmap :: (a -> b) -> Prep p a -> Prep p b

(<$) :: a -> Prep p b -> Prep p a

Profunctor p => Functor (Coprep p)

Defined in Data.Profunctor.Rep

Methods

fmap :: (a -> b) -> Coprep p a -> Coprep p b

(<$) :: a -> Coprep p b -> Coprep p a

Functor (IntPSQ p)

Defined in Data.IntPSQ.Internal

Methods

fmap :: (a -> b) -> IntPSQ p a -> IntPSQ p b

(<$) :: a -> IntPSQ p b -> IntPSQ p a

Functor f => Functor (WrappedApplicative f)

Defined in Data.Functor.Bind.Class

Methods

fmap :: (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b

(<$) :: a -> WrappedApplicative f b -> WrappedApplicative f a

Functor f => Functor (MaybeApply f)

Defined in Data.Functor.Bind.Class

Methods

fmap :: (a -> b) -> MaybeApply f a -> MaybeApply f b

(<$) :: a -> MaybeApply f b -> MaybeApply f a

Functor (IParser t)

Defined in Data.Text.Internal.Read

Methods

fmap :: (a -> b) -> IParser t a -> IParser t b

(<$) :: a -> IParser t b -> IParser t a

Functor (StreamSpec streamType)

Defined in System.Process.Typed

Methods

fmap :: (a -> b) -> StreamSpec streamType a -> StreamSpec streamType b

(<$) :: a -> StreamSpec streamType b -> StreamSpec streamType a

Monad m => Functor (Concurrently m)

Since: unliftio-0.1.0.0

Defined in UnliftIO.Async

Methods

fmap :: (a -> b) -> Concurrently m a -> Concurrently m b

(<$) :: a -> Concurrently m b -> Concurrently m a

Functor f => Functor (Act f)

Defined in Data.Semigroup.Bifoldable

Methods

fmap :: (a -> b) -> Act f a -> Act f b

(<$) :: a -> Act f b -> Act f a

Functor f => Functor (Act f)

Defined in Data.Semigroup.Foldable

Methods

fmap :: (a -> b) -> Act f a -> Act f b

(<$) :: a -> Act f b -> Act f a

Functor (SetM s)

Defined in Data.Graph

Methods

fmap :: (a -> b) -> SetM s a -> SetM s b

(<$) :: a -> SetM s b -> SetM s a

Functor (IncrementalDecoder s)

Defined in Codec.CBOR.Read

Methods

fmap :: (a -> b) -> IncrementalDecoder s a -> IncrementalDecoder s b

(<$) :: a -> IncrementalDecoder s b -> IncrementalDecoder s a

Functor (Subterms n)

Defined in Hedgehog.Internal.Gen

Methods

fmap :: (a -> b) -> Subterms n a -> Subterms n b

(<$) :: a -> Subterms n b -> Subterms n a

Class (Functor f) (Applicative f)

Defined in Data.Constraint

Methods

cls :: Applicative f :- Functor f

(Monad m) :=> (Functor (WrappedMonad m))

Defined in Data.Constraint

Methods

ins :: Monad m :- Functor (WrappedMonad m)

Functor f => Functor (Rec1 f)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> Rec1 f a -> Rec1 f b

(<$) :: a -> Rec1 f b -> Rec1 f a

Functor (URec Char :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b

(<$) :: a -> URec Char b -> URec Char a

Functor (URec Double :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b

(<$) :: a -> URec Double b -> URec Double a

Functor (URec Float :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b

(<$) :: a -> URec Float b -> URec Float a

Functor (URec Int :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b

(<$) :: a -> URec Int b -> URec Int a

Functor (URec Word :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Word a -> URec Word b

(<$) :: a -> URec Word b -> URec Word a

Functor (URec (Ptr ()) :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b

(<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a

Functor (Results s t)

Defined in Text.Earley.Generator.Internal

Methods

fmap :: (a -> b) -> Results s t a -> Results s t b

(<$) :: a -> Results s t b -> Results s t a

Functor (Result s t)

Defined in Text.Earley.Generator.Internal

Methods

fmap :: (a -> b) -> Result s t a -> Result s t b

(<$) :: a -> Result s t b -> Result s t a

Arrow a => Functor (WrappedArrow a b)

Since: base-2.1

Defined in Control.Applicative

Methods

fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0

(<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0

Functor (Const m :: * -> *)

Since: base-2.1

Defined in Data.Functor.Const

Methods

fmap :: (a -> b) -> Const m a -> Const m b

(<$) :: a -> Const m b -> Const m a

Functor f => Functor (Alt f)

Defined in Data.Semigroup.Internal

Methods

fmap :: (a -> b) -> Alt f a -> Alt f b

(<$) :: a -> Alt f b -> Alt f a

Bifunctor p => Functor (Join p)

Defined in Data.Bifunctor.Join

Methods

fmap :: (a -> b) -> Join p a -> Join p b

(<$) :: a -> Join p b -> Join p a

Bifunctor p => Functor (Fix p)

Defined in Data.Bifunctor.Fix

Methods

fmap :: (a -> b) -> Fix p a -> Fix p b

(<$) :: a -> Fix p b -> Fix p a

Functor m => Functor (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

fmap :: (a -> b) -> IdentityT m a -> IdentityT m b

(<$) :: a -> IdentityT m b -> IdentityT m a

(Applicative f, Monad f) => Functor (WhenMissing f x)

Since: containers-0.5.9

Defined in Data.IntMap.Internal

Methods

fmap :: (a -> b) -> WhenMissing f x a -> WhenMissing f x b

(<$) :: a -> WhenMissing f x b -> WhenMissing f x a

Functor m => Functor (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

fmap :: (a -> b) -> ExceptT e m a -> ExceptT e m b

(<$) :: a -> ExceptT e m b -> ExceptT e m a

Monad m => Functor (GT m g)

Defined in Data.Graph.Inductive.Query.Monad

Methods

fmap :: (a -> b) -> GT m g a -> GT m g b

(<$) :: a -> GT m g b -> GT m g a

Functor m => Functor (FoldM m a)

Defined in Control.Foldl

Methods

fmap :: (a0 -> b) -> FoldM m a a0 -> FoldM m a b

(<$) :: a0 -> FoldM m a b -> FoldM m a a0

Functor f => Functor (FreeF f a)

Defined in Control.Monad.Trans.Free

Methods

fmap :: (a0 -> b) -> FreeF f a a0 -> FreeF f a b

(<$) :: a0 -> FreeF f a b -> FreeF f a a0

(Functor f, Monad m) => Functor (FreeT f m)

Defined in Control.Monad.Trans.Free

Methods

fmap :: (a -> b) -> FreeT f m a -> FreeT f m b

(<$) :: a -> FreeT f m b -> FreeT f m a

Functor f => Functor (CofreeF f a)

Defined in Control.Comonad.Trans.Cofree

Methods

fmap :: (a0 -> b) -> CofreeF f a a0 -> CofreeF f a b

(<$) :: a0 -> CofreeF f a b -> CofreeF f a a0

(Functor f, Functor w) => Functor (CofreeT f w)

Defined in Control.Comonad.Trans.Cofree

Methods

fmap :: (a -> b) -> CofreeT f w a -> CofreeT f w b

(<$) :: a -> CofreeT f w b -> CofreeT f w a

Functor (Day f g)

Defined in Data.Functor.Day

Methods

fmap :: (a -> b) -> Day f g a -> Day f g b

(<$) :: a -> Day f g b -> Day f g a

Functor m => Functor (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

fmap :: (a -> b) -> ErrorT e m a -> ErrorT e m b

(<$) :: a -> ErrorT e m b -> ErrorT e m a

Functor f => Functor (Backwards f)

Derived instance.

Defined in Control.Applicative.Backwards

Methods

fmap :: (a -> b) -> Backwards f a -> Backwards f b

(<$) :: a -> Backwards f b -> Backwards f a

Functor (ReifiedIndexedGetter i s)

Defined in Control.Lens.Reified

Methods

fmap :: (a -> b) -> ReifiedIndexedGetter i s a -> ReifiedIndexedGetter i s b

(<$) :: a -> ReifiedIndexedGetter i s b -> ReifiedIndexedGetter i s a

Functor (ReifiedIndexedFold i s)

Defined in Control.Lens.Reified

Methods

fmap :: (a -> b) -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s b

(<$) :: a -> ReifiedIndexedFold i s b -> ReifiedIndexedFold i s a

Functor (Mafic a b)

Defined in Control.Lens.Internal.Magma

Methods

fmap :: (a0 -> b0) -> Mafic a b a0 -> Mafic a b b0

(<$) :: a0 -> Mafic a b b0 -> Mafic a b a0

Functor (Context a b)

Defined in Control.Lens.Internal.Context

Methods

fmap :: (a0 -> b0) -> Context a b a0 -> Context a b b0

(<$) :: a0 -> Context a b b0 -> Context a b a0

Functor (Indexed i a)

Defined in Control.Lens.Internal.Indexed

Methods

fmap :: (a0 -> b) -> Indexed i a a0 -> Indexed i a b

(<$) :: a0 -> Indexed i a b -> Indexed i a a0

Functor m => Functor (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

fmap :: (a -> b) -> StateT s m a -> StateT s m b

(<$) :: a -> StateT s m b -> StateT s m a

Functor (STE e s)

Defined in Control.Monad.STE.Internal

Methods

fmap :: (a -> b) -> STE e s a -> STE e s b

(<$) :: a -> STE e s b -> STE e s a

Functor m => Functor (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

fmap :: (a -> b) -> StateT s m a -> StateT s m b

(<$) :: a -> StateT s m b -> StateT s m a

Profunctor p => Functor (TambaraSum p a)

Defined in Data.Profunctor.Choice

Methods

fmap :: (a0 -> b) -> TambaraSum p a a0 -> TambaraSum p a b

(<$) :: a0 -> TambaraSum p a b -> TambaraSum p a a0

Functor (CotambaraSum p a)

Defined in Data.Profunctor.Choice

Methods

fmap :: (a0 -> b) -> CotambaraSum p a a0 -> CotambaraSum p a b

(<$) :: a0 -> CotambaraSum p a b -> CotambaraSum p a a0

Profunctor p => Functor (Closure p a)

Defined in Data.Profunctor.Closed

Methods

fmap :: (a0 -> b) -> Closure p a a0 -> Closure p a b

(<$) :: a0 -> Closure p a b -> Closure p a a0

Profunctor p => Functor (Tambara p a)

Defined in Data.Profunctor.Strong

Methods

fmap :: (a0 -> b) -> Tambara p a a0 -> Tambara p a b

(<$) :: a0 -> Tambara p a b -> Tambara p a a0

Functor (Cotambara p a)

Defined in Data.Profunctor.Strong

Methods

fmap :: (a0 -> b) -> Cotambara p a a0 -> Cotambara p a b

(<$) :: a0 -> Cotambara p a b -> Cotambara p a a0

Functor f => Functor (Star f a)

Defined in Data.Profunctor.Types

Methods

fmap :: (a0 -> b) -> Star f a a0 -> Star f a b

(<$) :: a0 -> Star f a b -> Star f a a0

Functor (Costar f a)

Defined in Data.Profunctor.Types

Methods

fmap :: (a0 -> b) -> Costar f a a0 -> Costar f a b

(<$) :: a0 -> Costar f a b -> Costar f a a0

Functor (Forget r a)

Defined in Data.Profunctor.Types

Methods

fmap :: (a0 -> b) -> Forget r a a0 -> Forget r a b

(<$) :: a0 -> Forget r a b -> Forget r a a0

Functor (Bucket k p)

Defined in Data.HashPSQ.Internal

Methods

fmap :: (a -> b) -> Bucket k p a -> Bucket k p b

(<$) :: a -> Bucket k p b -> Bucket k p a

Functor (LTree k p)

Defined in Data.OrdPSQ.Internal

Methods

fmap :: (a -> b) -> LTree k p a -> LTree k p b

(<$) :: a -> LTree k p b -> LTree k p a

Functor (Elem k p)

Defined in Data.OrdPSQ.Internal

Methods

fmap :: (a -> b) -> Elem k p a -> Elem k p b

(<$) :: a -> Elem k p b -> Elem k p a

Functor (HashPSQ k p)

Defined in Data.HashPSQ.Internal

Methods

fmap :: (a -> b) -> HashPSQ k p a -> HashPSQ k p b

(<$) :: a -> HashPSQ k p b -> HashPSQ k p a

Functor (OrdPSQ k p)

Defined in Data.OrdPSQ.Internal

Methods

fmap :: (a -> b) -> OrdPSQ k p a -> OrdPSQ k p b

(<$) :: a -> OrdPSQ k p b -> OrdPSQ k p a

Functor f => Functor (Static f a)

Defined in Data.Semigroupoid.Static

Methods

fmap :: (a0 -> b) -> Static f a a0 -> Static f a b

(<$) :: a0 -> Static f a b -> Static f a a0

Functor (Tagged s)

Defined in Data.Tagged

Methods

fmap :: (a -> b) -> Tagged s a -> Tagged s b

(<$) :: a -> Tagged s b -> Tagged s a

Functor m => Functor (WriterT w m)

Defined in Control.Monad.Trans.Writer.CPS.Internal

Methods

fmap :: (a -> b) -> WriterT w m a -> WriterT w m b

(<$) :: a -> WriterT w m b -> WriterT w m a

Functor (Holes t m)

Defined in Control.Lens.Traversal

Methods

fmap :: (a -> b) -> Holes t m a -> Holes t m b

(<$) :: a -> Holes t m b -> Holes t m a

Functor ((->) r :: * -> *)

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a -> b) -> (r -> a) -> r -> b

(<$) :: a -> (r -> b) -> r -> a

Functor (K1 i c :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> K1 i c a -> K1 i c b

(<$) :: a -> K1 i c b -> K1 i c a

(Functor f, Functor g) => Functor (f :+: g)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b

(<$) :: a -> (f :+: g) b -> (f :+: g) a

(Functor f, Functor g) => Functor (f :*: g)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> (f :*: g) a -> (f :*: g) b

(<$) :: a -> (f :*: g) b -> (f :*: g) a

Functor (Result s e i)

Defined in Text.Earley.Parser.Internal

Methods

fmap :: (a -> b) -> Result s e i a -> Result s e i b

(<$) :: a -> Result s e i b -> Result s e i a

Functor (Prod r e t)

Defined in Text.Earley.Grammar

Methods

fmap :: (a -> b) -> Prod r e t a -> Prod r e t b

(<$) :: a -> Prod r e t b -> Prod r e t a

(Functor f, Functor g) => Functor (Product f g)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

fmap :: (a -> b) -> Product f g a -> Product f g b

(<$) :: a -> Product f g b -> Product f g a

(Functor f, Functor g) => Functor (Sum f g)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Methods

fmap :: (a -> b) -> Sum f g a -> Sum f g b

(<$) :: a -> Sum f g b -> Sum f g a

Functor (Cokleisli w a)

Defined in Control.Comonad

Methods

fmap :: (a0 -> b) -> Cokleisli w a a0 -> Cokleisli w a b

(<$) :: a0 -> Cokleisli w a b -> Cokleisli w a a0

Functor f => Functor (WhenMatched f x y)

Since: containers-0.5.9

Defined in Data.IntMap.Internal

Methods

fmap :: (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b

(<$) :: a -> WhenMatched f x y b -> WhenMatched f x y a

(Applicative f, Monad f) => Functor (WhenMissing f k x)

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

fmap :: (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b

(<$) :: a -> WhenMissing f k x b -> WhenMissing f k x a

Functor (Magma i t b)

Defined in Control.Lens.Internal.Magma

Methods

fmap :: (a -> b0) -> Magma i t b a -> Magma i t b b0

(<$) :: a -> Magma i t b b0 -> Magma i t b a

Functor (Molten i a b)

Defined in Control.Lens.Internal.Magma

Methods

fmap :: (a0 -> b0) -> Molten i a b a0 -> Molten i a b b0

(<$) :: a0 -> Molten i a b b0 -> Molten i a b a0

Functor (Exchange a b s)

Defined in Control.Lens.Internal.Iso

Methods

fmap :: (a0 -> b0) -> Exchange a b s a0 -> Exchange a b s b0

(<$) :: a0 -> Exchange a b s b0 -> Exchange a b s a0

Functor (Bazaar p a b)

Defined in Control.Lens.Internal.Bazaar

Methods

fmap :: (a0 -> b0) -> Bazaar p a b a0 -> Bazaar p a b b0

(<$) :: a0 -> Bazaar p a b b0 -> Bazaar p a b a0

Functor (Bazaar1 p a b)

Defined in Control.Lens.Internal.Bazaar

Methods

fmap :: (a0 -> b0) -> Bazaar1 p a b a0 -> Bazaar1 p a b b0

(<$) :: a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b a0

Functor (Pretext p a b)

Defined in Control.Lens.Internal.Context

Methods

fmap :: (a0 -> b0) -> Pretext p a b a0 -> Pretext p a b b0

(<$) :: a0 -> Pretext p a b b0 -> Pretext p a b a0

Functor m => Functor (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

fmap :: (a -> b) -> ReaderT r m a -> ReaderT r m b

(<$) :: a -> ReaderT r m b -> ReaderT r m a

Functor (ParsecT e s m)

Defined in Text.Megaparsec.Internal

Methods

fmap :: (a -> b) -> ParsecT e s m a -> ParsecT e s m b

(<$) :: a -> ParsecT e s m b -> ParsecT e s m a

Functor (ContT r m)

Defined in Control.Monad.Trans.Cont

Methods

fmap :: (a -> b) -> ContT r m a -> ContT r m b

(<$) :: a -> ContT r m b -> ContT r m a

Profunctor p => Functor (Procompose p q a)

Defined in Data.Profunctor.Composition

Methods

fmap :: (a0 -> b) -> Procompose p q a a0 -> Procompose p q a b

(<$) :: a0 -> Procompose p q a b -> Procompose p q a a0

Profunctor p => Functor (Rift p q a)

Defined in Data.Profunctor.Composition

Methods

fmap :: (a0 -> b) -> Rift p q a a0 -> Rift p q a b

(<$) :: a0 -> Rift p q a b -> Rift p q a a0

Functor f => Functor (M1 i c f)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> M1 i c f a -> M1 i c f b

(<$) :: a -> M1 i c f b -> M1 i c f a

(Functor f, Functor g) => Functor (f :.: g)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b

(<$) :: a -> (f :.: g) b -> (f :.: g) a

(Functor f, Functor g) => Functor (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

fmap :: (a -> b) -> Compose f g a -> Compose f g b

(<$) :: a -> Compose f g b -> Compose f g a

Bifunctor p => Functor (WrappedBifunctor p a)

Defined in Data.Bifunctor.Wrapped

Methods

fmap :: (a0 -> b) -> WrappedBifunctor p a a0 -> WrappedBifunctor p a b

(<$) :: a0 -> WrappedBifunctor p a b -> WrappedBifunctor p a a0

Functor g => Functor (Joker g a)

Defined in Data.Bifunctor.Joker

Methods

fmap :: (a0 -> b) -> Joker g a a0 -> Joker g a b

(<$) :: a0 -> Joker g a b -> Joker g a a0

Bifunctor p => Functor (Flip p a)

Defined in Data.Bifunctor.Flip

Methods

fmap :: (a0 -> b) -> Flip p a a0 -> Flip p a b

(<$) :: a0 -> Flip p a b -> Flip p a a0

Functor (Clown f a :: * -> *)

Defined in Data.Bifunctor.Clown

Methods

fmap :: (a0 -> b) -> Clown f a a0 -> Clown f a b

(<$) :: a0 -> Clown f a b -> Clown f a a0

Functor f => Functor (WhenMatched f k x y)

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

fmap :: (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b

(<$) :: a -> WhenMatched f k x y b -> WhenMatched f k x y a

Functor (TakingWhile p f a b)

Defined in Control.Lens.Internal.Magma

Methods

fmap :: (a0 -> b0) -> TakingWhile p f a b a0 -> TakingWhile p f a b b0

(<$) :: a0 -> TakingWhile p f a b b0 -> TakingWhile p f a b a0

Functor (BazaarT p g a b)

Defined in Control.Lens.Internal.Bazaar

Methods

fmap :: (a0 -> b0) -> BazaarT p g a b a0 -> BazaarT p g a b b0

(<$) :: a0 -> BazaarT p g a b b0 -> BazaarT p g a b a0

Functor (BazaarT1 p g a b)

Defined in Control.Lens.Internal.Bazaar

Methods

fmap :: (a0 -> b0) -> BazaarT1 p g a b a0 -> BazaarT1 p g a b b0

(<$) :: a0 -> BazaarT1 p g a b b0 -> BazaarT1 p g a b a0

Functor (PretextT p g a b)

Defined in Control.Lens.Internal.Context

Methods

fmap :: (a0 -> b0) -> PretextT p g a b a0 -> PretextT p g a b b0

(<$) :: a0 -> PretextT p g a b b0 -> PretextT p g a b a0

Reifies s (ReifiedApplicative f) => Functor (ReflectedApplicative f s)

Defined in Data.Reflection

Methods

fmap :: (a -> b) -> ReflectedApplicative f s a -> ReflectedApplicative f s b

(<$) :: a -> ReflectedApplicative f s b -> ReflectedApplicative f s a

(Functor f, Bifunctor p) => Functor (Tannen f p a)

Defined in Data.Bifunctor.Tannen

Methods

fmap :: (a0 -> b) -> Tannen f p a a0 -> Tannen f p a b

(<$) :: a0 -> Tannen f p a b -> Tannen f p a a0

(Bifunctor p, Functor g) => Functor (Biff p f g a)

Defined in Data.Bifunctor.Biff

Methods

fmap :: (a0 -> b) -> Biff p f g a a0 -> Biff p f g a b

(<$) :: a0 -> Biff p f g a b -> Biff p f g a a0

(<$>) :: 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 Int to a Maybe String using show:

>>> show <$> Nothing
Nothing
>>> show <$> Just 3
Just "3"

Convert from an Either Int Int to an Either Int String using show:

>>> show <$> Left 17
Left 17
>>> show <$> Right 17
Right "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)

($>) :: Functor f => f a -> b -> f b infixl 4

Flipped version of <$.

Examples

Replace the contents of a Maybe Int with a constant String:

>>> Nothing $> "foo"
Nothing
>>> Just 90210 $> "foo"
Just "foo"

Replace the contents of an Either Int Int with a constant String, resulting in an Either Int String:

>>> Left 8675309 $> "foo"
Left 8675309
>>> Right 8675309 $> "foo"
Right "foo"

Replace each element of a list with a constant String:

>>> [1,2,3] $> "foo"
["foo","foo","foo"]

Replace the second element of a pair with a constant String:

>>> (1,2) $> "foo"
(1,"foo")

Since: base-4.7.0.0

(<&>) :: Functor f => f a -> (a -> b) -> f b infixl 1

Flipped version of <$>.

(<&>) = flip fmap

Examples

Apply (+1) to a list, a Just and a Right:

>>> Just 2 <&> (+1)
Just 3

>>> [1,2,3] <&> (+1)
[2,3,4]

>>> Right 3 <&> (+1)
Right 4

Since: base-4.11.0.0

void :: Functor f => f a -> f ()

void value discards or ignores the result of evaluation, such as the return value of an IO action.

Examples

Replace the contents of a Maybe Int with unit:

>>> void Nothing
Nothing
>>> void (Just 3)
Just ()

Replace the contents of an Either Int Int with unit, resulting in an Either 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

unzip :: Functor f => f (a, b) -> (f a, f b)

The unzip function is the inverse of the zip function.

Optics

mapped :: Functor f => Setter (f a) (f b) a b

This Setter can be used to map over all of the values in a Functor.

fmap ≡ over mapped
fmapDefault ≡ over traverse
(<$) ≡ set mapped

>>> over mapped f [a,b,c]
[f a,f b,f c]

>>> over mapped (+1) [1,2,3]
[2,3,4]

>>> set mapped x [a,b,c]
[x,x,x]

>>> [[a,b],[c]] & mapped.mapped +~ x
[[a + x,b + x],[c + x]]

>>> over (mapped._2) length [("hello","world"),("leaders","!!!")]
[("hello",5),("leaders",3)]

mapped :: Functor f => Setter (f a) (f b) a b

If you want an IndexPreservingSetter use setting fmap.

Apply

class Functor f => Apply (f :: * -> *) where

A strong lax semi-monoidal endofunctor. This is equivalent to an Applicative without pure.

Laws:

(.) <$> u <.> v <.> w = u <.> (v <.> w)
x <.> (f <$> y) = (. f) <$> x <.> y
f <$> (x <.> y) = (f .) <$> x <.> y

The laws imply that .> and <. really ignore their left and right results, respectively, and really return their right and left results, respectively. Specifically,

(mf <$> m) .> (nf <$> n) = nf <$> (m .> n)
(mf <$> m) <. (nf <$> n) = mf <$> (m <. n)

Minimal complete definition

(<.>) | liftF2

Methods

(<.>) :: f (a -> b) -> f a -> f b infixl 4

(.>) :: f a -> f b -> f b infixl 4

 a .> b = const id <$> a <.> b

(<.) :: f a -> f b -> f a infixl 4

 a <. b = const <$> a <.> b

liftF2 :: (a -> b -> c) -> f a -> f b -> f c

Lift a binary function into a comonad with zipping

Instances

Apply []

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: [a -> b] -> [a] -> [b]

(.>) :: [a] -> [b] -> [b]

(<.) :: [a] -> [b] -> [a]

liftF2 :: (a -> b -> c) -> [a] -> [b] -> [c]

Apply Maybe

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Maybe (a -> b) -> Maybe a -> Maybe b

(.>) :: Maybe a -> Maybe b -> Maybe b

(<.) :: Maybe a -> Maybe b -> Maybe a

liftF2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c

Apply IO

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: IO (a -> b) -> IO a -> IO b

(.>) :: IO a -> IO b -> IO b

(<.) :: IO a -> IO b -> IO a

liftF2 :: (a -> b -> c) -> IO a -> IO b -> IO c

Apply Par1

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Par1 (a -> b) -> Par1 a -> Par1 b

(.>) :: Par1 a -> Par1 b -> Par1 b

(<.) :: Par1 a -> Par1 b -> Par1 a

liftF2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c

Apply Q

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Q (a -> b) -> Q a -> Q b

(.>) :: Q a -> Q b -> Q b

(<.) :: Q a -> Q b -> Q a

liftF2 :: (a -> b -> c) -> Q a -> Q b -> Q c

Apply Approximate

Defined in Data.Approximate.Type

Methods

(<.>) :: Approximate (a -> b) -> Approximate a -> Approximate b

(.>) :: Approximate a -> Approximate b -> Approximate b

(<.) :: Approximate a -> Approximate b -> Approximate a

liftF2 :: (a -> b -> c) -> Approximate a -> Approximate b -> Approximate c

Apply Complex

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Complex (a -> b) -> Complex a -> Complex b

(.>) :: Complex a -> Complex b -> Complex b

(<.) :: Complex a -> Complex b -> Complex a

liftF2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c

Apply Min

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Min (a -> b) -> Min a -> Min b

(.>) :: Min a -> Min b -> Min b

(<.) :: Min a -> Min b -> Min a

liftF2 :: (a -> b -> c) -> Min a -> Min b -> Min c

Apply Max

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Max (a -> b) -> Max a -> Max b

(.>) :: Max a -> Max b -> Max b

(<.) :: Max a -> Max b -> Max a

liftF2 :: (a -> b -> c) -> Max a -> Max b -> Max c

Apply First

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: First (a -> b) -> First a -> First b

(.>) :: First a -> First b -> First b

(<.) :: First a -> First b -> First a

liftF2 :: (a -> b -> c) -> First a -> First b -> First c

Apply Last

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Last (a -> b) -> Last a -> Last b

(.>) :: Last a -> Last b -> Last b

(<.) :: Last a -> Last b -> Last a

liftF2 :: (a -> b -> c) -> Last a -> Last b -> Last c

Apply Option

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Option (a -> b) -> Option a -> Option b

(.>) :: Option a -> Option b -> Option b

(<.) :: Option a -> Option b -> Option a

liftF2 :: (a -> b -> c) -> Option a -> Option b -> Option c

Apply ZipList

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: ZipList (a -> b) -> ZipList a -> ZipList b

(.>) :: ZipList a -> ZipList b -> ZipList b

(<.) :: ZipList a -> ZipList b -> ZipList a

liftF2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c

Apply Identity

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Identity (a -> b) -> Identity a -> Identity b

(.>) :: Identity a -> Identity b -> Identity b

(<.) :: Identity a -> Identity b -> Identity a

liftF2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c

Apply First

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: First (a -> b) -> First a -> First b

(.>) :: First a -> First b -> First b

(<.) :: First a -> First b -> First a

liftF2 :: (a -> b -> c) -> First a -> First b -> First c

Apply Last

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Last (a -> b) -> Last a -> Last b

(.>) :: Last a -> Last b -> Last b

(<.) :: Last a -> Last b -> Last a

liftF2 :: (a -> b -> c) -> Last a -> Last b -> Last c

Apply Dual

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Dual (a -> b) -> Dual a -> Dual b

(.>) :: Dual a -> Dual b -> Dual b

(<.) :: Dual a -> Dual b -> Dual a

liftF2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c

Apply Sum

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Sum (a -> b) -> Sum a -> Sum b

(.>) :: Sum a -> Sum b -> Sum b

(<.) :: Sum a -> Sum b -> Sum a

liftF2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c

Apply Product

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Product (a -> b) -> Product a -> Product b

(.>) :: Product a -> Product b -> Product b

(<.) :: Product a -> Product b -> Product a

liftF2 :: (a -> b -> c) -> Product a -> Product b -> Product c

Apply Down

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Down (a -> b) -> Down a -> Down b

(.>) :: Down a -> Down b -> Down b

(<.) :: Down a -> Down b -> Down a

liftF2 :: (a -> b -> c) -> Down a -> Down b -> Down c

Apply NonEmpty

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b

(.>) :: NonEmpty a -> NonEmpty b -> NonEmpty b

(<.) :: NonEmpty a -> NonEmpty b -> NonEmpty a

liftF2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c

Apply IntMap

An IntMap is not Applicative, but it is an instance of Apply

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: IntMap (a -> b) -> IntMap a -> IntMap b

(.>) :: IntMap a -> IntMap b -> IntMap b

(<.) :: IntMap a -> IntMap b -> IntMap a

liftF2 :: (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c

Apply Tree

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Tree (a -> b) -> Tree a -> Tree b

(.>) :: Tree a -> Tree b -> Tree b

(<.) :: Tree a -> Tree b -> Tree a

liftF2 :: (a -> b -> c) -> Tree a -> Tree b -> Tree c

Apply Seq

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Seq (a -> b) -> Seq a -> Seq b

(.>) :: Seq a -> Seq b -> Seq b

(<.) :: Seq a -> Seq b -> Seq a

liftF2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c

Apply Log

Defined in Numeric.Log

Methods

(<.>) :: Log (a -> b) -> Log a -> Log b

(.>) :: Log a -> Log b -> Log b

(<.) :: Log a -> Log b -> Log a

liftF2 :: (a -> b -> c) -> Log a -> Log b -> Log c

Apply (Either a)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Either a (a0 -> b) -> Either a a0 -> Either a b

(.>) :: Either a a0 -> Either a b -> Either a b

(<.) :: Either a a0 -> Either a b -> Either a a0

liftF2 :: (a0 -> b -> c) -> Either a a0 -> Either a b -> Either a c

Apply (V1 :: * -> *)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: V1 (a -> b) -> V1 a -> V1 b

(.>) :: V1 a -> V1 b -> V1 b

(<.) :: V1 a -> V1 b -> V1 a

liftF2 :: (a -> b -> c) -> V1 a -> V1 b -> V1 c

Apply (U1 :: * -> *)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: U1 (a -> b) -> U1 a -> U1 b

(.>) :: U1 a -> U1 b -> U1 b

(<.) :: U1 a -> U1 b -> U1 a

liftF2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c

Semigroup m => Apply ((,) m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: (m, a -> b) -> (m, a) -> (m, b)

(.>) :: (m, a) -> (m, b) -> (m, b)

(<.) :: (m, a) -> (m, b) -> (m, a)

liftF2 :: (a -> b -> c) -> (m, a) -> (m, b) -> (m, c)

Representable f => Apply (Co f)

Defined in Data.Functor.Rep

Methods

(<.>) :: Co f (a -> b) -> Co f a -> Co f b

(.>) :: Co f a -> Co f b -> Co f b

(<.) :: Co f a -> Co f b -> Co f a

liftF2 :: (a -> b -> c) -> Co f a -> Co f b -> Co f c

(Hashable k, Eq k) => Apply (HashMap k)

A HashMap is not Applicative, but it is an instance of Apply

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: HashMap k (a -> b) -> HashMap k a -> HashMap k b

(.>) :: HashMap k a -> HashMap k b -> HashMap k b

(<.) :: HashMap k a -> HashMap k b -> HashMap k a

liftF2 :: (a -> b -> c) -> HashMap k a -> HashMap k b -> HashMap k c

Ord k => Apply (Map k)

A Map is not Applicative, but it is an instance of Apply

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Map k (a -> b) -> Map k a -> Map k b

(.>) :: Map k a -> Map k b -> Map k b

(<.) :: Map k a -> Map k b -> Map k a

liftF2 :: (a -> b -> c) -> Map k a -> Map k b -> Map k c

Monad m => Apply (WrappedMonad m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b

(.>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b

(<.) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a

liftF2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c

Apply (Proxy :: * -> *)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Proxy (a -> b) -> Proxy a -> Proxy b

(.>) :: Proxy a -> Proxy b -> Proxy b

(<.) :: Proxy a -> Proxy b -> Proxy a

liftF2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c

(Functor m, Monad m) => Apply (MaybeT m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b

(.>) :: MaybeT m a -> MaybeT m b -> MaybeT m b

(<.) :: MaybeT m a -> MaybeT m b -> MaybeT m a

liftF2 :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c

Apply f => Apply (Cofree f)

Defined in Control.Comonad.Cofree

Methods

(<.>) :: Cofree f (a -> b) -> Cofree f a -> Cofree f b

(.>) :: Cofree f a -> Cofree f b -> Cofree f b

(<.) :: Cofree f a -> Cofree f b -> Cofree f a

liftF2 :: (a -> b -> c) -> Cofree f a -> Cofree f b -> Cofree f c

Functor f => Apply (Free f)

Defined in Control.Monad.Free

Methods

(<.>) :: Free f (a -> b) -> Free f a -> Free f b

(.>) :: Free f a -> Free f b -> Free f b

(<.) :: Free f a -> Free f b -> Free f a

liftF2 :: (a -> b -> c) -> Free f a -> Free f b -> Free f c

Apply (Ap f)

Defined in Control.Applicative.Free

Methods

(<.>) :: Ap f (a -> b) -> Ap f a -> Ap f b

(.>) :: Ap f a -> Ap f b -> Ap f b

(<.) :: Ap f a -> Ap f b -> Ap f a

liftF2 :: (a -> b -> c) -> Ap f a -> Ap f b -> Ap f c

Apply f => Apply (Yoneda f)

Defined in Data.Functor.Yoneda

Methods

(<.>) :: Yoneda f (a -> b) -> Yoneda f a -> Yoneda f b

(.>) :: Yoneda f a -> Yoneda f b -> Yoneda f b

(<.) :: Yoneda f a -> Yoneda f b -> Yoneda f a

liftF2 :: (a -> b -> c) -> Yoneda f a -> Yoneda f b -> Yoneda f c

Apply (ReifiedGetter s)

Defined in Control.Lens.Reified

Methods

(<.>) :: ReifiedGetter s (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b

(.>) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s b

(<.) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s a

liftF2 :: (a -> b -> c) -> ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s c

Apply (ReifiedFold s)

Defined in Control.Lens.Reified

Methods

(<.>) :: ReifiedFold s (a -> b) -> ReifiedFold s a -> ReifiedFold s b

(.>) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s b

(<.) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s a

liftF2 :: (a -> b -> c) -> ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s c

Apply f => Apply (Indexing f)

Defined in Control.Lens.Internal.Indexed

Methods

(<.>) :: Indexing f (a -> b) -> Indexing f a -> Indexing f b

(.>) :: Indexing f a -> Indexing f b -> Indexing f b

(<.) :: Indexing f a -> Indexing f b -> Indexing f a

liftF2 :: (a -> b -> c) -> Indexing f a -> Indexing f b -> Indexing f c

Apply f => Apply (Indexing64 f)

Defined in Control.Lens.Internal.Indexed

Methods

(<.>) :: Indexing64 f (a -> b) -> Indexing64 f a -> Indexing64 f b

(.>) :: Indexing64 f a -> Indexing64 f b -> Indexing64 f b

(<.) :: Indexing64 f a -> Indexing64 f b -> Indexing64 f a

liftF2 :: (a -> b -> c) -> Indexing64 f a -> Indexing64 f b -> Indexing64 f c

Apply m => Apply (ListT m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: ListT m (a -> b) -> ListT m a -> ListT m b

(.>) :: ListT m a -> ListT m b -> ListT m b

(<.) :: ListT m a -> ListT m b -> ListT m a

liftF2 :: (a -> b -> c) -> ListT m a -> ListT m b -> ListT m c

Applicative f => Apply (WrappedApplicative f)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: WrappedApplicative f (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b

(.>) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f b

(<.) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f a

liftF2 :: (a -> b -> c) -> WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f c

Apply f => Apply (MaybeApply f)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b

(.>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b

(<.) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a

liftF2 :: (a -> b -> c) -> MaybeApply f a -> MaybeApply f b -> MaybeApply f c

Apply f => Apply (Lift f)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Lift f (a -> b) -> Lift f a -> Lift f b

(.>) :: Lift f a -> Lift f b -> Lift f b

(<.) :: Lift f a -> Lift f b -> Lift f a

liftF2 :: (a -> b -> c) -> Lift f a -> Lift f b -> Lift f c

Apply f => Apply (Rec1 f)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b

(.>) :: Rec1 f a -> Rec1 f b -> Rec1 f b

(<.) :: Rec1 f a -> Rec1 f b -> Rec1 f a

liftF2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c

Arrow a => Apply (WrappedArrow a b)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0

(.>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0

(<.) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0

liftF2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c

Semigroup m => Apply (Const m :: * -> *)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Const m (a -> b) -> Const m a -> Const m b

(.>) :: Const m a -> Const m b -> Const m b

(<.) :: Const m a -> Const m b -> Const m a

liftF2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c

Apply f => Apply (Alt f)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Alt f (a -> b) -> Alt f a -> Alt f b

(.>) :: Alt f a -> Alt f b -> Alt f b

(<.) :: Alt f a -> Alt f b -> Alt f a

liftF2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c

Biapply p => Apply (Join p)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Join p (a -> b) -> Join p a -> Join p b

(.>) :: Join p a -> Join p b -> Join p b

(<.) :: Join p a -> Join p b -> Join p a

liftF2 :: (a -> b -> c) -> Join p a -> Join p b -> Join p c

Apply w => Apply (TracedT m w)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: TracedT m w (a -> b) -> TracedT m w a -> TracedT m w b

(.>) :: TracedT m w a -> TracedT m w b -> TracedT m w b

(<.) :: TracedT m w a -> TracedT m w b -> TracedT m w a

liftF2 :: (a -> b -> c) -> TracedT m w a -> TracedT m w b -> TracedT m w c

(Apply w, Semigroup s) => Apply (StoreT s w)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: StoreT s w (a -> b) -> StoreT s w a -> StoreT s w b

(.>) :: StoreT s w a -> StoreT s w b -> StoreT s w b

(<.) :: StoreT s w a -> StoreT s w b -> StoreT s w a

liftF2 :: (a -> b -> c) -> StoreT s w a -> StoreT s w b -> StoreT s w c

(Semigroup e, Apply w) => Apply (EnvT e w)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: EnvT e w (a -> b) -> EnvT e w a -> EnvT e w b

(.>) :: EnvT e w a -> EnvT e w b -> EnvT e w b

(<.) :: EnvT e w a -> EnvT e w b -> EnvT e w a

liftF2 :: (a -> b -> c) -> EnvT e w a -> EnvT e w b -> EnvT e w c

Apply w => Apply (IdentityT w)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: IdentityT w (a -> b) -> IdentityT w a -> IdentityT w b

(.>) :: IdentityT w a -> IdentityT w b -> IdentityT w b

(<.) :: IdentityT w a -> IdentityT w b -> IdentityT w a

liftF2 :: (a -> b -> c) -> IdentityT w a -> IdentityT w b -> IdentityT w c

(Functor m, Monad m) => Apply (ExceptT e m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b

(.>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b

(<.) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a

liftF2 :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c

(Functor f, Monad m) => Apply (FreeT f m)

Defined in Control.Monad.Trans.Free

Methods

(<.>) :: FreeT f m (a -> b) -> FreeT f m a -> FreeT f m b

(.>) :: FreeT f m a -> FreeT f m b -> FreeT f m b

(<.) :: FreeT f m a -> FreeT f m b -> FreeT f m a

liftF2 :: (a -> b -> c) -> FreeT f m a -> FreeT f m b -> FreeT f m c

(Functor m, Monad m) => Apply (ErrorT e m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: ErrorT e m (a -> b) -> ErrorT e m a -> ErrorT e m b

(.>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b

(<.) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m a

liftF2 :: (a -> b -> c) -> ErrorT e m a -> ErrorT e m b -> ErrorT e m c

Apply f => Apply (Backwards f)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Backwards f (a -> b) -> Backwards f a -> Backwards f b

(.>) :: Backwards f a -> Backwards f b -> Backwards f b

(<.) :: Backwards f a -> Backwards f b -> Backwards f a

liftF2 :: (a -> b -> c) -> Backwards f a -> Backwards f b -> Backwards f c

Semigroup i => Apply (ReifiedIndexedGetter i s)

Defined in Control.Lens.Reified

Methods

(<.>) :: ReifiedIndexedGetter i s (a -> b) -> ReifiedIndexedGetter i s a -> ReifiedIndexedGetter i s b

(.>) :: ReifiedIndexedGetter i s a -> ReifiedIndexedGetter i s b -> ReifiedIndexedGetter i s b

(<.) :: ReifiedIndexedGetter i s a -> ReifiedIndexedGetter i s b -> ReifiedIndexedGetter i s a

liftF2 :: (a -> b -> c) -> ReifiedIndexedGetter i s a -> ReifiedIndexedGetter i s b -> ReifiedIndexedGetter i s c

Apply (Mafic a b)

Defined in Control.Lens.Internal.Magma

Methods

(<.>) :: Mafic a b (a0 -> b0) -> Mafic a b a0 -> Mafic a b b0

(.>) :: Mafic a b a0 -> Mafic a b b0 -> Mafic a b b0

(<.) :: Mafic a b a0 -> Mafic a b b0 -> Mafic a b a0

liftF2 :: (a0 -> b0 -> c) -> Mafic a b a0 -> Mafic a b b0 -> Mafic a b c

Apply (Indexed i a)

Defined in Control.Lens.Internal.Indexed

Methods

(<.>) :: Indexed i a (a0 -> b) -> Indexed i a a0 -> Indexed i a b

(.>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b

(<.) :: Indexed i a a0 -> Indexed i a b -> Indexed i a a0

liftF2 :: (a0 -> b -> c) -> Indexed i a a0 -> Indexed i a b -> Indexed i a c

(Apply m, Semigroup w) => Apply (WriterT w m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b

(.>) :: WriterT w m a -> WriterT w m b -> WriterT w m b

(<.) :: WriterT w m a -> WriterT w m b -> WriterT w m a

liftF2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c

Bind m => Apply (StateT s m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b

(.>) :: StateT s m a -> StateT s m b -> StateT s m b

(<.) :: StateT s m a -> StateT s m b -> StateT s m a

liftF2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c

Bind m => Apply (StateT s m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b

(.>) :: StateT s m a -> StateT s m b -> StateT s m b

(<.) :: StateT s m a -> StateT s m b -> StateT s m a

liftF2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c

(Apply m, Semigroup w) => Apply (WriterT w m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b

(.>) :: WriterT w m a -> WriterT w m b -> WriterT w m b

(<.) :: WriterT w m a -> WriterT w m b -> WriterT w m a

liftF2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c

Apply f => Apply (Static f a)

Defined in Data.Semigroupoid.Static

Methods

(<.>) :: Static f a (a0 -> b) -> Static f a a0 -> Static f a b

(.>) :: Static f a a0 -> Static f a b -> Static f a b

(<.) :: Static f a a0 -> Static f a b -> Static f a a0

liftF2 :: (a0 -> b -> c) -> Static f a a0 -> Static f a b -> Static f a c

Apply (Tagged a)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Tagged a (a0 -> b) -> Tagged a a0 -> Tagged a b

(.>) :: Tagged a a0 -> Tagged a b -> Tagged a b

(<.) :: Tagged a a0 -> Tagged a b -> Tagged a a0

liftF2 :: (a0 -> b -> c) -> Tagged a a0 -> Tagged a b -> Tagged a c

Apply f => Apply (Reverse f)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Reverse f (a -> b) -> Reverse f a -> Reverse f b

(.>) :: Reverse f a -> Reverse f b -> Reverse f b

(<.) :: Reverse f a -> Reverse f b -> Reverse f a

liftF2 :: (a -> b -> c) -> Reverse f a -> Reverse f b -> Reverse f c

Semigroup f => Apply (Constant f :: * -> *)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Constant f (a -> b) -> Constant f a -> Constant f b

(.>) :: Constant f a -> Constant f b -> Constant f b

(<.) :: Constant f a -> Constant f b -> Constant f a

liftF2 :: (a -> b -> c) -> Constant f a -> Constant f b -> Constant f c

Apply ((->) m :: * -> *)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: (m -> a -> b) -> (m -> a) -> m -> b

(.>) :: (m -> a) -> (m -> b) -> m -> b

(<.) :: (m -> a) -> (m -> b) -> m -> a

liftF2 :: (a -> b -> c) -> (m -> a) -> (m -> b) -> m -> c

Semigroup c => Apply (K1 i c :: * -> *)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b

(.>) :: K1 i c a -> K1 i c b -> K1 i c b

(<.) :: K1 i c a -> K1 i c b -> K1 i c a

liftF2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0

(Apply f, Apply g) => Apply (f :*: g)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: (f :*: g) (a -> b) -> (f :*: g) a -> (f :*: g) b

(.>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b

(<.) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) a

liftF2 :: (a -> b -> c) -> (f :*: g) a -> (f :*: g) b -> (f :*: g) c

(Apply f, Apply g) => Apply (Product f g)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Product f g (a -> b) -> Product f g a -> Product f g b

(.>) :: Product f g a -> Product f g b -> Product f g b

(<.) :: Product f g a -> Product f g b -> Product f g a

liftF2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c

Apply (Cokleisli w a)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Cokleisli w a (a0 -> b) -> Cokleisli w a a0 -> Cokleisli w a b

(.>) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a b

(<.) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a a0

liftF2 :: (a0 -> b -> c) -> Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a c

Apply (Molten i a b)

Defined in Control.Lens.Internal.Magma

Methods

(<.>) :: Molten i a b (a0 -> b0) -> Molten i a b a0 -> Molten i a b b0

(.>) :: Molten i a b a0 -> Molten i a b b0 -> Molten i a b b0

(<.) :: Molten i a b a0 -> Molten i a b b0 -> Molten i a b a0

liftF2 :: (a0 -> b0 -> c) -> Molten i a b a0 -> Molten i a b b0 -> Molten i a b c

Apply (Bazaar p a b)

Defined in Control.Lens.Internal.Bazaar

Methods

(<.>) :: Bazaar p a b (a0 -> b0) -> Bazaar p a b a0 -> Bazaar p a b b0

(.>) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b b0

(<.) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b a0

liftF2 :: (a0 -> b0 -> c) -> Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b c

Apply (Bazaar1 p a b)

Defined in Control.Lens.Internal.Bazaar

Methods

(<.>) :: Bazaar1 p a b (a0 -> b0) -> Bazaar1 p a b a0 -> Bazaar1 p a b b0

(.>) :: Bazaar1 p a b a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b b0

(<.) :: Bazaar1 p a b a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b a0

liftF2 :: (a0 -> b0 -> c) -> Bazaar1 p a b a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b c

Apply m => Apply (ReaderT e m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: ReaderT e m (a -> b) -> ReaderT e m a -> ReaderT e m b

(.>) :: ReaderT e m a -> ReaderT e m b -> ReaderT e m b

(<.) :: ReaderT e m a -> ReaderT e m b -> ReaderT e m a

liftF2 :: (a -> b -> c) -> ReaderT e m a -> ReaderT e m b -> ReaderT e m c

Apply (ContT r m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: ContT r m (a -> b) -> ContT r m a -> ContT r m b

(.>) :: ContT r m a -> ContT r m b -> ContT r m b

(<.) :: ContT r m a -> ContT r m b -> ContT r m a

liftF2 :: (a -> b -> c) -> ContT r m a -> ContT r m b -> ContT r m c

Apply f => Apply (M1 i t f)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: M1 i t f (a -> b) -> M1 i t f a -> M1 i t f b

(.>) :: M1 i t f a -> M1 i t f b -> M1 i t f b

(<.) :: M1 i t f a -> M1 i t f b -> M1 i t f a

liftF2 :: (a -> b -> c) -> M1 i t f a -> M1 i t f b -> M1 i t f c

(Apply f, Apply g) => Apply (f :.: g)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b

(.>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b

(<.) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a

liftF2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c

(Apply f, Apply g) => Apply (Compose f g)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b

(.>) :: Compose f g a -> Compose f g b -> Compose f g b

(<.) :: Compose f g a -> Compose f g b -> Compose f g a

liftF2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c

Apply (TakingWhile p f a b)

Defined in Control.Lens.Internal.Magma

Methods

(<.>) :: TakingWhile p f a b (a0 -> b0) -> TakingWhile p f a b a0 -> TakingWhile p f a b b0

(.>) :: TakingWhile p f a b a0 -> TakingWhile p f a b b0 -> TakingWhile p f a b b0

(<.) :: TakingWhile p f a b a0 -> TakingWhile p f a b b0 -> TakingWhile p f a b a0

liftF2 :: (a0 -> b0 -> c) -> TakingWhile p f a b a0 -> TakingWhile p f a b b0 -> TakingWhile p f a b c

Apply (BazaarT p g a b)

Defined in Control.Lens.Internal.Bazaar

Methods

(<.>) :: BazaarT p g a b (a0 -> b0) -> BazaarT p g a b a0 -> BazaarT p g a b b0

(.>) :: BazaarT p g a b a0 -> BazaarT p g a b b0 -> BazaarT p g a b b0

(<.) :: BazaarT p g a b a0 -> BazaarT p g a b b0 -> BazaarT p g a b a0

liftF2 :: (a0 -> b0 -> c) -> BazaarT p g a b a0 -> BazaarT p g a b b0 -> BazaarT p g a b c

Apply (BazaarT1 p g a b)

Defined in Control.Lens.Internal.Bazaar

Methods

(<.>) :: BazaarT1 p g a b (a0 -> b0) -> BazaarT1 p g a b a0 -> BazaarT1 p g a b b0

(.>) :: BazaarT1 p g a b a0 -> BazaarT1 p g a b b0 -> BazaarT1 p g a b b0

(<.) :: BazaarT1 p g a b a0 -> BazaarT1 p g a b b0 -> BazaarT1 p g a b a0

liftF2 :: (a0 -> b0 -> c) -> BazaarT1 p g a b a0 -> BazaarT1 p g a b b0 -> BazaarT1 p g a b c

(Bind m, Semigroup w) => Apply (RWST r w s m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b

(.>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b

(<.) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a

liftF2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c

(Bind m, Semigroup w) => Apply (RWST r w s m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b

(.>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b

(<.) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a

liftF2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c

liftF3 :: Apply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w d

Lift a ternary function into a comonad with zipping

Newtypes

newtype MaybeApply (f :: * -> *) a

Transform a Apply into an Applicative by adding a unit.

Constructors

MaybeApply

Fields

• runMaybeApply :: Either (f a) a

Instances

Functor f => Functor (MaybeApply f)

Defined in Data.Functor.Bind.Class

Methods

fmap :: (a -> b) -> MaybeApply f a -> MaybeApply f b

(<$) :: a -> MaybeApply f b -> MaybeApply f a

Apply f => Applicative (MaybeApply f)

Defined in Data.Functor.Bind.Class

Methods

pure :: a -> MaybeApply f a

(<*>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b

liftA2 :: (a -> b -> c) -> MaybeApply f a -> MaybeApply f b -> MaybeApply f c

(*>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b

(<*) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a

Comonad f => Comonad (MaybeApply f)

Defined in Data.Functor.Bind.Class

Methods

extract :: MaybeApply f a -> a

duplicate :: MaybeApply f a -> MaybeApply f (MaybeApply f a)

extend :: (MaybeApply f a -> b) -> MaybeApply f a -> MaybeApply f b

Apply f => Apply (MaybeApply f)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b

(.>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b

(<.) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a

liftF2 :: (a -> b -> c) -> MaybeApply f a -> MaybeApply f b -> MaybeApply f c

Pointed (MaybeApply f)

Defined in Data.Pointed

Methods

point :: a -> MaybeApply f a

Copointed f => Copointed (MaybeApply f)

Defined in Data.Copointed

Methods

copoint :: MaybeApply f a -> a

Extend f => Extend (MaybeApply f)

Defined in Data.Functor.Bind.Class

Methods

duplicated :: MaybeApply f a -> MaybeApply f (MaybeApply f a)

extended :: (MaybeApply f a -> b) -> MaybeApply f a -> MaybeApply f b

Wrapped (MaybeApply f a)

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped (MaybeApply f a) :: *

Methods

_Wrapped' :: Iso' (MaybeApply f a) (Unwrapped (MaybeApply f a))

t ~ MaybeApply f' a' => Rewrapped (MaybeApply f a) t

Defined in Control.Lens.Wrapped

type Unwrapped (MaybeApply f a)

Defined in Control.Lens.Wrapped

type Unwrapped (MaybeApply f a) = Either (f a) a

newtype Static (f :: * -> *) a b

Constructors

Static

Fields

• runStatic :: f (a -> b)

Instances

Applicative f => Arrow (Static f)

Defined in Data.Semigroupoid.Static

Methods

arr :: (b -> c) -> Static f b c

first :: Static f b c -> Static f (b, d) (c, d)

second :: Static f b c -> Static f (d, b) (d, c)

(***) :: Static f b c -> Static f b' c' -> Static f (b, b') (c, c')

(&&&) :: Static f b c -> Static f b c' -> Static f b (c, c')

Alternative f => ArrowZero (Static f)

Defined in Data.Semigroupoid.Static

Methods

zeroArrow :: Static f b c

Alternative f => ArrowPlus (Static f)

Defined in Data.Semigroupoid.Static

Methods

(<+>) :: Static f b c -> Static f b c -> Static f b c

Applicative f => ArrowChoice (Static f)

Defined in Data.Semigroupoid.Static

Methods

left :: Static f b c -> Static f (Either b d) (Either c d)

right :: Static f b c -> Static f (Either d b) (Either d c)

(+++) :: Static f b c -> Static f b' c' -> Static f (Either b b') (Either c c')

(|||) :: Static f b d -> Static f c d -> Static f (Either b c) d

Applicative f => Category (Static f :: * -> * -> *)

Defined in Data.Semigroupoid.Static

Methods

id :: Static f a a

(.) :: Static f b c -> Static f a b -> Static f a c

Apply f => Semigroupoid (Static f :: * -> * -> *)

Defined in Data.Semigroupoid.Static

Methods

o :: Static f j k1 -> Static f i j -> Static f i k1

Functor f => Functor (Static f a)

Defined in Data.Semigroupoid.Static

Methods

fmap :: (a0 -> b) -> Static f a a0 -> Static f a b

(<$) :: a0 -> Static f a b -> Static f a a0

Applicative f => Applicative (Static f a)

Defined in Data.Semigroupoid.Static

Methods

pure :: a0 -> Static f a a0

(<*>) :: Static f a (a0 -> b) -> Static f a a0 -> Static f a b

liftA2 :: (a0 -> b -> c) -> Static f a a0 -> Static f a b -> Static f a c

(*>) :: Static f a a0 -> Static f a b -> Static f a b

(<*) :: Static f a a0 -> Static f a b -> Static f a a0

(Comonad f, Monoid a) => Comonad (Static f a)

Defined in Data.Semigroupoid.Static

Methods

extract :: Static f a a0 -> a0

duplicate :: Static f a a0 -> Static f a (Static f a a0)

extend :: (Static f a a0 -> b) -> Static f a a0 -> Static f a b

Apply f => Apply (Static f a)

Defined in Data.Semigroupoid.Static

Methods

(<.>) :: Static f a (a0 -> b) -> Static f a a0 -> Static f a b

(.>) :: Static f a a0 -> Static f a b -> Static f a b

(<.) :: Static f a a0 -> Static f a b -> Static f a a0

liftF2 :: (a0 -> b -> c) -> Static f a a0 -> Static f a b -> Static f a c

Pointed m => Pointed (Static m a)

Defined in Data.Pointed

Methods

point :: a0 -> Static m a a0

Plus f => Plus (Static f a)

Defined in Data.Semigroupoid.Static

Methods

zero :: Static f a a0

Alt f => Alt (Static f a)

Defined in Data.Semigroupoid.Static

Methods

(<!>) :: Static f a a0 -> Static f a a0 -> Static f a a0

some :: Applicative (Static f a) => Static f a a0 -> Static f a [a0]

many :: Applicative (Static f a) => Static f a a0 -> Static f a [a0]

(Extend f, Semigroup a) => Extend (Static f a)

Defined in Data.Semigroupoid.Static

Methods

duplicated :: Static f a a0 -> Static f a (Static f a a0)

extended :: (Static f a a0 -> b) -> Static f a a0 -> Static f a b

Wrapped (Static f a b)

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped (Static f a b) :: *

Methods

_Wrapped' :: Iso' (Static f a b) (Unwrapped (Static f a b))

t ~ Static f' a' b' => Rewrapped (Static f a b) t

Defined in Control.Lens.Wrapped

type Unwrapped (Static f a b)

Defined in Control.Lens.Wrapped

type Unwrapped (Static f a b) = f (a -> b)

Alt

class Functor f => Alt (f :: * -> *) where

Laws:

<!> is associative:             (a <!> b) <!> c = a <!> (b <!> c)
<$> left-distributes over <!>:  f <$> (a <!> b) = (f <$> a) <!> (f <$> b)

If extended to an Alternative then <!> should equal <|>.

Ideally, an instance of Alt also satisfies the "left distributon" law of MonadPlus with respect to <.>:

<.> right-distributes over <!>: (a <!> b) <.> c = (a <.> c) <!> (b <.> c)

But Maybe, IO, Either a, ErrorT e m, and STM satisfy the alternative "left catch" law instead:

pure a <!> b = pure a

However, this variation cannot be stated purely in terms of the dependencies of Alt.

When and if MonadPlus is successfully refactored, this class should also be refactored to remove these instances.

The right distributive law should extend in the cases where the a Bind or Monad is provided to yield variations of the right distributive law:

(m <!> n) >>- f = (m >>- f) <!> (m >>- f)
(m <!> n) >>= f = (m >>= f) <!> (m >>= f)

Minimal complete definition

(<!>)

Methods

(<!>) :: f a -> f a -> f a infixl 3

<|> without a required empty

Instances

Alt []

Defined in Data.Functor.Alt

Methods

(<!>) :: [a] -> [a] -> [a]

some :: Applicative [] => [a] -> [[a]]

many :: Applicative [] => [a] -> [[a]]

Alt Maybe

Defined in Data.Functor.Alt

Methods

(<!>) :: Maybe a -> Maybe a -> Maybe a

some :: Applicative Maybe => Maybe a -> Maybe [a]

many :: Applicative Maybe => Maybe a -> Maybe [a]

Alt IO

This instance does not actually satisfy the (<.>) right distributive law It instead satisfies the "Left-Catch" law

Defined in Data.Functor.Alt

Methods

(<!>) :: IO a -> IO a -> IO a

some :: Applicative IO => IO a -> IO [a]

many :: Applicative IO => IO a -> IO [a]

Alt First

Defined in Data.Functor.Alt

Methods

(<!>) :: First a -> First a -> First a

some :: Applicative First => First a -> First [a]

many :: Applicative First => First a -> First [a]

Alt Last

Defined in Data.Functor.Alt

Methods

(<!>) :: Last a -> Last a -> Last a

some :: Applicative Last => Last a -> Last [a]

many :: Applicative Last => Last a -> Last [a]

Alt Option

Defined in Data.Functor.Alt

Methods

(<!>) :: Option a -> Option a -> Option a

some :: Applicative Option => Option a -> Option [a]

many :: Applicative Option => Option a -> Option [a]

Alt First

Defined in Data.Functor.Alt

Methods

(<!>) :: First a -> First a -> First a

some :: Applicative First => First a -> First [a]

many :: Applicative First => First a -> First [a]

Alt Last

Defined in Data.Functor.Alt

Methods

(<!>) :: Last a -> Last a -> Last a

some :: Applicative Last => Last a -> Last [a]

many :: Applicative Last => Last a -> Last [a]

Alt NonEmpty

Defined in Data.Functor.Alt

Methods

(<!>) :: NonEmpty a -> NonEmpty a -> NonEmpty a

some :: Applicative NonEmpty => NonEmpty a -> NonEmpty [a]

many :: Applicative NonEmpty => NonEmpty a -> NonEmpty [a]

Alt IntMap

Defined in Data.Functor.Alt

Methods

(<!>) :: IntMap a -> IntMap a -> IntMap a

some :: Applicative IntMap => IntMap a -> IntMap [a]

many :: Applicative IntMap => IntMap a -> IntMap [a]

Alt Seq

Defined in Data.Functor.Alt

Methods

(<!>) :: Seq a -> Seq a -> Seq a

some :: Applicative Seq => Seq a -> Seq [a]

many :: Applicative Seq => Seq a -> Seq [a]

Alt (Either a)

Defined in Data.Functor.Alt

Methods

(<!>) :: Either a a0 -> Either a a0 -> Either a a0

some :: Applicative (Either a) => Either a a0 -> Either a [a0]

many :: Applicative (Either a) => Either a a0 -> Either a [a0]

Alt (V1 :: * -> *)

Defined in Data.Functor.Alt

Methods

(<!>) :: V1 a -> V1 a -> V1 a

some :: Applicative V1 => V1 a -> V1 [a]

many :: Applicative V1 => V1 a -> V1 [a]

Alt (U1 :: * -> *)

Defined in Data.Functor.Alt

Methods

(<!>) :: U1 a -> U1 a -> U1 a

some :: Applicative U1 => U1 a -> U1 [a]

many :: Applicative U1 => U1 a -> U1 [a]

Ord k => Alt (Map k)

Defined in Data.Functor.Alt

Methods

(<!>) :: Map k a -> Map k a -> Map k a

some :: Applicative (Map k) => Map k a -> Map k [a]

many :: Applicative (Map k) => Map k a -> Map k [a]

MonadPlus m => Alt (WrappedMonad m)

Defined in Data.Functor.Alt

Methods

(<!>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a

some :: Applicative (WrappedMonad m) => WrappedMonad m a -> WrappedMonad m [a]

many :: Applicative (WrappedMonad m) => WrappedMonad m a -> WrappedMonad m [a]

Alt (Proxy :: * -> *)

Defined in Data.Functor.Alt

Methods

(<!>) :: Proxy a -> Proxy a -> Proxy a

some :: Applicative Proxy => Proxy a -> Proxy [a]

many :: Applicative Proxy => Proxy a -> Proxy [a]

(Bind f, Monad f) => Alt (MaybeT f)

Defined in Data.Functor.Alt

Methods

(<!>) :: MaybeT f a -> MaybeT f a -> MaybeT f a

some :: Applicative (MaybeT f) => MaybeT f a -> MaybeT f [a]

many :: Applicative (MaybeT f) => MaybeT f a -> MaybeT f [a]

Alt f => Alt (Yoneda f)

Defined in Data.Functor.Yoneda

Methods

(<!>) :: Yoneda f a -> Yoneda f a -> Yoneda f a

some :: Applicative (Yoneda f) => Yoneda f a -> Yoneda f [a]

many :: Applicative (Yoneda f) => Yoneda f a -> Yoneda f [a]

Alt (ReifiedFold s)

Defined in Control.Lens.Reified

Methods

(<!>) :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a

some :: Applicative (ReifiedFold s) => ReifiedFold s a -> ReifiedFold s [a]

many :: Applicative (ReifiedFold s) => ReifiedFold s a -> ReifiedFold s [a]

Apply f => Alt (ListT f)

Defined in Data.Functor.Alt

Methods

(<!>) :: ListT f a -> ListT f a -> ListT f a

some :: Applicative (ListT f) => ListT f a -> ListT f [a]

many :: Applicative (ListT f) => ListT f a -> ListT f [a]

Alternative f => Alt (WrappedApplicative f)

Defined in Data.Functor.Alt

Methods

(<!>) :: WrappedApplicative f a -> WrappedApplicative f a -> WrappedApplicative f a

some :: Applicative (WrappedApplicative f) => WrappedApplicative f a -> WrappedApplicative f [a]

many :: Applicative (WrappedApplicative f) => WrappedApplicative f a -> WrappedApplicative f [a]

Alt f => Alt (Lift f)

Defined in Data.Functor.Alt

Methods

(<!>) :: Lift f a -> Lift f a -> Lift f a

some :: Applicative (Lift f) => Lift f a -> Lift f [a]

many :: Applicative (Lift f) => Lift f a -> Lift f [a]

Alt f => Alt (Rec1 f)

Defined in Data.Functor.Alt

Methods

(<!>) :: Rec1 f a -> Rec1 f a -> Rec1 f a

some :: Applicative (Rec1 f) => Rec1 f a -> Rec1 f [a]

many :: Applicative (Rec1 f) => Rec1 f a -> Rec1 f [a]

ArrowPlus a => Alt (WrappedArrow a b)

Defined in Data.Functor.Alt

Methods

(<!>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0

some :: Applicative (WrappedArrow a b) => WrappedArrow a b a0 -> WrappedArrow a b [a0]

many :: Applicative (WrappedArrow a b) => WrappedArrow a b a0 -> WrappedArrow a b [a0]

Alt f => Alt (IdentityT f)

Defined in Data.Functor.Alt

Methods

(<!>) :: IdentityT f a -> IdentityT f a -> IdentityT f a

some :: Applicative (IdentityT f) => IdentityT f a -> IdentityT f [a]

many :: Applicative (IdentityT f) => IdentityT f a -> IdentityT f [a]

(Bind f, Monad f, Semigroup e) => Alt (ExceptT e f)

Defined in Data.Functor.Alt

Methods

(<!>) :: ExceptT e f a -> ExceptT e f a -> ExceptT e f a

some :: Applicative (ExceptT e f) => ExceptT e f a -> ExceptT e f [a]

many :: Applicative (ExceptT e f) => ExceptT e f a -> ExceptT e f [a]

(Bind f, Monad f) => Alt (ErrorT e f)

Defined in Data.Functor.Alt

Methods

(<!>) :: ErrorT e f a -> ErrorT e f a -> ErrorT e f a

some :: Applicative (ErrorT e f) => ErrorT e f a -> ErrorT e f [a]

many :: Applicative (ErrorT e f) => ErrorT e f a -> ErrorT e f [a]

Alt f => Alt (Backwards f)

Defined in Data.Functor.Alt

Methods

(<!>) :: Backwards f a -> Backwards f a -> Backwards f a

some :: Applicative (Backwards f) => Backwards f a -> Backwards f [a]

many :: Applicative (Backwards f) => Backwards f a -> Backwards f [a]

Alt (ReifiedIndexedFold i s)

Defined in Control.Lens.Reified

Methods

(<!>) :: ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a

some :: Applicative (ReifiedIndexedFold i s) => ReifiedIndexedFold i s a -> ReifiedIndexedFold i s [a]

many :: Applicative (ReifiedIndexedFold i s) => ReifiedIndexedFold i s a -> ReifiedIndexedFold i s [a]

Alt f => Alt (WriterT w f)

Defined in Data.Functor.Alt

Methods

(<!>) :: WriterT w f a -> WriterT w f a -> WriterT w f a

some :: Applicative (WriterT w f) => WriterT w f a -> WriterT w f [a]

many :: Applicative (WriterT w f) => WriterT w f a -> WriterT w f [a]

Alt f => Alt (StateT e f)

Defined in Data.Functor.Alt

Methods

(<!>) :: StateT e f a -> StateT e f a -> StateT e f a

some :: Applicative (StateT e f) => StateT e f a -> StateT e f [a]

many :: Applicative (StateT e f) => StateT e f a -> StateT e f [a]

Alt f => Alt (StateT e f)

Defined in Data.Functor.Alt

Methods

(<!>) :: StateT e f a -> StateT e f a -> StateT e f a

some :: Applicative (StateT e f) => StateT e f a -> StateT e f [a]

many :: Applicative (StateT e f) => StateT e f a -> StateT e f [a]

Alt f => Alt (WriterT w f)

Defined in Data.Functor.Alt

Methods

(<!>) :: WriterT w f a -> WriterT w f a -> WriterT w f a

some :: Applicative (WriterT w f) => WriterT w f a -> WriterT w f [a]

many :: Applicative (WriterT w f) => WriterT w f a -> WriterT w f [a]

Alt f => Alt (Static f a)

Defined in Data.Semigroupoid.Static

Methods

(<!>) :: Static f a a0 -> Static f a a0 -> Static f a a0

some :: Applicative (Static f a) => Static f a a0 -> Static f a [a0]

many :: Applicative (Static f a) => Static f a a0 -> Static f a [a0]

Alt f => Alt (Reverse f)

Defined in Data.Functor.Alt

Methods

(<!>) :: Reverse f a -> Reverse f a -> Reverse f a

some :: Applicative (Reverse f) => Reverse f a -> Reverse f [a]

many :: Applicative (Reverse f) => Reverse f a -> Reverse f [a]

(Alt f, Alt g) => Alt (f :*: g)

Defined in Data.Functor.Alt

Methods

(<!>) :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a

some :: Applicative (f :*: g) => (f :*: g) a -> (f :*: g) [a]

many :: Applicative (f :*: g) => (f :*: g) a -> (f :*: g) [a]

(Alt f, Alt g) => Alt (Product f g)

Defined in Data.Functor.Alt

Methods

(<!>) :: Product f g a -> Product f g a -> Product f g a

some :: Applicative (Product f g) => Product f g a -> Product f g [a]

many :: Applicative (Product f g) => Product f g a -> Product f g [a]

Alt f => Alt (ReaderT e f)

Defined in Data.Functor.Alt

Methods

(<!>) :: ReaderT e f a -> ReaderT e f a -> ReaderT e f a

some :: Applicative (ReaderT e f) => ReaderT e f a -> ReaderT e f [a]

many :: Applicative (ReaderT e f) => ReaderT e f a -> ReaderT e f [a]

Alt f => Alt (M1 i c f)

Defined in Data.Functor.Alt

Methods

(<!>) :: M1 i c f a -> M1 i c f a -> M1 i c f a

some :: Applicative (M1 i c f) => M1 i c f a -> M1 i c f [a]

many :: Applicative (M1 i c f) => M1 i c f a -> M1 i c f [a]

(Alt f, Functor g) => Alt (Compose f g)

Defined in Data.Functor.Alt

Methods

(<!>) :: Compose f g a -> Compose f g a -> Compose f g a

some :: Applicative (Compose f g) => Compose f g a -> Compose f g [a]

many :: Applicative (Compose f g) => Compose f g a -> Compose f g [a]

Alt f => Alt (RWST r w s f)

Defined in Data.Functor.Alt

Methods

(<!>) :: RWST r w s f a -> RWST r w s f a -> RWST r w s f a

some :: Applicative (RWST r w s f) => RWST r w s f a -> RWST r w s f [a]

many :: Applicative (RWST r w s f) => RWST r w s f a -> RWST r w s f [a]

Alt f => Alt (RWST r w s f)

Defined in Data.Functor.Alt

Methods

(<!>) :: RWST r w s f a -> RWST r w s f a -> RWST r w s f a

some :: Applicative (RWST r w s f) => RWST r w s f a -> RWST r w s f [a]

many :: Applicative (RWST r w s f) => RWST r w s f a -> RWST r w s f [a]

Plus

class Alt f => Plus (f :: * -> *) where

Laws:

zero <!> m = m
m <!> zero = m

If extended to an Alternative then zero should equal empty.

Minimal complete definition

zero

Methods

zero :: f a

Instances

Plus []

Defined in Data.Functor.Plus

Methods

zero :: [a]

Plus Maybe

Defined in Data.Functor.Plus

Methods

zero :: Maybe a

Plus IO

Defined in Data.Functor.Plus

Methods

zero :: IO a

Plus Option

Defined in Data.Functor.Plus

Methods

zero :: Option a

Plus First

Defined in Data.Functor.Plus

Methods

zero :: First a

Plus Last

Defined in Data.Functor.Plus

Methods

zero :: Last a

Plus IntMap

Defined in Data.Functor.Plus

Methods

zero :: IntMap a

Plus Seq

Defined in Data.Functor.Plus

Methods

zero :: Seq a

Plus (U1 :: * -> *)

Defined in Data.Functor.Plus

Methods

zero :: U1 a

Ord k => Plus (Map k)

Defined in Data.Functor.Plus

Methods

zero :: Map k a

MonadPlus m => Plus (WrappedMonad m)

Defined in Data.Functor.Plus

Methods

zero :: WrappedMonad m a

Plus (Proxy :: * -> *)

Defined in Data.Functor.Plus

Methods

zero :: Proxy a

(Bind f, Monad f) => Plus (MaybeT f)

Defined in Data.Functor.Plus

Methods

zero :: MaybeT f a

Plus f => Plus (Yoneda f)

Defined in Data.Functor.Yoneda

Methods

zero :: Yoneda f a

Plus (ReifiedFold s)

Defined in Control.Lens.Reified

Methods

zero :: ReifiedFold s a

(Apply f, Applicative f) => Plus (ListT f)

Defined in Data.Functor.Plus

Methods

zero :: ListT f a

Alternative f => Plus (WrappedApplicative f)

Defined in Data.Functor.Plus

Methods

zero :: WrappedApplicative f a

Plus f => Plus (Lift f)

Defined in Data.Functor.Plus

Methods

zero :: Lift f a

Plus f => Plus (Rec1 f)

Defined in Data.Functor.Plus

Methods

zero :: Rec1 f a

ArrowPlus a => Plus (WrappedArrow a b)

Defined in Data.Functor.Plus

Methods

zero :: WrappedArrow a b a0

Plus f => Plus (IdentityT f)

Defined in Data.Functor.Plus

Methods

zero :: IdentityT f a

(Bind f, Monad f, Semigroup e, Monoid e) => Plus (ExceptT e f)

Defined in Data.Functor.Plus

Methods

zero :: ExceptT e f a

(Bind f, Monad f, Error e) => Plus (ErrorT e f)

Defined in Data.Functor.Plus

Methods

zero :: ErrorT e f a

Plus f => Plus (Backwards f)

Defined in Data.Functor.Plus

Methods

zero :: Backwards f a

Plus (ReifiedIndexedFold i s)

Defined in Control.Lens.Reified

Methods

zero :: ReifiedIndexedFold i s a

Plus f => Plus (WriterT w f)

Defined in Data.Functor.Plus

Methods

zero :: WriterT w f a

Plus f => Plus (StateT e f)

Defined in Data.Functor.Plus

Methods

zero :: StateT e f a

Plus f => Plus (StateT e f)

Defined in Data.Functor.Plus

Methods

zero :: StateT e f a

Plus f => Plus (WriterT w f)

Defined in Data.Functor.Plus

Methods

zero :: WriterT w f a

Plus f => Plus (Static f a)

Defined in Data.Semigroupoid.Static

Methods

zero :: Static f a a0

Plus f => Plus (Reverse f)

Defined in Data.Functor.Plus

Methods

zero :: Reverse f a

(Plus f, Plus g) => Plus (f :*: g)

Defined in Data.Functor.Plus

Methods

zero :: (f :*: g) a

(Plus f, Plus g) => Plus (Product f g)

Defined in Data.Functor.Plus

Methods

zero :: Product f g a

Plus f => Plus (ReaderT e f)

Defined in Data.Functor.Plus

Methods

zero :: ReaderT e f a

Plus f => Plus (M1 i c f)

Defined in Data.Functor.Plus

Methods

zero :: M1 i c f a

(Plus f, Functor g) => Plus (Compose f g)

Defined in Data.Functor.Plus

Methods

zero :: Compose f g a

Plus f => Plus (RWST r w s f)

Defined in Data.Functor.Plus

Methods

zero :: RWST r w s f a

Plus f => Plus (RWST r w s f)

Defined in Data.Functor.Plus

Methods

zero :: RWST r w s f a

Bind

class Apply m => Bind (m :: * -> *) where

A Monad sans return.

Minimal definition: Either join or >>-

If defining both, then the following laws (the default definitions) must hold:

join = (>>- id)
m >>- f = join (fmap f m)

Laws:

induced definition of <.>: f <.> x = f >>- (<$> x)

Finally, there are two associativity conditions:

associativity of (>>-):    (m >>- f) >>- g == m >>- (\x -> f x >>- g)
associativity of join:     join . join = join . fmap join

These can both be seen as special cases of the constraint that

associativity of (->-): (f ->- g) ->- h = f ->- (g ->- h)

Minimal complete definition

(>>-) | join

Methods

(>>-) :: m a -> (a -> m b) -> m b infixl 1

join :: m (m a) -> m a

Instances

Bind []

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: [a] -> (a -> [b]) -> [b]

join :: [[a]] -> [a]

Bind Maybe

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Maybe a -> (a -> Maybe b) -> Maybe b

join :: Maybe (Maybe a) -> Maybe a

Bind IO

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: IO a -> (a -> IO b) -> IO b

join :: IO (IO a) -> IO a

Bind Q

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Q a -> (a -> Q b) -> Q b

join :: Q (Q a) -> Q a

Bind Complex

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Complex a -> (a -> Complex b) -> Complex b

join :: Complex (Complex a) -> Complex a

Bind Min

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Min a -> (a -> Min b) -> Min b

join :: Min (Min a) -> Min a

Bind Max

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Max a -> (a -> Max b) -> Max b

join :: Max (Max a) -> Max a

Bind First

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: First a -> (a -> First b) -> First b

join :: First (First a) -> First a

Bind Last

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Last a -> (a -> Last b) -> Last b

join :: Last (Last a) -> Last a

Bind Option

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Option a -> (a -> Option b) -> Option b

join :: Option (Option a) -> Option a

Bind Identity

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Identity a -> (a -> Identity b) -> Identity b

join :: Identity (Identity a) -> Identity a

Bind First

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: First a -> (a -> First b) -> First b

join :: First (First a) -> First a

Bind Last

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Last a -> (a -> Last b) -> Last b

join :: Last (Last a) -> Last a

Bind Dual

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Dual a -> (a -> Dual b) -> Dual b

join :: Dual (Dual a) -> Dual a

Bind Sum

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Sum a -> (a -> Sum b) -> Sum b

join :: Sum (Sum a) -> Sum a

Bind Product

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Product a -> (a -> Product b) -> Product b

join :: Product (Product a) -> Product a

Bind Down

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Down a -> (a -> Down b) -> Down b

join :: Down (Down a) -> Down a

Bind NonEmpty

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b

join :: NonEmpty (NonEmpty a) -> NonEmpty a

Bind IntMap

An IntMap is not a Monad, but it is an instance of Bind

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: IntMap a -> (a -> IntMap b) -> IntMap b

join :: IntMap (IntMap a) -> IntMap a

Bind Tree

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Tree a -> (a -> Tree b) -> Tree b

join :: Tree (Tree a) -> Tree a

Bind Seq

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Seq a -> (a -> Seq b) -> Seq b

join :: Seq (Seq a) -> Seq a

Bind Log

Defined in Numeric.Log

Methods

(>>-) :: Log a -> (a -> Log b) -> Log b

join :: Log (Log a) -> Log a

Bind (Either a)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Either a a0 -> (a0 -> Either a b) -> Either a b

join :: Either a (Either a a0) -> Either a a0

Bind (V1 :: * -> *)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: V1 a -> (a -> V1 b) -> V1 b

join :: V1 (V1 a) -> V1 a

Semigroup m => Bind ((,) m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: (m, a) -> (a -> (m, b)) -> (m, b)

join :: (m, (m, a)) -> (m, a)

Representable f => Bind (Co f)

Defined in Data.Functor.Rep

Methods

(>>-) :: Co f a -> (a -> Co f b) -> Co f b

join :: Co f (Co f a) -> Co f a

(Hashable k, Eq k) => Bind (HashMap k)

A HashMap is not a Monad, but it is an instance of Bind

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: HashMap k a -> (a -> HashMap k b) -> HashMap k b

join :: HashMap k (HashMap k a) -> HashMap k a

Ord k => Bind (Map k)

A Map is not a Monad, but it is an instance of Bind

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Map k a -> (a -> Map k b) -> Map k b

join :: Map k (Map k a) -> Map k a

Monad m => Bind (WrappedMonad m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b

join :: WrappedMonad m (WrappedMonad m a) -> WrappedMonad m a

Bind (Proxy :: * -> *)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Proxy a -> (a -> Proxy b) -> Proxy b

join :: Proxy (Proxy a) -> Proxy a

(Functor m, Monad m) => Bind (MaybeT m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b

join :: MaybeT m (MaybeT m a) -> MaybeT m a

Functor f => Bind (Free f)

Defined in Control.Monad.Free

Methods

(>>-) :: Free f a -> (a -> Free f b) -> Free f b

join :: Free f (Free f a) -> Free f a

Bind m => Bind (Yoneda m)

Defined in Data.Functor.Yoneda

Methods

(>>-) :: Yoneda m a -> (a -> Yoneda m b) -> Yoneda m b

join :: Yoneda m (Yoneda m a) -> Yoneda m a

Bind (ReifiedGetter s)

Defined in Control.Lens.Reified

Methods

(>>-) :: ReifiedGetter s a -> (a -> ReifiedGetter s b) -> ReifiedGetter s b

join :: ReifiedGetter s (ReifiedGetter s a) -> ReifiedGetter s a

Bind (ReifiedFold s)

Defined in Control.Lens.Reified

Methods

(>>-) :: ReifiedFold s a -> (a -> ReifiedFold s b) -> ReifiedFold s b

join :: ReifiedFold s (ReifiedFold s a) -> ReifiedFold s a

(Apply m, Monad m) => Bind (ListT m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: ListT m a -> (a -> ListT m b) -> ListT m b

join :: ListT m (ListT m a) -> ListT m a

Bind f => Bind (Alt f)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Alt f a -> (a -> Alt f b) -> Alt f b

join :: Alt f (Alt f a) -> Alt f a

Bind m => Bind (IdentityT m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: IdentityT m a -> (a -> IdentityT m b) -> IdentityT m b

join :: IdentityT m (IdentityT m a) -> IdentityT m a

(Functor m, Monad m) => Bind (ExceptT e m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b

join :: ExceptT e m (ExceptT e m a) -> ExceptT e m a

(Functor f, Monad m) => Bind (FreeT f m)

Defined in Control.Monad.Trans.Free

Methods

(>>-) :: FreeT f m a -> (a -> FreeT f m b) -> FreeT f m b

join :: FreeT f m (FreeT f m a) -> FreeT f m a

(Functor m, Monad m) => Bind (ErrorT e m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: ErrorT e m a -> (a -> ErrorT e m b) -> ErrorT e m b

join :: ErrorT e m (ErrorT e m a) -> ErrorT e m a

Bind (Indexed i a)

Defined in Control.Lens.Internal.Indexed

Methods

(>>-) :: Indexed i a a0 -> (a0 -> Indexed i a b) -> Indexed i a b

join :: Indexed i a (Indexed i a a0) -> Indexed i a a0

(Bind m, Semigroup w) => Bind (WriterT w m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b

join :: WriterT w m (WriterT w m a) -> WriterT w m a

Bind m => Bind (StateT s m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b

join :: StateT s m (StateT s m a) -> StateT s m a

Bind m => Bind (StateT s m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b

join :: StateT s m (StateT s m a) -> StateT s m a

(Bind m, Semigroup w) => Bind (WriterT w m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b

join :: WriterT w m (WriterT w m a) -> WriterT w m a

Bind (Tagged a)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Tagged a a0 -> (a0 -> Tagged a b) -> Tagged a b

join :: Tagged a (Tagged a a0) -> Tagged a a0

Bind ((->) m :: * -> *)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: (m -> a) -> (a -> m -> b) -> m -> b

join :: (m -> m -> a) -> m -> a

(Bind f, Bind g) => Bind (Product f g)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Product f g a -> (a -> Product f g b) -> Product f g b

join :: Product f g (Product f g a) -> Product f g a

Bind m => Bind (ReaderT e m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: ReaderT e m a -> (a -> ReaderT e m b) -> ReaderT e m b

join :: ReaderT e m (ReaderT e m a) -> ReaderT e m a

Bind (ContT r m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: ContT r m a -> (a -> ContT r m b) -> ContT r m b

join :: ContT r m (ContT r m a) -> ContT r m a

(Bind m, Semigroup w) => Bind (RWST r w s m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b

join :: RWST r w s m (RWST r w s m a) -> RWST r w s m a

(Bind m, Semigroup w) => Bind (RWST r w s m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b

join :: RWST r w s m (RWST r w s m a) -> RWST r w s m a

(-<<) :: Bind m => (a -> m b) -> m a -> m b infixr 1

Extend

class Functor w => Extend (w :: * -> *) where

Minimal complete definition

duplicated | extended

Methods

duplicated :: w a -> w (w a)

duplicated = extended id
fmap (fmap f) . duplicated = duplicated . fmap f

extended :: (w a -> b) -> w a -> w b

extended f  = fmap f . duplicated

Instances

Extend []

Defined in Data.Functor.Extend

Methods

duplicated :: [a] -> [[a]]

extended :: ([a] -> b) -> [a] -> [b]

Extend Maybe

Defined in Data.Functor.Extend

Methods

duplicated :: Maybe a -> Maybe (Maybe a)

extended :: (Maybe a -> b) -> Maybe a -> Maybe b

Extend Par1

Defined in Data.Functor.Extend

Methods

duplicated :: Par1 a -> Par1 (Par1 a)

extended :: (Par1 a -> b) -> Par1 a -> Par1 b

Extend Min

Defined in Data.Functor.Extend

Methods

duplicated :: Min a -> Min (Min a)

extended :: (Min a -> b) -> Min a -> Min b

Extend Max

Defined in Data.Functor.Extend

Methods

duplicated :: Max a -> Max (Max a)

extended :: (Max a -> b) -> Max a -> Max b

Extend First

Defined in Data.Functor.Extend

Methods

duplicated :: First a -> First (First a)

extended :: (First a -> b) -> First a -> First b

Extend Last

Defined in Data.Functor.Extend

Methods

duplicated :: Last a -> Last (Last a)

extended :: (Last a -> b) -> Last a -> Last b

Extend Identity

Defined in Data.Functor.Extend

Methods

duplicated :: Identity a -> Identity (Identity a)

extended :: (Identity a -> b) -> Identity a -> Identity b

Extend Dual

Defined in Data.Functor.Extend

Methods

duplicated :: Dual a -> Dual (Dual a)

extended :: (Dual a -> b) -> Dual a -> Dual b

Extend Sum

Defined in Data.Functor.Extend

Methods

duplicated :: Sum a -> Sum (Sum a)

extended :: (Sum a -> b) -> Sum a -> Sum b

Extend Product

Defined in Data.Functor.Extend

Methods

duplicated :: Product a -> Product (Product a)

extended :: (Product a -> b) -> Product a -> Product b

Extend NonEmpty

Defined in Data.Functor.Extend

Methods

duplicated :: NonEmpty a -> NonEmpty (NonEmpty a)

extended :: (NonEmpty a -> b) -> NonEmpty a -> NonEmpty b

Extend Tree

Defined in Data.Functor.Extend

Methods

duplicated :: Tree a -> Tree (Tree a)

extended :: (Tree a -> b) -> Tree a -> Tree b

Extend Seq

Defined in Data.Functor.Extend

Methods

duplicated :: Seq a -> Seq (Seq a)

extended :: (Seq a -> b) -> Seq a -> Seq b

Extend Log

Defined in Numeric.Log

Methods

duplicated :: Log a -> Log (Log a)

extended :: (Log a -> b) -> Log a -> Log b

Extend (Either a)

Defined in Data.Functor.Extend

Methods

duplicated :: Either a a0 -> Either a (Either a a0)

extended :: (Either a a0 -> b) -> Either a a0 -> Either a b

Extend (V1 :: * -> *)

Defined in Data.Functor.Extend

Methods

duplicated :: V1 a -> V1 (V1 a)

extended :: (V1 a -> b) -> V1 a -> V1 b

Extend (U1 :: * -> *)

Defined in Data.Functor.Extend

Methods

duplicated :: U1 a -> U1 (U1 a)

extended :: (U1 a -> b) -> U1 a -> U1 b

Extend ((,) e)

Defined in Data.Functor.Extend

Methods

duplicated :: (e, a) -> (e, (e, a))

extended :: ((e, a) -> b) -> (e, a) -> (e, b)

(Representable f, Semigroup (Rep f)) => Extend (Co f)

Defined in Data.Functor.Rep

Methods

duplicated :: Co f a -> Co f (Co f a)

extended :: (Co f a -> b) -> Co f a -> Co f b

Extend (Proxy :: * -> *)

Defined in Data.Functor.Extend

Methods

duplicated :: Proxy a -> Proxy (Proxy a)

extended :: (Proxy a -> b) -> Proxy a -> Proxy b

Functor f => Extend (Cofree f)

Defined in Control.Comonad.Cofree

Methods

duplicated :: Cofree f a -> Cofree f (Cofree f a)

extended :: (Cofree f a -> b) -> Cofree f a -> Cofree f b

Extend w => Extend (Yoneda w)

Defined in Data.Functor.Yoneda

Methods

duplicated :: Yoneda w a -> Yoneda w (Yoneda w a)

extended :: (Yoneda w a -> b) -> Yoneda w a -> Yoneda w b

Semigroup s => Extend (ReifiedGetter s)

Defined in Control.Lens.Reified

Methods

duplicated :: ReifiedGetter s a -> ReifiedGetter s (ReifiedGetter s a)

extended :: (ReifiedGetter s a -> b) -> ReifiedGetter s a -> ReifiedGetter s b

Extend f => Extend (MaybeApply f)

Defined in Data.Functor.Bind.Class

Methods

duplicated :: MaybeApply f a -> MaybeApply f (MaybeApply f a)

extended :: (MaybeApply f a -> b) -> MaybeApply f a -> MaybeApply f b

Extend f => Extend (Rec1 f)

Defined in Data.Functor.Extend

Methods

duplicated :: Rec1 f a -> Rec1 f (Rec1 f a)

extended :: (Rec1 f a -> b) -> Rec1 f a -> Rec1 f b

Extend f => Extend (Alt f)

Defined in Data.Functor.Extend

Methods

duplicated :: Alt f a -> Alt f (Alt f a)

extended :: (Alt f a -> b) -> Alt f a -> Alt f b

(Extend w, Semigroup m) => Extend (TracedT m w)

Defined in Data.Functor.Extend

Methods

duplicated :: TracedT m w a -> TracedT m w (TracedT m w a)

extended :: (TracedT m w a -> b) -> TracedT m w a -> TracedT m w b

Extend w => Extend (StoreT s w)

Defined in Data.Functor.Extend

Methods

duplicated :: StoreT s w a -> StoreT s w (StoreT s w a)

extended :: (StoreT s w a -> b) -> StoreT s w a -> StoreT s w b

Extend w => Extend (EnvT e w)

Defined in Data.Functor.Extend

Methods

duplicated :: EnvT e w a -> EnvT e w (EnvT e w a)

extended :: (EnvT e w a -> b) -> EnvT e w a -> EnvT e w b

Extend w => Extend (IdentityT w)

Defined in Data.Functor.Extend

Methods

duplicated :: IdentityT w a -> IdentityT w (IdentityT w a)

extended :: (IdentityT w a -> b) -> IdentityT w a -> IdentityT w b

(Extend f, Semigroup a) => Extend (Static f a)

Defined in Data.Semigroupoid.Static

Methods

duplicated :: Static f a a0 -> Static f a (Static f a a0)

extended :: (Static f a a0 -> b) -> Static f a a0 -> Static f a b

Extend (Tagged a)

Defined in Data.Functor.Extend

Methods

duplicated :: Tagged a a0 -> Tagged a (Tagged a a0)

extended :: (Tagged a a0 -> b) -> Tagged a a0 -> Tagged a b

Semigroup m => Extend ((->) m :: * -> *)

Defined in Data.Functor.Extend

Methods

duplicated :: (m -> a) -> m -> m -> a

extended :: ((m -> a) -> b) -> (m -> a) -> m -> b

(Extend f, Extend g) => Extend (f :+: g)

Defined in Data.Functor.Extend

Methods

duplicated :: (f :+: g) a -> (f :+: g) ((f :+: g) a)

extended :: ((f :+: g) a -> b) -> (f :+: g) a -> (f :+: g) b

(Extend f, Extend g) => Extend (Sum f g)

Defined in Data.Functor.Extend

Methods

duplicated :: Sum f g a -> Sum f g (Sum f g a)

extended :: (Sum f g a -> b) -> Sum f g a -> Sum f g b

Extend f => Extend (M1 i t f)

Defined in Data.Functor.Extend

Methods

duplicated :: M1 i t f a -> M1 i t f (M1 i t f a)

extended :: (M1 i t f a -> b) -> M1 i t f a -> M1 i t f b

MFunctor

class MFunctor (t :: (* -> *) -> k -> *) where

A functor in the category of monads, using hoist as the analog of fmap:

hoist (f . g) = hoist f . hoist g

hoist id = id

Minimal complete definition

hoist

Methods

hoist :: Monad m => (forall a. m a -> n a) -> t m b -> t n b

Lift a monad morphism from m to n into a monad morphism from (t m) to (t n)

The first argument to hoist must be a monad morphism, even though the type system does not enforce this

Instances

MFunctor MaybeT

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> MaybeT m b -> MaybeT n b

MFunctor PropertyT

Defined in Hedgehog.Internal.Property

Methods

hoist :: Monad m => (forall a. m a -> n a) -> PropertyT m b -> PropertyT n b

MFunctor TestT

Defined in Hedgehog.Internal.Property

Methods

hoist :: Monad m => (forall a. m a -> n a) -> TestT m b -> TestT n b

MFunctor GenT

Defined in Hedgehog.Internal.Gen

Methods

hoist :: Monad m => (forall a. m a -> n a) -> GenT m b -> GenT n b

MFunctor ListT

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> ListT m b -> ListT n b

MFunctor Lift

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> Lift m b -> Lift n b

MFunctor (IdentityT :: (* -> *) -> * -> *)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> IdentityT m b -> IdentityT n b

MFunctor (ExceptT e :: (* -> *) -> * -> *)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> ExceptT e m b -> ExceptT e n b

MFunctor (ErrorT e :: (* -> *) -> * -> *)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> ErrorT e m b -> ErrorT e n b

MFunctor (Backwards :: (* -> *) -> * -> *)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> Backwards m b -> Backwards n b

MFunctor (WriterT w :: (* -> *) -> * -> *)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> WriterT w m b -> WriterT w n b

MFunctor (StateT s :: (* -> *) -> * -> *)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> StateT s m b -> StateT s n b

MFunctor (StateT s :: (* -> *) -> * -> *)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> StateT s m b -> StateT s n b

MFunctor (WriterT w :: (* -> *) -> * -> *)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> WriterT w m b -> WriterT w n b

MFunctor (Product f :: (* -> *) -> * -> *)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> Product f m b -> Product f n b

MFunctor (ReaderT r :: (* -> *) -> * -> *)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> ReaderT r m b -> ReaderT r n b

Functor f => MFunctor (Compose f :: (* -> *) -> * -> *)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> Compose f m b -> Compose f n b

MFunctor (RWST r w s :: (* -> *) -> * -> *)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> RWST r w s m b -> RWST r w s n b

MFunctor (RWST r w s :: (* -> *) -> * -> *)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> RWST r w s m b -> RWST r w s n b