flip

flip :: (a -> b -> c) -> b -> a -> c

flip f takes its (first) two arguments in the reverse order of f.

flip f x y = f y x

flip . flip = id

Examples

>>> flip (++) "hello" "world"
"worldhello"

>>> let (.>) = flip (.) in (+1) .> show $ 5
"6"

flip :: (a -> b -> c) -> b -> a -> c

hedgehog Hedgehog.Internal.Prelude, base-compat Prelude.Compat, rio RIO.Prelude, base-prelude BasePrelude, classy-prelude ClassyPrelude, numeric-prelude NumericPrelude NumericPrelude.Base, Cabal-syntax Distribution.Compat.Prelude, universum Universum.Function, ihaskell IHaskellPrelude, basement Basement.Compat.Base Basement.Imports, numhask NumHask.Prelude NumHask.Prelude, clash-prelude Clash.HaskellPrelude, foundation Foundation, dimensional Numeric.Units.Dimensional.Prelude, rebase Rebase.Prelude, mixed-types-num Numeric.MixedTypes.PreludeHiding, constrained-categories Control.Category.Constrained.Prelude Control.Category.Hask, LambdaHack Game.LambdaHack.Core.Prelude, cabal-install-solver Distribution.Solver.Compat.Prelude, faktory Faktory.Prelude, vcr Imports, yesod-paginator Yesod.Paginator.Prelude, distribution-opensuse OpenSuse.Prelude, termonad Termonad.Prelude

flip f takes its (first) two arguments in the reverse order of f.

>>> flip (++) "hello" "world"
"worldhello"

flip :: (a -> b -> c) -> b -> a -> c

ghc GHC.Prelude.Basic

flip :: BiMultiMap a b v -> BiMultiMap b a v

distributed-process Control.Distributed.Process.Internal.BiMultiMap

Exchange the first and the second components of all triplets.

flip :: (a -> b -> c) -> b -> a -> c

basic-prelude CorePrelude

flip f takes its (first) two arguments in the reverse order of f.

flip :: () => (a -> b -> c) -> b -> a -> c

prelude-compat Prelude2010

flip f takes its (first) two arguments in the reverse order of f.

>>> flip (++) "hello" "world"
"worldhello"

flip :: (Enum a, Bits w) => a -> T w a -> T w a

enumset Data.EnumBitSet

flip :: forall (repc :: RuntimeRep) a b (c :: TYPE repc) . (a -> b -> c) -> b -> a -> c

ghc-internal GHC.Internal.Data.Function

flip f takes its (first) two arguments in the reverse order of f.

flip f x y = f y x

flip . flip = id

Examples

>>> flip (++) "hello" "world"
"worldhello"

>>> let (.>) = flip (.) in (+1) .> show $ 5
"6"

flip :: Lam2 a b c f -> b x -> a y -> c (Flip f x y)

defun-core DeFun.Function

flip :: (a -> b -> c) <-> (b -> a -> c)

invertible Data.Invertible.Function Data.Invertible.Prelude

flip the order of the first two arguments of a function.

flip :: Fake Text

fakedata Faker.Coin

flip :: Predicate (x : (y : zs)) -> Predicate (y : (x : zs))

falsify Test.Falsify.Predicate

Analogue of flip

flip :: (a -> b -> c) -> b -> a -> c

between Data.Function.Between.Strict.Internal

Strict variant of flip. Defined as:

flip f b a = f $! a $! b

Since version 0.11.0.0.

module Data.Bifunctor.Flip

bifunctors, rerebase

newtype Flip p a b

bifunctors Data.Bifunctor.Flip

Make a Bifunctor flipping the arguments of a Bifunctor.

Flip :: p b a -> Flip p a b

bifunctors Data.Bifunctor.Flip

data Flip

first-class-families Fcf Fcf.Combinators, type-spec Test.TypeSpec.Internal.Apply

type family Flip (a1 :: a ~> b ~> c) (a2 :: b) (a3 :: a) :: c

singletons-base Data.Function.Singletons Prelude.Singletons

module Data.Constraint.Flip

constraints-extras

newtype Flip b l r

barbies Barbies.Bi

Convert a FunctorB into a FunctorT and vice-versa.

Flip :: b r l -> Flip b l r

barbies Barbies.Bi

newtype Flip g a f

rank2classes Rank2

A nested parametric type represented as a rank-2 type

Flip :: g (f a) -> Flip g a f

rank2classes Rank2

type family Flip f b a

defun-core DeFun.Function

Function flip. Combinator C in https://en.wikipedia.org/wiki/B,_C,_K,_W_system.

module Rebase.Data.Bifunctor.Flip

rebase