planet-mitchell-0.1.0: Planet Mitchell

Safe HaskellNone
LanguageHaskell2010

Functor

Contents

Synopsis

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

Instance details

Defined in GHC.Base

Methods

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

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

Functor Maybe

Since: base-2.1

Instance details

Defined in GHC.Base

Methods

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

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

Functor IO

Since: base-2.1

Instance details

Defined in GHC.Base

Methods

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

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

Functor Par1 
Instance details

Defined in GHC.Generics

Methods

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

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

Functor Q 
Instance details

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

Instance details

Defined in Data.Aeson.Types.FromJSON

Functor IResult 
Instance details

Defined in Data.Aeson.Types.Internal

Methods

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

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

Functor Result 
Instance details

Defined in Data.Aeson.Types.Internal

Methods

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

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

Functor Parser 
Instance details

Defined in Data.Aeson.Types.Internal

Methods

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

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

Functor Approximate 
Instance details

Defined in Data.Approximate.Type

Methods

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

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

Functor Async 
Instance details

Defined in Control.Concurrent.Async

Methods

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

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

Functor Concurrently 
Instance details

Defined in Control.Concurrent.Async

Methods

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

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

Functor Complex 
Instance details

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

Instance details

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

Instance details

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

Instance details

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

Instance details

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

Instance details

Defined in Data.Semigroup

Methods

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

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

Functor ZipList 
Instance details

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

Instance details

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

Instance details

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

Instance details

Defined in GHC.Conc.Sync

Methods

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

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

Functor First 
Instance details

Defined in Data.Monoid

Methods

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

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

Functor Last 
Instance details

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

Instance details

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

Instance details

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

Instance details

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

Instance details

Defined in Data.Ord

Methods

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

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

Functor ReadPrec

Since: base-2.1

Instance details

Defined in Text.ParserCombinators.ReadPrec

Methods

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

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

Functor ReadP

Since: base-2.1

Instance details

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

Instance details

Defined in GHC.Base

Methods

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

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

Functor Put 
Instance details

Defined in Data.ByteString.Builder.Internal

Methods

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

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

Functor IntMap 
Instance details

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

Instance details

Defined in Data.Graph

Methods

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

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

Functor Tree 
Instance details

Defined in Data.Tree

Methods

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

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

Functor Seq 
Instance details

Defined in Data.Sequence.Internal

Methods

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

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

Functor FingerTree 
Instance details

Defined in Data.Sequence.Internal

Methods

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

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

Functor Digit 
Instance details

Defined in Data.Sequence.Internal

Methods

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

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

Functor Node 
Instance details

Defined in Data.Sequence.Internal

Methods

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

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

Functor Elem 
Instance details

Defined in Data.Sequence.Internal

Methods

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

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

Functor ViewL 
Instance details

Defined in Data.Sequence.Internal

Methods

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

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

Functor ViewR 
Instance details

Defined in Data.Sequence.Internal

Methods

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

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

Functor DList 
Instance details

Defined in Data.DList

Methods

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

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

Functor NonGreedy 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

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

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

Functor ListOf 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

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

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

Functor ModuleName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor SpecialCon 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor QName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Name 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor IPName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor QOp 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Op 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor CName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Module 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor ModuleHead 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor ExportSpecList 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor ExportSpec 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor EWildcard 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Namespace 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor ImportDecl 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor ImportSpecList 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor ImportSpec 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Assoc 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Decl 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor PatternSynDirection 
Instance details

Defined in Language.Haskell.Exts.Syntax

Functor TypeEqn 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Annotation 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor BooleanFormula 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Role 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor DataOrNew 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor InjectivityInfo 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor ResultSig 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor DeclHead 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor InstRule 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor InstHead 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Deriving 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor DerivStrategy 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Binds 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor IPBind 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Match 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor QualConDecl 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor ConDecl 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor FieldDecl 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor GadtDecl 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor ClassDecl 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor InstDecl 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor BangType 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Unpackedness 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Rhs 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor GuardedRhs 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Type 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor MaybePromotedName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Functor Promoted 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor TyVarBind 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Kind 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor FunDep 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Context 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Asst 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Literal 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Sign 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Exp 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor XName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor XAttr 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Bracket 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Splice 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Safety 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor CallConv 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor ModulePragma 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Overlap 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Activation 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Rule 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor RuleVar 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor WarningText 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Pat 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor PXAttr 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor RPatOp 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor RPat 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor PatField 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Stmt 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor QualStmt 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor FieldUpdate 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Alt 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Functor Eval 
Instance details

Defined in Control.Parallel.Strategies

Methods

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

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

Functor Vector 
Instance details

Defined in Data.Vector

Methods

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

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

Functor Log 
Instance details

Defined in Numeric.Log

Methods

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

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

Functor Managed 
Instance details

