<h2 dir="auto">Situation</h2>
<p dir="auto">Let's consider the surface expr obtained when parsing short function forms</p>
<div class="highlight highlight-source-julia notranslate position-relative overflow-auto" dir="auto" data-snippet-clipboard-copy-content="f(x::A) = body                          # (= (call f (:: x A)) body)
f(x::A, y::B) = body                    # (= (call f (:: x A) (:: y B)) body)

f(::A) = body                           # (= (call f (:: A)) body)
f()::A = body                           # (= (:: (call f) A) body)
f(::A)::B = body                        # (= (:: (call f (:: A)) B) body)

f(x::A) where A = body                  # (= (where (call f (:: x A)) A) body)
f()::A where A = body                   # (= (:: (call f) (where A A)) body)
f(::A)::B where A = body                # (= (:: (call f (:: A)) (where B A)) body)
f(::A)::B where B = body                # (= (:: (call f (:: A)) (where B B)) body)
f(::A)::B where {A,B} = body            # (= (:: (call f (:: A)) (where B A B)) body)"><pre class="notranslate"><span class="pl-en">f</span>(x<span class="pl-k">::</span><span class="pl-c1">A</span>) <span class="pl-k">=</span> body                          <span class="pl-c"><span class="pl-c">#</span> (= (call f (:: x A)) body)</span>
<span class="pl-en">f</span>(x<span class="pl-k">::</span><span class="pl-c1">A</span>, y<span class="pl-k">::</span><span class="pl-c1">B</span>) <span class="pl-k">=</span> body                    <span class="pl-c"><span class="pl-c">#</span> (= (call f (:: x A) (:: y B)) body)</span>

<span class="pl-en">f</span>(<span class="pl-k">::</span><span class="pl-c1">A</span>) <span class="pl-k">=</span> body                           <span class="pl-c"><span class="pl-c">#</span> (= (call f (:: A)) body)</span>
<span class="pl-en">f</span>()<span class="pl-k">::</span><span class="pl-c1">A</span> <span class="pl-k">=</span> body                           <span class="pl-c"><span class="pl-c">#</span> (= (:: (call f) A) body)</span>
<span class="pl-en">f</span>(<span class="pl-k">::</span><span class="pl-c1">A</span>)<span class="pl-k">::</span><span class="pl-c1">B</span> <span class="pl-k">=</span> body                        <span class="pl-c"><span class="pl-c">#</span> (= (:: (call f (:: A)) B) body)</span>

