Q:

Haskell Convert 1-800 Numbers

This little app converts 1-800 numbers (with letters) to actual numbers. I'm very frustrated by the insertDashes function as it's very brute force. I'm sure there's a far more elegant solution. I'd appreciate any feedback on anything else though.
module Dial
    ( enter,
    stripDashes
    ) where

import Data.Char (ord, toLower, isNumber, intToDigit, isPunctuation)
import System.IO
import Data.List

enter = do
    putStrLn "Enter a phone number"
    num <- getLine
    let converted = insertDashes $ convertLetters $ stripDashes num
    putStrLn $ "You may dial " ++ converted

stripDashes :: String -> String
stripDashes xs = [ x | x <- xs, not (elem x  "-") ]

insertDashes :: String -> String
insertDashes xs = take 1 xs ++ ['-'] ++ take 3 (drop 1 xs) ++ ['-'] ++ take 3 (drop 4 xs) ++ ['-'] ++ take 4 (drop 7 xs) 

getDigit :: Char -> Int
getDigit letter
    | (ord letter >= 97) && (ord letter <= 99) = 2
    | ord letter <= 102 = 3
    | ord letter <= 105 = 4
    | ord letter <= 108 = 5
    | ord letter <= 111 = 6
    | ord letter <= 115 = 7
    | ord letter <= 118 = 8
    | ord letter <= 122 = 9
    | otherwise = 0

convertLetters :: String -> String
convertLetters xs = map (\x -> if (isNumber x) then x else (intToDigit $ getDigit $ toLower x)) xs

A:

Type signatures
Good job on providing all type signatures. Unfortunately, you forgot one: enter. Always include type signatures on top-level functions.
Remove unused imports
You use neither Data.List, nor System.IO.
Prefer character comparison instead of ord x > n
In getDigit, you compare characters by their ord values. That's not easy on the eye. It's a lot easier to read if you just compare the letter with characters:
getDigit :: Char -> Int
getDigit letter
    | letter >= 'a' && letter <= 'c' = 2
    | letter <= 'f' = 3
    | letter <= 'i' = 4
    | letter <= 'l' = 5
    | letter <= 'o' = 6
    | letter <= 's' = 7
    | letter <= 'v' = 8
    | letter <= 'z' = 9
    | otherwise = 0

There are other ways to write getDigit, but I they differ on personal preference only.
Use the standard library
stripDashes is filter (/= '-') in disguise:
stripDashes xs = [ x | x <- xs, not (elem x  "-")]
               = [ x | x <- xs, x /= '-']
               = filter (/= '-') xs

Therefore use filter instead of a list comprehension:
stripDashes :: String -> String
stripDashes = filter (/= '-')

By the way not (elem x y) is notElem x y.
Prefer local bindings instead of long lines
This is personal preference, but I think that
convertLetters :: String -> String
convertLetters xs = map toDigit xs
  where
    toDigit x 
     | isNumber x = x 
     | otherwise  = intToDigit $ getDigit $ toLower x

is easier to read.
Use hlint to get rid of redundant brackets
You have a lot of redundant brackets, which can make the code hard to read. hlint can report them to you. It also reports the not (elem x y) == notElem x y hint, by the way.
Prefer pure functions if possible
You have enter for a complete transformation. It would be great if there was a non-IO variant too, e.g.
convert :: String -> String
convert = insertDashes . convertLetters . stripDashes

That way you can export enter, conver and stripDashes.
Use splitAt instead of take/drop combinations
Finally, we have a look at insertDashes. First of all, let's write bindings:
insertDashes :: String -> String
insertDashes xs = group1 ++ ['-'] ++ group2 ++ ['-'] ++ group3 ++ ['-'] ++ group4 
   where
      group1 = take 1 xs
      group2 = take 3 (drop 1 xs)
      group3 = take 3 (drop 4 xs)
      group4 = take 4 (drop 7 xs)

That looks like a perfect job for splitAt:
-- do not include this function in your code, it's part of the Prelude
splitAt n xs = (take n xs, drop n xs)

However, if we were to rewrite insertDashes with splitAt, it wouldn't get any better immediately:
import Data.List (intercalate)

insertDashes :: String -> String
insertDashes xs = group1 ++ ['-'] ++ group2 ++ ['-'] ++ group3 ++ ['-'] ++ group4 
   where
      (group1,ys1) = splitAt 1 xs
      (group2,ys2) = splitAt 3 ys1
      (group3,ys3) = splitAt 3 ys2
      (group4,_  ) = splitAt 4 ys3

Ugh. Not really any better. So instead let's write another function:
splitAtNs :: [Int] -> [a] -> [[a]]
splitAtNs []     xs = [xs]
splitAtNs (n:ns) xs = as : splitAtNs ns bs
  where (as, bs) = splitAt n xs

Now  insertDashes is
insertDashes :: String -> String
insertDashes xs = group1 ++ ['-'] ++ group2 ++ ['-'] ++ group3 ++ ['-'] ++ group4 
   where
      (group1:group2:group3:group4:_) = splitAtNs [1,3,3,4] xs

Which almost looks fine. There is one more improvement, though. The function intercalate from Data.List brings it down to a single line:
insertDashes :: String -> String
insertDashes = intercalate "-" . take 4 . splitAtNs [1,3,3,4]