Defined in Control.Monad.Managed

Methods

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

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

Functor ErrorItem 
Instance details

Defined in Text.Megaparsec.Error

Methods

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

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

Functor ErrorFancy 
Instance details

Defined in Text.Megaparsec.Error

Methods

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

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

Functor ParserInfo 
Instance details

Defined in Options.Applicative.Types

Methods

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

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

Functor Option 
Instance details

Defined in Options.Applicative.Types

Methods

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

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

Functor ReadM 
Instance details

Defined in Options.Applicative.Types

Methods

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

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

Functor CReader 
Instance details

Defined in Options.Applicative.Types

Methods

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

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

Functor OptReader 
Instance details

Defined in Options.Applicative.Types

Methods

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

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

Functor Parser 
Instance details

Defined in Options.Applicative.Types

Methods

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

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

Functor ParserM 
Instance details

Defined in Options.Applicative.Types

Methods

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

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

Functor ParserFailure 
Instance details

Defined in Options.Applicative.Types

Methods

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

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

Functor ParserResult 
Instance details

Defined in Options.Applicative.Types

Methods

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

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

Functor Doc 
Instance details

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

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

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

Functor AnnotDetails 
Instance details

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

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

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

Functor Span 
Instance details

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.

Instance details

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.

Instance details

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

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

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

Functor SmallArray 
Instance details

Defined in Data.Primitive.SmallArray

Methods

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

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

Functor Array 
Instance details

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]
Instance details

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)
Instance details

Defined in Reactive.Banana.Types

Methods

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

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

Functor Future 
Instance details

Defined in Reactive.Banana.Types

Methods

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

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

Functor Moment 
Instance details

Defined in Reactive.Banana.Types

Methods

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

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

Functor MomentIO 
Instance details

Defined in Reactive.Banana.Types

Methods

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

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

Functor AddHandler 
Instance details

Defined in Control.Event.Handler

Methods

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

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

Functor Bound 
Instance details

Defined in Data.Semilattice.Bound

Methods

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

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

Functor Order 
Instance details

Defined in Data.Semilattice.Order

Methods

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

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

Functor Meeting 
Instance details

Defined in Data.Semilattice.Meet

Methods

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

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

Functor GreaterThan 
Instance details

Defined in Data.Semilattice.Meet

Methods

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

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

Functor Joining 
Instance details

Defined in Data.Semilattice.Join

Methods

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

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

Functor LessThan 
Instance details

Defined in Data.Semilattice.Join

Methods

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

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

Functor Cleanup 
Instance details

Defined in System.Process.Typed

Methods

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

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

Functor Element 
Instance details

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

Methods

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

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

Functor Memoized 
Instance details

Defined in UnliftIO.Memoize

Methods

fmap :: (a -> b) -> Memoized a -> Memoized b #

(<$) :: a -> Memoized b -> Memoized a #

Functor P 
Instance details

Defined in Text.ParserCombinators.ReadP

Methods

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

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

Functor Forest 
Instance details

Defined in Data.Heap

Methods

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

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

Functor Tree 
Instance details

Defined in Data.Heap

Methods

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

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

Functor P 
Instance details

Defined in Data.HashMap.Strict.InsOrd

Methods

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

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

Class () (Functor f) 
Instance details

Defined in Data.Constraint

Methods

cls :: Functor f :- () #

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

Defined in Data.Constraint

Methods

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

() :=> (Functor []) 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Functor [] #

() :=> (Functor Maybe) 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Functor Maybe #

() :=> (Functor IO) 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Functor IO #

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

Defined in Data.Constraint

Methods

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

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

Defined in Data.Constraint

Methods

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

() :=> (Functor Identity) 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Functor Identity #

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

Defined in Data.Constraint

Methods

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

Functor (Either a)

Since: base-3.0

Instance details

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

Instance details

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

Instance details

Defined in GHC.Generics

Methods

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

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

Functor ((,) a)

Since: base-2.1

Instance details

Defined in GHC.Base

Methods

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

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

Functor (ST s)

Since: base-2.1

Instance details

Defined in GHC.ST

Methods

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

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

Functor (Results s) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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

Instance details

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

Instance details

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

Instance details

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

Instance details

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

Instance details

Defined in Data.Proxy

Methods

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

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

Functor m => Functor (MaybeT m) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

Defined in Control.Applicative.Free

Methods

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

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

Functor f => Functor (Curried f) 
Instance details

Defined in Data.Generics.Internal.VL.Traversal

Methods

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

(<$) :: a -> Curried f b -> Curried f a #

Functor (Yoneda f) 
Instance details

Defined in Data.Generics.Internal.VL.Traversal

Methods

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

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

Functor (Entry p) 
Instance details

Defined in Data.Heap

Methods

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

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

