Pascal Triangle in Haskell
I don't know if this is more idiomatic, but ever since I've seen an infinite list construction for the Fibonacci numbers, I've been in love with it, so here goes nothing.

pascalTriangle :: [[Integer]]
pascalTriangle = [1] : map newRow pascalTriangle
    where newRow y = 1 : zipWith (+) y (tail y) ++ [1]


To understand this, perhaps first you should look at simpler examples, e.g. an infinite list of zeros,

zeros = 0 : zeros


or the list of natural numbers,

nats = 0 : map (+1) nats


or my favourite, the list of fibonacci numbers,

fibs = 1 : 1 : zipWith (+) fibs (tail fibs)




That being said...

The line

pascalList 1 = [[1], [1, 1]]


is unnecessary, because you've already specified pascalList 0. The line

[([1] ++ pascalCoeff (last pList) ++ [1])]


is equivalent to

[[1] ++ pascalCoeff (last pList) ++ [1]]


which is equivalent to

[ 1 : pascalCoeff (last pList) ++ [1]]


Whenever possible, I try to use functions from the standard library instead of rolling my own using recursion, so for example instead of

pascalCoeff (x:y:ys) = (x+y) : pascalCoeff (y:ys)
pascalCoeff (x:[]) = []


I'd say that this function takes a list e.g. [1,2,3,4] and does the following:

  [1, 2, 3]
  [2, 3, 4]
+ ---------
  [3, 5, 7]


so it takes the tail (all but the first element) of the list, and the init (all but the last element) of the list, and adds them together element-wise.

There are built-in functions tail, and init that yield you these parts from a list, and luckily the function 

zipWith (+)


does the adding part, so you can simply say

pascalCoeff y = zipWith (+) (init y) (tail y)


which is, due to the way zipWith works, the same as

pascalCoeff y = zipWith (+) y (tail y)




Similarly, 

listtoString [] = []
listtoString [x] = show x
listtoString (x:xs) = show x ++ " " ++ listtoString xs


could simply be

listToString = unwords . map show




And

justify :: Int -&gt; [String] -&gt; [String]
justify n (x:xs) = (concat (replicate n " ") ++ x) : justify (n-1) xs
justify _ [] = []


could be

justify n ss = zipWith (++) padding ss
    where padding = [ replicate k ' ' | k &lt;- [n, n-1 .. 1]]


or equivalently, after eta-reduction

justify n = zipWith (++) padding
    where padding = [ replicate k ' ' | k &lt;- [n, n-1 .. 1]]




Due to the fact that lists are linked lists, appending to a list is expensive, while prepending to it is cheap. So if you do decide to construct a list element-by-element, then I'd say you should prepend the new elements, and perhaps after the list is built, use a reverse. 

By the same logic, head is cheap, last is expensive.

Here's a possible implementation that uses what I've just said.

pascalList = reverse . pascalList'
pascalList' 0 = [[1]]
pascalList' n = new : old
    where new = 1 : pascalCoeff (head old) ++ [1]
          old = pascalList' (n-1)




In my opinion it is a good idea to 


separate pure and impure code,
keep your code as modular as possible,
write type signatures,
use a linter like hlint,
use functions from the standard library instead of writing explicit recursions.


Keeping this in mind, here's how I'd write the printing part.

listToString :: (Show a) =&gt; [a] -&gt; String
listToString = unwords . map show

leftPadStrings :: [String] -&gt; [String]
leftPadStrings ss = map leftPad ss
    where maxlen = maximum $ map length ss
          leftPad s = replicate (div (maxlen - length s) 2) ' ' ++ s 

paddedPascalTriangle :: Int -&gt; [String]
paddedPascalTriangle n = leftPadStrings 
                       . map listToString 
                       . take n 
                       $ pascalTriangle

printPascalTriangle :: Int -&gt; IO ()
printPascalTriangle = mapM_ putStrLn . paddedPascalTriangle


Running this, you should get something like the following:

*Main&gt; printPascalTriangle 10
             1
            1 1
           1 2 1
          1 3 3 1
         1 4 6 4 1
       1 5 10 10 5 1
     1 6 15 20 15 6 1
    1 7 21 35 35 21 7 1
  1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1