Oo 40 000 functions just in one module or written at once or by one day by one programmer? Seriously or are you joking? Quite really really bad design. Don’t forget about 40 000 @doc blocks. 
Yep first example is less error prone, because you have to think twice about the same problem. Firstly you think about types and what function will have to produce, and secondly you just think up names for entities. All is true only if you write @spec before your function. If you write specs for written functions earlier it got less sesne just like writing simple unit tests after implementation. Always is better to think twice about a problem than once. 
Side note:
Haskell is statically typed language untill compilation and got wonderfull types definitions, and they are just like annotations.
sayMe :: (Integral a) => a -> String
sayMe 1 = "One!"
sayMe 2 = "Two!"
sayMe 3 = "Three!"
One more example from Elixir:
def some_function(%Some{p: pattern_match_here_blah, blah: blah} = arg1 :: integer(),
:match = match :: atom(),
arg3 :: integer()) :: integer()
do
# something
end
vs.
@spec some_function(integer(), atom(), integer()) :: integer()
def some_function(%Some{p: pattern_match_here_blah, blah: blah} = arg1,
:match = match,
arg3)
do
# something
end
Which one give you more information when you first look at it?
Second example:
@spec funnier(integer()) :: integer()
def funnier(0), do: 1
def funnier(1), do: 0
def funnier(n), do: funnier(n-1)
So with types in function head you would like to put them where?
# define special clause for types? - it's just spec without @spec polluted by arg names :)
def funnier(n :: integer()) :: integer()
def funnier(0 :: integer()) :: integer(), do: 1 #or just here?
def funnier(1 :: integer()) :: integer(), do: 0 #or maybe here?
def funnier(n :: integer()) :: integer(), do: funnier(n-1) #or here??
# or everywhere???
So?
