Eq a => a -> a -> [a] -> [a]

replace :: Eq a => a -> a -> [a] -> [a]
cgi Network.CGI.Protocol
Replaces all instances of a value in a list by another value.
enumFromThenTo :: Enum a => a -> a -> a -> [a]
base Prelude
buf_append :: BufferOp a -> a -> a -> a
HTTP Network.BufferType
CondE :: Exp -> Exp -> Exp -> Exp
template-haskell Language.Haskell.TH.Syntax, template-haskell Language.Haskell.TH
> { if e1 then e2 else e3 }
UInfixE :: Exp -> Exp -> Exp -> Exp
template-haskell Language.Haskell.TH.Syntax, template-haskell Language.Haskell.TH
> {x + y} See Note [Unresolved infix] at Language.Haskell.TH.Syntax#infix
HsEnumFromThenTo :: HsExp -> HsExp -> HsExp -> HsExp
haskell-src Language.Haskell.Syntax
bounded arithmetic sequence, with first two elements given
HsIf :: HsExp -> HsExp -> HsExp -> HsExp
haskell-src Language.Haskell.Syntax
if exp then exp else exp
replace :: Text -> Text -> Text -> Text
text Data.Text, text Data.Text.Lazy
O(m+n) Replace every occurrence of one substring with another. In (unlikely) bad cases, this function's time complexity degrades towards O(n*m).
postRequestWithBody :: String -> String -> String -> Request_String
HTTP Network.HTTP
postRequestWithBody urlString typ body is convenience constructor for POST Requests. It constructs a request and sets the body as well as the Content-Type and Content-Length headers. The contents of the body are forced to calculate the value for the Content-Length header. If urlString isn't a syntactically valid URL, the function raises an error.
buf_snoc :: BufferOp a -> a -> Word8 -> a
HTTP Network.BufferType
findWithDefault :: a -> Key -> IntMap a -> a
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(min(n,W)). The expression (findWithDefault def k map) returns the value at key k or returns def when the key is not an element of the map. > findWithDefault 'x' 1 (fromList [(5,'a'), (3,'b')]) == 'x' > findWithDefault 'x' 5 (fromList [(5,'a'), (3,'b')]) == 'a'
readProcess :: FilePath -> [String] -> String -> IO String
process System.Process
readProcess forks an external process, reads its standard output strictly, blocking until the process terminates, and returns the output string. Output is returned strictly, so this is not suitable for interactive applications. This function throws an IOError if the process ExitCode is anything other than ExitSuccess. Users of this function should compile with -threaded if they want other Haskell threads to keep running while waiting on the result of readProcess. > > readProcess "date" [] [] > "Thu Feb 7 10:03:39 PST 2008\n" The arguments are: * The command to run, which must be in the $PATH, or an absolute path * A list of separate command line arguments to the program * A string to pass on the standard input to the program.
InfixE :: (Maybe Exp) -> Exp -> (Maybe Exp) -> Exp
template-haskell Language.Haskell.TH.Syntax, template-haskell Language.Haskell.TH
> {x + y} or {(x+)} or {(+ x)} or {(+)} It's a bit gruesome to use an Exp as the operator, but how else can we distinguish constructors from non-constructors? Maybe there should be a var-or-con type? Or maybe we should leave it to the String itself?
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
base Prelude, base Data.List
The zipWith3 function takes a function which combines three elements, as well as three lists and returns a list of their point-wise combination, analogous to zipWith.
zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
base Data.List
The zipWith4 function takes a function which combines four elements, as well as four lists and returns a list of their point-wise combination, analogous to zipWith.
makeRegexOpts :: RegexMaker regex compOpt execOpt source => compOpt -> execOpt -> source -> regex
regex-base Text.Regex.Base.RegexLike
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
base Control.Applicative
Lift a ternary function to actions.
makeRegexOptsM :: (RegexMaker regex compOpt execOpt source, Monad m) => compOpt -> execOpt -> source -> m regex
regex-base Text.Regex.Base.RegexLike
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
base Control.Monad
Promote a function to a monad, scanning the monadic arguments from left to right (cf. liftM2).
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
base Control.Monad
Promote a function to a monad, scanning the monadic arguments from left to right (cf. liftM2).