Functor (InsOrdHashMap k) 
Instance details

Defined in Data.HashMap.Strict.InsOrd

Methods

fmap :: (a -> b) -> InsOrdHashMap k a -> InsOrdHashMap k b #

(<$) :: a -> InsOrdHashMap k b -> InsOrdHashMap k a #

Functor (Yoneda f) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

Defined in List.Transformer

Methods

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

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

Functor (LogicT f) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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

Instance details

Defined in UnliftIO.Async

Methods

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

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

Functor f => Functor (AltSum f) 
Instance details

Defined in Control.Compactable

Methods

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

(<$) :: a -> AltSum f b -> AltSum f a #

Functor f => Functor (Act f) 
Instance details

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) 
Instance details

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) 
Instance details

Defined in Data.Graph

Methods

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

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

Functor (SortedAp f) 
Instance details

Defined in Data.HashMap.Strict.InsOrd

Methods

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

(<$) :: a -> SortedAp f b -> SortedAp f a #

Functor (IncrementalDecoder s) 
Instance details

Defined in Codec.CBOR.Read

Methods

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

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

Class (Functor f) (Applicative f) 
Instance details

Defined in Data.Constraint

Methods

cls :: Applicative f :- Functor f #

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

Defined in Data.Constraint

Methods

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

Functor f => Functor (Rec1 f) 
Instance details

Defined in GHC.Generics

Methods

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

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

Functor (URec Char :: * -> *) 
Instance details

Defined in GHC.Generics

Methods

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

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

Functor (URec Double :: * -> *) 
Instance details

Defined in GHC.Generics

Methods

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

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

Functor (URec Float :: * -> *) 
Instance details

Defined in GHC.Generics

Methods

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

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

Functor (URec Int :: * -> *) 
Instance details

Defined in GHC.Generics

Methods

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

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

Functor (URec Word :: * -> *) 
Instance details

Defined in GHC.Generics

Methods

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

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

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

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) 
Instance details

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) 
Instance details

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

Instance details

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

Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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

Instance details

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) 
Instance details

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) 
Instance details

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 #

Monad m => Functor (FoldM m a) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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.

Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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

Instance details

Defined in GHC.Base

Methods

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

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

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

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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

Instance details

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

Instance details

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) 
Instance details

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

Instance details

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

Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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

Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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 :: * -> *) 
Instance details

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

Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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

Expand

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

Expand

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

Expand

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

Expand

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.

fmapover mapped
fmapDefaultover 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 [] 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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

Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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) 
Instance details

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 :: * -> *) 
Instance details

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 :: * -> *) 
Instance details

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) 
Instance details

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) 
Instance details

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

Instance details

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

Instance details

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) 
Instance details

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 :: * -> *) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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 #

(Eq k, Hashable k) => Apply (InsOrdHashMap k) 
Instance details

Defined in Data.HashMap.Strict.InsOrd

Methods

(<.>) :: InsOrdHashMap k (a -> b) -> InsOrdHashMap k a -> InsOrdHashMap k b #

(.>) :: InsOrdHashMap k a -> InsOrdHashMap k b -> InsOrdHashMap k b #

(<.) :: InsOrdHashMap k a -> InsOrdHashMap k b -> InsOrdHashMap k a #

liftF2 :: (a -> b -> c) -> InsOrdHashMap k a -> InsOrdHashMap k b -> InsOrdHashMap k c #

Apply f => Apply (Yoneda f) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

Defined in Data.Functor.Bind.Class

Apply f => Apply (MaybeApply f) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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 :: * -> *) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

Defined in Control.Lens.Reified

Apply (Mafic a b) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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 :: * -> *) 
Instance details

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 :: * -> *) 
Instance details

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 :: * -> *) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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

Instances
Functor f => Functor (MaybeApply f) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

Defined in Data.Pointed

Methods

point :: a -> MaybeApply f a #

Copointed f => Copointed (MaybeApply f) 
Instance details

Defined in Data.Copointed

Methods

copoint :: MaybeApply f a -> a #

Extend f => Extend (MaybeApply f) 
Instance details

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) 
Instance details

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 
Instance details

Defined in Control.Lens.Wrapped

type Unwrapped (MaybeApply f a) 
Instance details

Defined in Control.Lens.Wrapped

type Unwrapped (MaybeApply f a) = Either (f a) a

newtype Static (f :: * -> *) a b #

Constructors

Static 

Fields

Instances
Applicative f => Arrow (Static f) 
Instance details

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) 
Instance details

Defined in Data.Semigroupoid.Static

Methods

zeroArrow :: Static f b c #

Alternative f => ArrowPlus (Static f) 
Instance details

Defined in Data.Semigroupoid.Static

Methods

(<+>) :: Static f b c -> Static f b c -> Static f b c #

