$ -pretty -base

($!!) :: NFData a => (a -> b) -> a -> b
deepseq Control.DeepSeq
the deep analogue of $!. In the expression f $!! x, x is fully evaluated before the function f is applied to it.
($$) :: Doc -> Doc -> Doc
template-haskell Language.Haskell.TH.PprLib
Above; if there is no overlap it "dovetails" the two
($+$) :: Doc -> Doc -> Doc
template-haskell Language.Haskell.TH.PprLib
Above, without dovetailing.
($=) :: HasSetter s => s a -> a -> IO ()
OpenGL Graphics.Rendering.OpenGL.GL.StateVar
($=!) :: HasSetter s => s a -> a -> IO ()
OpenGL Graphics.Rendering.OpenGL.GL.StateVar
A variant of $= which is strict in the value to be set.
($|) :: (a -> b) -> Strategy a -> a -> b
parallel Control.Parallel.Strategies
Sequential function application. The argument is evaluated using the given strategy before it is given to the function.
($||) :: (a -> b) -> Strategy a -> a -> b
parallel Control.Parallel.Strategies
Parallel function application. The argument is evaluated using the given strategy, in parallel with the function application.
($~) :: (HasGetter v, HasSetter v) => v a -> (a -> a) -> IO ()
OpenGL Graphics.Rendering.OpenGL.GL.StateVar
A modificator convenience function, transforming the contents of a state variable with a given funtion.
($~!) :: (HasGetter v, HasSetter v) => v a -> (a -> a) -> IO ()
OpenGL Graphics.Rendering.OpenGL.GL.StateVar
A variant of $~ which is strict in the transformed value.
(<$$>) :: Stream s Identity tok => (a -> b) -> Parsec s st a -> StreamPermParser s st b
parsec Text.Parsec.Perm, parsec Text.ParserCombinators.Parsec.Perm
The expression f <$$> p creates a fresh permutation parser consisting of parser p. The the final result of the permutation parser is the function f applied to the return value of p. The parser p is not allowed to accept empty input - use the optional combinator (<$?>) instead. If the function f takes more than one parameter, the type variable b is instantiated to a functional type which combines nicely with the adds parser p to the (<||>) combinator. This results in stylized code permutation parser starts with a combining function f followed by the parsers. The function f gets its parameters in the order in which the parsers are specified, but actual input can be in any order.
(<$?>) :: Stream s Identity tok => (a -> b) -> (a, Parsec s st a) -> StreamPermParser s st b
parsec Text.Parsec.Perm, parsec Text.ParserCombinators.Parsec.Perm
The expression f <$?> (x,p) creates a fresh permutation parser consisting of parser p. The the final result of the permutation parser is the function f applied to the return value of p. The parser p is optional - if it can not be applied, the default value x will be used instead.
(>$<) :: Contravariant f => (b -> a) -> f a -> f b
bytestring Data.ByteString.Builder.Prim
A fmap-like operator for builder primitives, both bounded and fixed size. Builder primitives are contravariant so it's like the normal fmap, but backwards (look at the type). (If it helps to remember, the operator symbol is like ($) but backwards.) We can use it for example to prepend and/or append fixed values to an primitive. > showEncoding ((\x -> ('\'', (x, '\''))) >$< fixed3) 'x' = "'x'" > > fixed3 = char7 >*< char7 >*< char7 Note that the rather verbose syntax for composition stems from the requirement to be able to compute the size / size bound at compile time.