That has been my understanding---the goto implementation is not particularly efficient---however, I've also learned that testing frequently reveals errors in the received view.  In this case, it is easy enough to demonstrate a simple implementation in which, for some inputs, the goto statement is no less efficient.  Compare the following three alternative implementation of a case statement:

f1 := proc(a)
local b,k;
    if a in '[a1,a2,a3,a4,a5,a6,a7,a8,a9]' then
        do
            goto(a);
            a1: b := 1; break;
            a2: b := 2; break;
            a3: b := 3; break;
            a4: b := 4; break;
            a5: b := 5; break;
            a6: b := 6; break;
            a7: b := 7; break;
            a8: b := 8; break;
            a9: b := 9; break;
        end do;
    else
        b := 10;
    end if;
    b;
end proc:

f2 := proc(a)
local b;
    if   'a1' = a then b := 1;
    elif 'a2' = a then b := 2;
    elif 'a3' = a then b := 3;
    elif 'a4' = a then b := 4;
    elif 'a5' = a then b := 5;
    elif 'a6' = a then b := 6;
    elif 'a7' = a then b := 7;
    elif 'a8' = a then b := 8;
    elif 'a9' = a then b := 9;
    else b := 10;
    end if;
    b;
end proc:

f3 := proc(a)
local b;
    try
        error sprintf("%a", a);
    catch "a1": b := 1;
    catch "a2": b := 2;
    catch "a3": b := 3;
    catch "a4": b := 4;
    catch "a5": b := 5;
    catch "a6": b := 6;
    catch "a7": b := 7;
    catch "a8": b := 8;
    catch "a9": b := 9;
    catch:      b := 10;
    end try;
    b;
end proc:

Here we measure the time required for each:

n := 4:
for k to 10 do
    k = (time(proc() to 10^n do f1(a||k); end do end proc())
         ,time(proc() to 10^n do f2(a||k); end do end proc())
         ,time(proc() to 10^n do f3(a||k); end do end proc())
         ,time(proc() to 10^n do f4(a||k); end do end proc())
        );
end do;
                           1 = (0.112, 0.052, 0.232)
                           2 = (0.108, 0.060, 0.252)
                           3 = (0.096, 0.068, 0.252)
                           4 = (0.092, 0.088, 0.240)
                           5 = (0.112, 0.080, 0.240)
                           6 = (0.112, 0.084, 0.252)
                           7 = (0.096, 0.104, 0.232)
                           8 = (0.100, 0.112, 0.236)
                           9 = (0.116, 0.104, 0.256)
                          10 = (0.068, 0.124, 0.240)

For inputs that require more than about 7 comparisons, the goto method is equivalent to if/elif.  The try/catch technique was mainly for comparion.

I'm not suggesting that goto should be used---there are reasons other than speed that it might not be a good idea.

I should say that I didn't check the efficiency, but code with goto looks much more clear than with overload. Actually, even if ... elif looks better :)

I wonder why Maple doesn't have a switch? It is a standard recommendation for writing a good (maintainable) code - to use a switch instead of nested ifs.

Alec