Applicative f => ArrowChoice (Static f) 
Instance details

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 :: * -> * -> *) 
Instance details

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 :: * -> * -> *) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

Defined in Data.Pointed

Methods

point :: a0 -> Static m a a0 #

Plus f => Plus (Static f a) 
Instance details

Defined in Data.Semigroupoid.Static

Methods

zero :: Static f a a0 #

Alt f => Alt (Static f a) 
Instance details

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) 
Instance details

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) 
Instance details

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 
Instance details

Defined in Control.Lens.Wrapped

type Unwrapped (Static f a b) 
Instance details

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 [] 
Instance details

Defined in Data.Functor.Alt

Methods

(<!>) :: [a] -> [a] -> [a] #

some :: Applicative [] => [a] -> [[a]] #

many :: Applicative [] => [a] -> [[a]] #

Alt Maybe 
Instance details

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

Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

Defined in Data.Functor.Alt

Alt IntMap 
Instance details

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 
Instance details

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) 
Instance details

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 :: * -> *) 
Instance details

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 :: * -> *) 
Instance details

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) 
Instance details

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) 
Instance details

Defined in Data.Functor.Alt

Alt (Proxy :: * -> *) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

Defined in Control.Lens.Reified

Apply f => Alt (ListT f) 
Instance details

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) 
Instance details

Defined in Data.Functor.Alt

Alt f => Alt (Lift f) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

Defined in Control.Lens.Reified

Alt f => Alt (WriterT w f) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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 [] 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: [a] #

Plus Maybe 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: Maybe a #

Plus IO 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: IO a #

Plus Option 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: Option a #

Plus First 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: First a #

Plus Last 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: Last a #

Plus IntMap 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: IntMap a #

Plus Seq 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: Seq a #

Plus (U1 :: * -> *) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: U1 a #

Ord k => Plus (Map k) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: Map k a #

MonadPlus m => Plus (WrappedMonad m) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: WrappedMonad m a #

Plus (Proxy :: * -> *) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: Proxy a #

