arrays - Why is this tail-recursive Haskell function slower ? -

I was trying to apply a Haskell function which takes an array of input as input and one Other array B = [A [0], A [0] + A [1], A [0] + A [1] + A [2], ...]. I know that with scanl function (+) from data.List can be used for this. I saw the second implementation (which works fast) after looking at the source code of ScanLL, I want to know why despite being tail-recursive, why is it slower than the other one?

  - This function creates slow ps sx [] = x ps sxy = ps' x 'y' s' = s + head yx '= x ++ [s'] y' = Tail Y - This function works fast. ps' s [] = [] ps' sy = [s'] ++ (ps' y ') where s' = s + head yy' = tail y   
 some code above Details about:  
 Implementation 1: It should be named after  
  ps 0 [] a   
. 'Your array is.  
 Implementation 2: It is called  
  ps' 0 a   
, where 'A' is your array.  
  
 
 
 The way you are changing  ++  associates your first function You are computing in  ((([a0] ++ [a1]) ++ [a2]) ++ ...  while in another function you are computing  [A0 ] ++ ([a1] ++ ([a2] ++ ..))  adding some element at the beginning of the list is  O (1) , while at the end of a list Adding some element lists the length of  o (n) . This leads to a linear versus quadratic algorithm.  
 You can reverse o You can fix the first example by creating the list in the order, and then at the end can be reversed or use something like the list, though the second will still be better for most purposes, whereas the tail calls are present and the Haskell Can be important, if you are familiar with hard working language like a scheme or ml, how to use it and how and when it is completely wrong.  
 Ra example is better, in large part, because it is incremental; it may start immediately return data which interested customers. If you have set the first example using the trick of double-reverse or list, before you return anything, your function will be in the entire list.