It is good practice in Haskell to separate the functional code from the IO. In this case, you could (and therefore should) define a lolcat :: String -> String function. Be sure to put a type declaration on all functions — you didn't write one for your main.

Defining variables a, b, c, and d is overkill. I would write this as a composition of functions.

lolcat :: String -> String
lolcat = strReplace " A " " " .
         strReplace "CHEESEBURGER" "CHEEZBURGER" .
         strReplace "CAN I" "I CAN" .
         strReplace "HAVE" "HAS" .
         strToUpper

I agree with 200_success and am just typing out the full program because you said you were a beginner.

import Data.Strings

encode :: String -> String
encode = strReplace " A " " "
       . strReplace "CHEESEBURGER" "CHEEZBURGER"
       . strReplace "CAN I" "I CAN"
       . strReplace "HAVE" "HAS"
       . strToUpper

main :: IO ()
main = do 
   putStrLn "Enter your text to translate"

   input <- getLine
   putStrLn $ encode input

The main function would perhaps more commonly be written as:

main :: IO ()
main = do
   putStrLn "Enter your text to translate"
   putStrLn =<< encode <$> getLine

EDIT:

@MichaelKlein asked me to explain (<$>) and (=<<), so I will do so as briefly as possible.

<$> is the inline version of fmap, which is the only function from the Functor typeclass. A typeclass is somewhat like a interface in an imperial language like Java.

class Functor f where
   fmap :: (a -> b) -> f a -> f b

fmap is used to run a function (a -> b) inside some data structure f a

fmap (+1) [1]      == [2]
fmap (+1) (Just 3) == Just 4
(+1) <$> (Just 3)  == Just 4

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

In Haskell, we treat the world as a datastructure IO. So just in the same way that you can run a function inside a list or a maybe (like Just 3), you can run a function inside a IO.

encode             :: String -> String
getLine            :: IO String
encode <$> getLine :: IO String

(=<<) is part of the Monad typeclass, which is hard to explain briefly because you need to know about a few other typeclasses first.

(=<<) :: (a -> m b) -> m a -> m b

(=<<) is pronounced "bind", and is a flipped version of the more common (>>=). The important bit is that Haskell has a special syntax for working with monads: the do notation.

This:

main = do
  input <- getLine
  putStrLn input

Is syntatic sugar for this:

main = getLine >>= \input -> putStrLn input

Which is the same as this:

main = getLine >>= putStrLn

All of these are also equal:

main = do
   putStrLn "burger"
   input <- getLine
   putStrLn $ encode input

main = putStrLn "burger" 
    >> getLine >>= \input -> putStrLn $ encode input

main = putStrLn "burger" 
    >> encode <$> getLine >>= putStrLn

main = do 
  putStrLn "burger" 
  putStrLn =<< encode <$> getLine 

Remove repetition

You repeat a strReplace a lot:

        vvvvvvvvv
let a = strReplace "HAVE" "HAS" capsText
let b = strReplace "CAN I" "I CAN" a
let c = strReplace "CHEESEBURGER" "CHEEZBURGER" b
let d = strReplace " A " " " c
        ^^^^^^^^^^

What changes is what should be replaced by what: [("HAVE", "HAS"), ("CAN I", "I CAN"), ...]

Therefore your program should state the idea of replacement once and then contain this list of "replacement instructions".

To be more clear the function you should use has type String -> [(String, String)] -> String and example usage:

> replaceByTuples "foobar" [("foo", "fuu"),("bar", "baz")]
"fuubaz"

Using this function with your particular list of replacements will be easy.

This function is in this spoiler block. I advise you try to implement it by yourself.

import Data.List.Utils;


replaceByTuples s t = (foldl (.) id $ map (\(start, end) -> replace start end) t) s
More info and better implementations about this function to be found at: http://stackoverflow.com/questions/7862221/how-do-i-do-string-replace-in-haskell

I agree with the other two answers, but I would use interact in main. This will make your program infinitely loop until there's no more input which may not be what you want, but it will solve the problem of keeping the console open. You'll have to define an eachLine function so that the program processes one line at a time as detailed in this stackoverflow answer.

As 200_success mentioned, it is good practice to write type-signatures for all top-level functions and main traditionally has type-signature: main :: IO (). Because of the getLine at the end of your main, it would have type-signature: main :: IO String, which would give your program the unintended side-effect of printing an additional string as it terminates. Writing the type-signatures explicitly allows the compiler to catch these sorts of problems.

This would be the full program:

import Data.Strings

main :: IO ()
main = do
    putStrLn "Enter your text to translate"
    interact (eachLine lolcat)

lolcat :: String -> String
lolcat = strReplace " A " " " .
         strReplace "CHEESEBURGER" "CHEEZBURGER" .
         strReplace "CAN I" "I CAN" .
         strReplace "HAVE" "HAS" .
         strToUpper

eachLine :: (String -> String) -> String -> String
eachLine f = unlines . map f . lines