(Bind f, Monad f) => Plus (MaybeT f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: MaybeT f a #

Plus f => Plus (Yoneda f) 
Instance details

Defined in Data.Functor.Yoneda

Methods

zero :: Yoneda f a #

Plus (ReifiedFold s) 
Instance details

Defined in Control.Lens.Reified

Methods

zero :: ReifiedFold s a #

(Apply f, Applicative f) => Plus (ListT f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: ListT f a #

Alternative f => Plus (WrappedApplicative f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: WrappedApplicative f a #

Plus f => Plus (Lift f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: Lift f a #

Plus f => Plus (Rec1 f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: Rec1 f a #

ArrowPlus a => Plus (WrappedArrow a b) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: WrappedArrow a b a0 #

Plus f => Plus (IdentityT f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: IdentityT f a #

(Bind f, Monad f, Semigroup e, Monoid e) => Plus (ExceptT e f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: ExceptT e f a #

(Bind f, Monad f, Error e) => Plus (ErrorT e f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: ErrorT e f a #

Plus f => Plus (Backwards f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: Backwards f a #

Plus (ReifiedIndexedFold i s) 
Instance details

Defined in Control.Lens.Reified

Methods

zero :: ReifiedIndexedFold i s a #

Plus f => Plus (WriterT w f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: WriterT w f a #

Plus f => Plus (StateT e f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: StateT e f a #

Plus f => Plus (StateT e f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: StateT e f a #

Plus f => Plus (WriterT w f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: WriterT w f a #

Plus f => Plus (Static f a) 
Instance details

Defined in Data.Semigroupoid.Static

Methods

zero :: Static f a a0 #

Plus f => Plus (Reverse f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: Reverse f a #

(Plus f, Plus g) => Plus (f :*: g) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: (f :*: g) a #

(Plus f, Plus g) => Plus (Product f g) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: Product f g a #

Plus f => Plus (ReaderT e f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: ReaderT e f a #

Plus f => Plus (M1 i c f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: M1 i c f a #

(Plus f, Functor g) => Plus (Compose f g) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: Compose f g a #

Plus f => Plus (RWST r w s f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: RWST r w s f a #

Plus f => Plus (RWST r w s f) 
Instance details

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 [] 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: [[a]] -> [a] #

Bind Maybe 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Maybe (Maybe a) -> Maybe a #

Bind IO 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: IO (IO a) -> IO a #

Bind Q 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Q (Q a) -> Q a #

Bind Complex 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Complex (Complex a) -> Complex a #

Bind Min 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Min (Min a) -> Min a #

Bind Max 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Max (Max a) -> Max a #

Bind First 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: First (First a) -> First a #

Bind Last 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Last (Last a) -> Last a #

Bind Option 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Option (Option a) -> Option a #

Bind Identity 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Identity (Identity a) -> Identity a #

Bind First 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: First (First a) -> First a #

Bind Last 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Last (Last a) -> Last a #

Bind Dual 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Dual (Dual a) -> Dual a #

Bind Sum 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Sum (Sum a) -> Sum a #

Bind Product 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Product (Product a) -> Product a #

Bind Down 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Down (Down a) -> Down a #

Bind NonEmpty 
Instance details

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

Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: IntMap (IntMap a) -> IntMap a #

Bind Tree 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Tree (Tree a) -> Tree a #

Bind Seq 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: Seq (Seq a) -> Seq a #

Bind Log 
Instance details

Defined in Numeric.Log

Methods

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

join :: Log (Log a) -> Log a #

Bind (Either a) 
Instance details

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 :: * -> *) 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

join :: V1 (V1 a) -> V1 a #

Semigroup m => Bind ((,) m) 
Instance details

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) 
Instance details

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

Instance details

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

Instance details

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) 
Instance details

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 :: * -> *) 
Instance details

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) 
Instance details

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) 
Instance details

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 #

(Eq k, Hashable k) => Bind (InsOrdHashMap k) 
Instance details

Defined in Data.HashMap.Strict.InsOrd

Methods

(>>-) :: InsOrdHashMap k a -> (a -> InsOrdHashMap k b) -> InsOrdHashMap k b #

join :: InsOrdHashMap k (InsOrdHashMap k a) -> InsOrdHashMap k a #

Bind m => Bind (Yoneda m) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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 :: * -> *) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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 [] 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: [a] -> [[a]] #

extended :: ([a] -> b) -> [a] -> [b] #

Extend Maybe 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: Maybe a -> Maybe (Maybe a) #

extended :: (Maybe a -> b) -> Maybe a -> Maybe b #

Extend Par1 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: Par1 a -> Par1 (Par1 a) #

extended :: (Par1 a -> b) -> Par1 a -> Par1 b #

Extend Min 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: Min a -> Min (Min a) #

extended :: (Min a -> b) -> Min a -> Min b #

Extend Max 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: Max a -> Max (Max a) #

extended :: (Max a -> b) -> Max a -> Max b #

Extend First 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: First a -> First (First a) #

extended :: (First a -> b) -> First a -> First b #

Extend Last 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: Last a -> Last (Last a) #

extended :: (Last a -> b) -> Last a -> Last b #

Extend Identity 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: Identity a -> Identity (Identity a) #

extended :: (Identity a -> b) -> Identity a -> Identity b #

Extend Dual 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: Dual a -> Dual (Dual a) #

extended :: (Dual a -> b) -> Dual a -> Dual b #

Extend Sum 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: Sum a -> Sum (Sum a) #

extended :: (Sum a -> b) -> Sum a -> Sum b #

Extend Product 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: Product a -> Product (Product a) #

extended :: (Product a -> b) -> Product a -> Product b #

Extend NonEmpty 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: NonEmpty a -> NonEmpty (NonEmpty a) #

extended :: (NonEmpty a -> b) -> NonEmpty a -> NonEmpty b #

Extend Tree 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: Tree a -> Tree (Tree a) #

extended :: (Tree a -> b) -> Tree a -> Tree b #

Extend Seq 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: Seq a -> Seq (Seq a) #

extended :: (Seq a -> b) -> Seq a -> Seq b #

Extend Log 
Instance details

Defined in Numeric.Log

Methods

duplicated :: Log a -> Log (Log a) #

extended :: (Log a -> b) -> Log a -> Log b #

Extend (Either a) 
Instance details

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 :: * -> *) 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: V1 a -> V1 (V1 a) #

extended :: (V1 a -> b) -> V1 a -> V1 b #

Extend (U1 :: * -> *) 
Instance details

Defined in Data.Functor.Extend

Methods

duplicated :: U1 a -> U1 (U1 a) #

extended :: (U1 a -> b) -> U1 a -> U1 b #

Extend ((,) e) 
Instance details

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) 
Instance details

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 :: * -> *) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

Defined in Control.Lens.Reified

Extend f => Extend (MaybeApply f) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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 :: * -> *) 
Instance details

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) 
Instance details

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) 
Instance details

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) 
Instance details

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 #

Bifunctor

class Bifunctor (p :: * -> * -> *) where #

A bifunctor is a type constructor that takes two type arguments and is a functor in both arguments. That is, unlike with Functor, a type constructor such as Either does not need to be partially applied for a Bifunctor instance, and the methods in this class permit mapping functions over the Left value or the Right value, or both at the same time.

Formally, the class Bifunctor represents a bifunctor from Hask -> Hask.

Intuitively it is a bifunctor where both the first and second arguments are covariant.

You can define a Bifunctor by either defining bimap or by defining both first and second.

If you supply bimap, you should ensure that:

bimap id idid

If you supply first and second, ensure:

first idid
second idid

If you supply both, you should also ensure:

bimap f g ≡ first f . second g

These ensure by parametricity:

bimap  (f . g) (h . i) ≡ bimap f h . bimap g i
first  (f . g) ≡ first  f . first  g
second (f . g) ≡ second f . second g

Since: base-4.8.0.0

Minimal complete definition

bimap | first, second

Methods

bimap :: (a -> b) -> (c -> d) -> p a c -> p b d #

Map over both arguments at the same time.

bimap f g ≡ first f . second g

Examples

Expand
>>> bimap toUpper (+1) ('j', 3)
('J',4)
>>> bimap toUpper (+1) (Left 'j')
Left 'J'
>>> bimap toUpper (+1) (Right 3)
Right 4

first :: (a -> b) -> p a c -> p b c #

Map covariantly over the first argument.

first f ≡ bimap f id

Examples

Expand
>>> first toUpper ('j', 3)
('J',3)
>>> first toUpper (Left 'j')
Left 'J'

second :: (b -> c) -> p a b -> p a c #

Map covariantly over the second argument.

secondbimap id

Examples

Expand
>>> second (+1) ('j', 3)
('j',4)
>>> second (+1) (Right 3)
Right 4
Instances
Bifunctor Either

Since: base-4.8.0.0

Instance details

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d #

first :: (a -> b) -> Either a c -> Either b c #

second :: (b -> c) -> Either a b -> Either a c #

Bifunctor (,)

Since: base-4.8.0.0

Instance details

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> (a, c) -> (b, d) #

first :: (a -> b) -> (a, c) -> (b, c) #

second :: (b -> c) -> (a, b) -> (a, c) #

Bifunctor Arg

Since: base-4.9.0.0

Instance details

Defined in Data.Semigroup

Methods

bimap :: (a -> b) -> (c -> d) -> Arg a c -> Arg b d #

first :: (a -> b) -> Arg a c -> Arg b c #

second :: (b -> c) -> Arg a b -> Arg a c #

Bifunctor Gr 
Instance details

Defined in Data.Graph.Inductive.PatriciaTree

Methods

bimap :: (a -> b) -> (c -> d) -> Gr a c -> Gr b d #

first :: (a -> b) -> Gr a c -> Gr b c #

second :: (b -> c) -> Gr a b -> Gr a c #

Bifunctor Entry 
Instance details

Defined in Data.Heap

Methods

bimap :: (a -> b) -> (c -> d) -> Entry a c -> Entry b d #

first :: (a -> b) -> Entry a c -> Entry b c #

second :: (b -> c) -> Entry a b -> Entry a c #

Bifunctor ((,,) x1)

Since: base-4.8.0.0

Instance details

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> (x1, a, c) -> (x1, b, d) #

first :: (a -> b) -> (x1, a, c) -> (x1, b, c) #

second :: (b -> c) -> (x1, a, b) -> (x1, a, c) #

Bifunctor (Const :: * -> * -> *)

Since: base-4.8.0.0

Instance details

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d #

first :: (a -> b) -> Const a c -> Const b c #

second :: (b -> c) -> Const a b -> Const a c #

Functor f => Bifunctor (FreeF f) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

bimap :: (a -> b) -> (c -> d) -> FreeF f a c -> FreeF f b d #

first :: (a -> b) -> FreeF f a c -> FreeF f b c #

second :: (b -> c) -> FreeF f a b -> FreeF f a c #

Functor f => Bifunctor (CofreeF f) 
Instance details

Defined in Control.Comonad.Trans.Cofree

Methods

bimap :: (a -> b) -> (c -> d) -> CofreeF f a c -> CofreeF f b d #

first :: (a -> b) -> CofreeF f a c -> CofreeF f b c #

second :: (b -> c) -> CofreeF f a b -> CofreeF f a c #

Bifunctor (Tagged :: * -> * -> *) 
Instance details

Defined in Data.Tagged

Methods

bimap :: (a -> b) -> (c -> d) -> Tagged a c -> Tagged b d #

first :: (a -> b) -> Tagged a c -> Tagged b c #

second :: (b -> c) -> Tagged a b -> Tagged a c #

Bifunctor (K1 i :: * -> * -> *)

Since: base-4.9.0.0

Instance details

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> K1 i a c -> K1 i b d #

first :: (a -> b) -> K1 i a c -> K1 i b c #

second :: (b -> c) -> K1 i a b -> K1 i a c #

Bifunctor ((,,,) x1 x2)

Since: base-4.8.0.0

Instance details

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> (x1, x2, a, c) -> (x1, x2, b, d) #

first :: (a -> b) -> (x1, x2, a, c) -> (x1, x2, b, c) #

second :: (b -> c) -> (x1, x2, a, b) -> (x1, x2, a, c) #

Bifunctor ((,,,,) x1 x2 x3)

Since: base-4.8.0.0

Instance details

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, d) #

first :: (a -> b) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, c) #

second :: (b -> c) -> (x1, x2, x3, a, b) -> (x1, x2, x3, a, c) #

Bifunctor p => Bifunctor (WrappedBifunctor p) 
Instance details

Defined in Data.Bifunctor.Wrapped

Methods

bimap :: (a -> b) -> (c -> d) -> WrappedBifunctor p a c -> WrappedBifunctor p b d #

first :: (a -> b) -> WrappedBifunctor p a c -> WrappedBifunctor p b c #

second :: (b -> c) -> WrappedBifunctor p a b -> WrappedBifunctor p a c #

Functor g => Bifunctor (Joker g :: * -> * -> *) 
Instance details

Defined in Data.Bifunctor.Joker

Methods

bimap :: (a -> b) -> (c -> d) -> Joker g a c -> Joker g b d #

first :: (a -> b) -> Joker g a c -> Joker g b c #

second :: (b -> c) -> Joker g a b -> Joker g a c #

Bifunctor p => Bifunctor (Flip p) 
Instance details

Defined in Data.Bifunctor.Flip

Methods

bimap :: (a -> b) -> (c -> d) -> Flip p a c -> Flip p b d #

first :: (a -> b) -> Flip p a c -> Flip p b c #

second :: (b -> c) -> Flip p a b -> Flip p a c #

Functor f => Bifunctor (Clown f :: * -> * -> *) 
Instance details

Defined in Data.Bifunctor.Clown

Methods

bimap :: (a -> b) -> (c -> d) -> Clown f a c -> Clown f b d #

first :: (a -> b) -> Clown f a c -> Clown f b c #

second :: (b -> c) -> Clown f a b -> Clown f a c #

Bifunctor ((,,,,,) x1 x2 x3 x4)

Since: base-4.8.0.0

Instance details

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, d) #