<span class="pl-en">f</span>(x<span class="pl-k">::</span><span class="pl-c1">A</span>) <span class="pl-k">where</span> A <span class="pl-k">=</span> body                  <span class="pl-c"><span class="pl-c">#</span> (= (where (call f (:: x A)) A) body)</span>
<span class="pl-en">f</span>()<span class="pl-k">::</span><span class="pl-c1">A</span> <span class="pl-k">where</span> A <span class="pl-k">=</span> body                   <span class="pl-c"><span class="pl-c">#</span> (= (:: (call f) (where A A)) body)</span>
<span class="pl-en">f</span>(<span class="pl-k">::</span><span class="pl-c1">A</span>)<span class="pl-k">::</span><span class="pl-c1">B</span> <span class="pl-k">where</span> A <span class="pl-k">=</span> body                <span class="pl-c"><span class="pl-c">#</span> (= (:: (call f (:: A)) (where B A)) body)</span>
<span class="pl-en">f</span>(<span class="pl-k">::</span><span class="pl-c1">A</span>)<span class="pl-k">::</span><span class="pl-c1">B</span> <span class="pl-k">where</span> B <span class="pl-k">=</span> body                <span class="pl-c"><span class="pl-c">#</span> (= (:: (call f (:: A)) (where B B)) body)</span>
<span class="pl-en">f</span>(<span class="pl-k">::</span><span class="pl-c1">A</span>)<span class="pl-k">::</span><span class="pl-c1">B</span> <span class="pl-k">where</span> {A,B} <span class="pl-k">=</span> body            <span class="pl-c"><span class="pl-c">#</span> (= (:: (call f (:: A)) (where B A B)) body)</span></pre></div>
<p dir="auto">As soon as we add a return type and a where clause, the return type predates the where clause.<br>
Statistically, it seems that the where clause can concern either input type, io type more frequently  that only output type.</p>
<p dir="auto">If we want to obtain a where clause on the whole sig, we have to parenthesis things</p>
<div class="highlight highlight-source-julia notranslate position-relative overflow-auto" dir="auto" data-snippet-clipboard-copy-content="(f()::A) where A = body                 # (= (where (:: (call f) A) A) body)
(f(::A)::B) where B = body              # (= (where (:: (call f (:: A)) B) B) body)
(f(::A)::B) where {A,B} = body          # (= (where (:: (call f (:: A)) B) A B) body)"><pre class="notranslate">(<span class="pl-en">f</span>()<span class="pl-k">::</span><span class="pl-c1">A</span>) <span class="pl-k">where</span> A <span class="pl-k">=</span> body                 <span class="pl-c"><span class="pl-c">#</span> (= (where (:: (call f) A) A) body)</span>
(<span class="pl-en">f</span>(<span class="pl-k">::</span><span class="pl-c1">A</span>)<span class="pl-k">::</span><span class="pl-c1">B</span>) <span class="pl-k">where</span> B <span class="pl-k">=</span> body              <span class="pl-c"><span class="pl-c">#</span> (= (where (:: (call f (:: A)) B) B) body)</span>
(<span class="pl-en">f</span>(<span class="pl-k">::</span><span class="pl-c1">A</span>)<span class="pl-k">::</span><span class="pl-c1">B</span>) <span class="pl-k">where</span> {A,B} <span class="pl-k">=</span> body          <span class="pl-c"><span class="pl-c">#</span> (= (where (:: (call f (:: A)) B) A B) body)</span></pre></div>
<p dir="auto">Harder to read and understand.</p>
<p dir="auto">Also notice that it does not follow the default for the long form function</p>
<div class="highlight highlight-source-julia notranslate position-relative overflow-auto" dir="auto" data-snippet-clipboard-copy-content="# long form, where above call by default
function f(::A)::B where {A,B}; body end    # (function (where (:: (call f (:: A)) B) A B) body)

# short form, where above call if parenthesised otherwise under
(f(::A)::B) where {A,B} = body              # (= (where (:: (call f (:: A)) B) A B) body)
f(::A)::B where {A,B} = body                # (= (:: (call f (:: A)) (where B A B)) body)"><pre class="notranslate"><span class="pl-c"><span class="pl-c">#</span> long form, where above call by default</span>
<span class="pl-k">function</span> <span class="pl-en">f</span>(<span class="pl-k">::</span><span class="pl-c1">A</span>)<span class="pl-k">::</span><span class="pl-c1">B</span> <span class="pl-k">where</span> {A,B}; body <span class="pl-k">end</span>    <span class="pl-c"><span class="pl-c">#</span> (function (where (:: (call f (:: A)) B) A B) body)</span>

<span class="pl-c"><span class="pl-c">#</span> short form, where above call if parenthesised otherwise under</span>
(<span class="pl-en">f</span>(<span class="pl-k">::</span><span class="pl-c1">A</span>)<span class="pl-k">::</span><span class="pl-c1">B</span>) <span class="pl-k">where</span> {A,B} <span class="pl-k">=</span> body              <span class="pl-c"><span class="pl-c">#</span> (= (where (:: (call f (:: A)) B) A B) body)</span>
<span class="pl-en">f</span>(<span class="pl-k">::</span><span class="pl-c1">A</span>)<span class="pl-k">::</span><span class="pl-c1">B</span> <span class="pl-k">where</span> {A,B} <span class="pl-k">=</span> body                <span class="pl-c"><span class="pl-c">#</span> (= (:: (call f (:: A)) (where B A B)) body)</span></pre></div>
<h2 dir="auto">Proposal</h2>
<p dir="auto">let's the where clause being bound to the whole sig by default when both return type and where clause are present.</p>
<p dir="auto">In other words, <code class="notranslate">::ReturnType</code> is incompatible with <code class="notranslate">where</code> clauses in the short function form declarations.<br>
I thought an exemple was more clear than my words in the title.</p>