base-prelude-1.6.1: Featureful preludes formed solely from the "base" package

BasePrelude.Operators

Description

A collection of common operators provided across various modules of the "base" package.

Synopsis

# From Control.Applicative

(*>) :: Applicative f => f a -> f b -> f b infixl 4 Source #

Sequence actions, discarding the value of the first argument.

'as *> bs' can be understood as the do expression

do as
bs


This is a tad complicated for our ApplicativeDo extension which will give it a Monad constraint. For an Applicative constraint we write it of the form

do _ <- as
b <- bs
pure b


(<*) :: Applicative f => f a -> f b -> f a infixl 4 Source #

Sequence actions, discarding the value of the second argument.

Using ApplicativeDo: 'as <* bs' can be understood as the do expression

do a <- as
bs
pure a


(<*>) :: Applicative f => f (a -> b) -> f a -> f b infixl 4 Source #

Sequential application.

A few functors support an implementation of <*> that is more efficient than the default one.

Using ApplicativeDo: 'fs <*> as' can be understood as the do expression

do f <- fs
a <- as
pure (f a)


(<**>) :: Applicative f => f a -> f (a -> b) -> f b infixl 4 Source #

A variant of <*> with the arguments reversed.

Using ApplicativeDo: 'as <**> fs' can be understood as the do expression

do a <- as
f <- fs
pure (f a)


(<|>) :: Alternative f => f a -> f a -> f a infixl 3 Source #

An associative binary operation

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c infixr 1 Source #

Right-to-left composition of Kleisli arrows. (>=>), with the arguments flipped.

Note how this operator resembles function composition (.):

(.)   ::            (b ->   c) -> (a ->   b) -> a ->   c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c

(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 Source #

Same as >>=, but with the arguments interchanged.

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 Source #

Left-to-right composition of Kleisli arrows.

'(bs >=> cs) a' can be understood as the do expression

do b <- bs a
cs b


(>>) :: Monad m => m a -> m b -> m b infixl 1 Source #

Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.

'as >> bs' can be understood as the do expression

do as
bs


(>>=) :: Monad m => m a -> (a -> m b) -> m b infixl 1 Source #

Sequentially compose two actions, passing any value produced by the first as an argument to the second.

'as >>= bs' can be understood as the do expression

do a <- as
bs a


# From Data.Bits

(.&.) :: Bits a => a -> a -> a infixl 7 Source #

Bitwise "and"

(.|.) :: Bits a => a -> a -> a infixl 5 Source #

Bitwise "or"

# From Data.Bool

(&&) :: Bool -> Bool -> Bool infixr 3 Source #

Boolean "and", lazy in the second argument

(||) :: Bool -> Bool -> Bool infixr 2 Source #

Boolean "or", lazy in the second argument

(/=) :: Eq a => a -> a -> Bool infix 4 Source #

(==) :: Eq a => a -> a -> Bool infix 4 Source #

($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b infixr 0 Source # Application operator. This operator is redundant, since ordinary application (f x) means the same as (f$ x). However, $ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example: f$ g $h x = f (g (h x)) It is also useful in higher-order situations, such as map ($ 0) xs, or zipWith ($) fs xs. Note that ($) is levity-polymorphic in its result type, so that foo $True where foo :: Bool -> Int# is well-typed. (&) :: a -> (a -> b) -> b infixl 1 Source # & is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $. >>> 5 & (+1) & show "6"  Since: base-4.8.0.0 (.) :: (b -> c) -> (a -> b) -> a -> c infixr 9 Source # Function composition. # From Data.Functor ($>) :: Functor f => f a -> b -> f b infixl 4 Source #

Flipped version of <$. Using ApplicativeDo: 'as$> b' can be understood as the do expression

do as
pure b


with an inferred Functor constraint.

#### 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 => a -> f b -> f a infixl 4 Source # 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. Using ApplicativeDo: 'a <$ bs' can be understood as the do expression

do bs
pure a


with an inferred Functor constraint.

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 Source # 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 -> (a -> b) -> f b infixl 1 Source #

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 # From Data.Functor.Contravariant (>$) :: Contravariant f => b -> f b -> f a infixl 4 Source #

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

(>$<) :: Contravariant f => (a -> b) -> f b -> f a infixl 4 Source # This is an infix alias for contramap. (>$$<) :: Contravariant f => f b -> (a -> b) -> f a infixl 4 Source # This is an infix version of contramap with the arguments flipped. ($<) :: Contravariant f => f b -> b -> f a infixl 4 Source #

This is >$ with its arguments flipped. # From Data.Ord (<) :: Ord a => a -> a -> Bool infix 4 Source # (<=) :: Ord a => a -> a -> Bool infix 4 Source # (>) :: Ord a => a -> a -> Bool infix 4 Source # (>=) :: Ord a => a -> a -> Bool infix 4 Source # # From Data.Ratio (%) :: Integral a => a -> a -> Ratio a infixl 7 Source # Forms the ratio of two integral numbers. # From Data.Semigroup (<>) :: Semigroup a => a -> a -> a infixr 6 Source # An associative operation. >>> [1,2,3] <> [4,5,6] [1,2,3,4,5,6]  # From Prelude ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b infixr 0 Source #

Strict (call-by-value) application operator. It takes a function and an argument, evaluates the argument to weak head normal form (WHNF), then calls the function with that value.

(*) :: Num a => a -> a -> a infixl 7 Source #

(+) :: Num a => a -> a -> a infixl 6 Source #

(-) :: Num a => a -> a -> a infixl 6 Source #

(/) :: Fractional a => a -> a -> a infixl 7 Source #

Fractional division.

(^) :: (Num a, Integral b) => a -> b -> a infixr 8 Source #

raise a number to a non-negative integral power

(^^) :: (Fractional a, Integral b) => a -> b -> a infixr 8 Source #

raise a number to an integral power