first :: (a -> b) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, c) #

second :: (b -> c) -> (x1, x2, x3, x4, a, b) -> (x1, x2, x3, x4, a, c) #

(Bifunctor p, Bifunctor q) => Bifunctor (Sum p q) 
Instance details

Defined in Data.Bifunctor.Sum

Methods

bimap :: (a -> b) -> (c -> d) -> Sum p q a c -> Sum p q b d #

first :: (a -> b) -> Sum p q a c -> Sum p q b c #

second :: (b -> c) -> Sum p q a b -> Sum p q a c #

(Bifunctor f, Bifunctor g) => Bifunctor (Product f g) 
Instance details

Defined in Data.Bifunctor.Product

Methods

bimap :: (a -> b) -> (c -> d) -> Product f g a c -> Product f g b d #

first :: (a -> b) -> Product f g a c -> Product f g b c #

second :: (b -> c) -> Product f g a b -> Product f g a c #

Bifunctor ((,,,,,,) x1 x2 x3 x4 x5)

Since: base-4.8.0.0

Instance details

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, d) #

first :: (a -> b) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, c) #

second :: (b -> c) -> (x1, x2, x3, x4, x5, a, b) -> (x1, x2, x3, x4, x5, a, c) #

(Functor f, Bifunctor p) => Bifunctor (Tannen f p) 
Instance details

