Why is it priced like this?

Question

I have a function

doubleMe :: Num a => [a] -> [a]
doubleMe [] = []
doubleMe (x:xs) = (2*x):(doubleMe xs)

Consider this:

doubleMe(doubleMe([1,2,3]))

The first step is obviously

doubleMe(doubleMe([1,2,3])) = doubleMe(2:doubleMe[2,3])

because there are no other possibilities.

This is the next step I'm curious about. Why exactly

doubleMe(2:doubleMe[2,3]) = 4:(doubleMe(doubleMe([2,3])))

instead

doubleMe(2:doubleMe[2,3]) = doubleMe(2:4:doubleMe([3]))

?

The only answer that I have been able to find so far is

Because it makes sense. Otherwise, Haskell will not lazily act on lists.

But this is not an answer, but an answer. What is the real answer?

Answer 1

The first step is obviously doubleMe(doubleMe([1,2,3])) = doubleMe(2:doubleMe[2,3])

Well, actually not obvious!

For distinguishability,

doubleMe' = doubleMe

and consider

doubleMe' $ doubleMe [1,2,3]

The only reason you took the first step, namely

≡ doubleMe' $ 2 : doubleMe [2,3]

, doubleMe' [] _:_. doubleMe [1,2,3], . 2 : doubleMe [2,3], doubleMe' :

≡ 4 : doubleMe' (doubleMe [2,3])

---

, : (, ), - , , , .. doubleMe [1..] , .

GHC .

Answer 2

, case case Haskell [1]. , " ":

doubleMe(doubleMe([1,2,3]))

, . Haskell [1]. , (), , - case, . , case?

case doubleMe (doubleMe [1,2,3]) of
    []     -> ...
    x : xs -> ... x ... xs ...

. , ( desugaring case)

case (case doubleMe [1,2,3] of
          []   -> []
          x:xs -> (2*x) : doubleMe xs)
     ) of
    []     -> ...
    x : xs -> ... x ... xs ...

,

case (case (case [1,2,3] of
                 []   -> []
                 x:xs -> (2*x) : doubleMe xs
           ) of
          []   -> []
          x:xs -> (2*x) : doubleMe xs)
     ) of
    []     -> ...
    x : xs -> ... x ... xs ...

case. , : : 1 xs [2,3].

case (case ((2*1) : doubleMe [2,3]
           ) of
          []   -> []
          x:xs -> (2*x) : doubleMe xs)
     ) of
    []     -> ...
    x : xs -> ... x ... xs ...

case , ( :) x (2*1) xs doubleMe [2,3].

case ((2*(2*1)) : doubleMe (doubleMe [2,3]))
     ) of
    []     -> ...
    x : xs -> ... x ... xs ...

, , case

... (2*(2*1)) ... doubleMe (doubleMe [2,3])) ...

, (2*(2*1)) doubleMe (doubleMe [2,3])). , - case, , .

---

[1] , Haskell. , Haskell -, , , .