Defined in Data.Bifunctor.Tannen

Methods

bimap :: (a -> b) -> (c -> d) -> Tannen f p a c -> Tannen f p b d #

first :: (a -> b) -> Tannen f p a c -> Tannen f p b c #

second :: (b -> c) -> Tannen f p a b -> Tannen f p a c #

(Bifunctor p, Functor f, Functor g) => Bifunctor (Biff p f g) 
Instance details

Defined in Data.Bifunctor.Biff

Methods

bimap :: (a -> b) -> (c -> d) -> Biff p f g a c -> Biff p f g b d #

first :: (a -> b) -> Biff p f g a c -> Biff p f g b c #

second :: (b -> c) -> Biff p f g a b -> Biff p f g a c #

class Bifunctor p => Swapped (p :: * -> * -> *) where #

This class provides for symmetric bifunctors.

Minimal complete definition

swapped

Methods

swapped :: (Profunctor p, Functor f) => p (p b a) (f (p d c)) -> p (p a b) (f (p c d)) #

swapped . swappedid
first f . swapped = swapped . second f
second g . swapped = swapped . first g
bimap f g . swapped = swapped . bimap g f
>>> (1,2)^.swapped
(2,1)
Instances
Swapped Either 
Instance details

Defined in Control.Lens.Iso

Methods

swapped :: (Profunctor p, Functor f) => p (Either b a) (f (Either d c)) -> p (Either a b) (f (Either c d)) #

Swapped (,) 
Instance details

Defined in Control.Lens.Iso

Methods

swapped :: (Profunctor p, Functor f) => p (b, a) (f (d, c)) -> p (a, b) (f (c, d)) #

Biapply

class Bifunctor p => Biapply (p :: * -> * -> *) where #

Minimal complete definition

(<<.>>)

Methods

(<<.>>) :: p (a -> b) (c -> d) -> p a c -> p b d infixl 4 #

(.>>) :: p a b -> p c d -> p c d infixl 4 #

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

(<<.) :: p a b -> p c d -> p a b infixl 4 #

a <. b ≡ const <$> a <.> b
Instances
Biapply (,) 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<<.>>) :: (a -> b, c -> d) -> (a, c) -> (b, d) #

(.>>) :: (a, b) -> (c, d) -> (c, d) #

(<<.) :: (a, b) -> (c, d) -> (a, b) #

Biapply Arg 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<<.>>) :: Arg (a -> b) (c -> d) -> Arg a c -> Arg b d #

(.>>) :: Arg a b -> Arg c d -> Arg c d #

(<<.) :: Arg a b -> Arg c d -> Arg a b #

Semigroup x => Biapply ((,,) x) 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<<.>>) :: (x, a -> b, c -> d) -> (x, a, c) -> (x, b, d) #

(.>>) :: (x, a, b) -> (x, c, d) -> (x, c, d) #

(<<.) :: (x, a, b) -> (x, c, d) -> (x, a, b) #

Biapply (Const :: * -> * -> *) 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<<.>>) :: Const (a -> b) (c -> d) -> Const a c -> Const b d #

(.>>) :: Const a b -> Const c d -> Const c d #

(<<.) :: Const a b -> Const c d -> Const a b #

Biapply (Tagged :: * -> * -> *) 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<<.>>) :: Tagged (a -> b) (c -> d) -> Tagged a c -> Tagged b d #

(.>>) :: Tagged a b -> Tagged c d -> Tagged c d #

(<<.) :: Tagged a b -> Tagged c d -> Tagged a b #

(Semigroup x, Semigroup y) => Biapply ((,,,) x y) 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<<.>>) :: (x, y, a -> b, c -> d) -> (x, y, a, c) -> (x, y, b, d) #

(.>>) :: (x, y, a, b) -> (x, y, c, d) -> (x, y, c, d) #

(<<.) :: (x, y, a, b) -> (x, y, c, d) -> (x, y, a, b) #

(Semigroup x, Semigroup y, Semigroup z) => Biapply ((,,,,) x y z) 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<<.>>) :: (x, y, z, a -> b, c -> d) -> (x, y, z, a, c) -> (x, y, z, b, d) #

(.>>) :: (x, y, z, a, b) -> (x, y, z, c, d) -> (x, y, z, c, d) #

(<<.) :: (x, y, z, a, b) -> (x, y, z, c, d) -> (x, y, z, a, b) #

Biapply p => Biapply (WrappedBifunctor p) 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<<.>>) :: WrappedBifunctor p (a -> b) (c -> d) -> WrappedBifunctor p a c -> WrappedBifunctor p b d #

(.>>) :: WrappedBifunctor p a b -> WrappedBifunctor p c d -> WrappedBifunctor p c d #

(<<.) :: WrappedBifunctor p a b -> WrappedBifunctor p c d -> WrappedBifunctor p a b #

Apply g => Biapply (Joker g :: * -> * -> *) 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<<.>>) :: Joker g (a -> b) (c -> d) -> Joker g a c -> Joker g b d #

(.>>) :: Joker g a b -> Joker g c d -> Joker g c d #

(<<.) :: Joker g a b -> Joker g c d -> Joker g a b #

Biapply p => Biapply (Flip p) 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<<.>>) :: Flip p (a -> b) (c -> d) -> Flip p a c -> Flip p b d #

(.>>) :: Flip p a b -> Flip p c d -> Flip p c d #

(<<.) :: Flip p a b -> Flip p c d -> Flip p a b #

Apply f => Biapply (Clown f :: * -> * -> *) 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<<.>>) :: Clown f (a -> b) (c -> d) -> Clown f a c -> Clown f b d #

(.>>) :: Clown f a b -> Clown f c d -> Clown f c d #

(<<.) :: Clown f a b -> Clown f c d -> Clown f a b #

(Biapply p, Biapply q) => Biapply (Product p q) 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<<.>>) :: Product p q (a -> b) (c -> d) -> Product p q a c -> Product p q b d #

(.>>) :: Product p q a b -> Product p q c d -> Product p q c d #

(<<.) :: Product p q a b -> Product p q c d -> Product p q a b #

(Apply f, Biapply p) => Biapply (Tannen f p) 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<<.>>) ::