Javascript: o que significa esta sintaxe (0,functionName)(functionParemeter);

Eu estava explorando o arquivo JavaScript a partir da fonte de http://www.google.com, na verdade eu faço isso frequentemente e tento entender o que eles fizeram lá. Hoje eu estava olhando dentro dos arquivos e encontrei algumas chamadas de função estranhas. Talvez seja uma coisa boba, mas eu realmente não tenho ideia do que é e, por isso, não pude deixar de pesquisar sobre isso.

uma semelhança legível do código-

var someFunction = function(somaeParamenter){
    //do some stuffs;
    return something;
}

var someOtherThing = (0, someFunction)(oneParameter);

Por favor, desculpe minha falta de conhecimento.

EDITAR:

Fonte-

Estou usando o Chrome. Enquanto estava na página http://www.google.com aberta, abri a ferramenta de desenvolvedor. Então, abri a aba Fontes e abri o arquivo https://www.google.com.bd/xjs/_/js/s/c,sb,cr,cdos,vm,tbui,mb,wobnm,cfm,abd,bihu,kp,lu,m,tnv,amcl,erh,hv,lc,ob,r,rsn,sf,sfa,shb,srl,tbpr,hsm,j,p,pcc,csi/rt=j/ver=WUW4ydIf-wI.en_US./am=gA/d=1/sv=1/rs=AItRSTPu52CumknQsh0was81vrM4inla_w no visualizador. Este é o único arquivo js que vi lá. Ativei a opção "formatação" (pretty print) e na linha 58 você encontrará a definição-

_.Va = function(a) {
            var b = typeof a;
            if ("object" == b)
                if (a) {
                    if (a instanceof window.Array)
                        return "array";
                    if (a instanceof window.Object)
                        return b;
                    var c = window.Object.prototype.toString.call(a);
                    if ("[object Window]" == c)
                        return "object";
                    if ("[object Array]" == c || "number" == typeof a.length && "undefined" != typeof a.splice && "undefined" != typeof a.propertyIsEnumerable && !a.propertyIsEnumerable("splice"))
                        return "array";
                    if ("[object Function]" == c || "undefined" != typeof a.call && "undefined" != typeof a.propertyIsEnumerable && !a.propertyIsEnumerable("call"))
                        return "function"
                } else
                    return "null";
            else if ("function" == b && "undefined" == typeof a.call)
                return "object";
            return b
        };

e na linha 83 você verá que a função é chamada.

_.Za = function(a) {
            return "array" == (0, _.Va)(a)
        };

Resposta #1

(0, someFunction)

simplesmente retorna someFunction

então isso é apenas equivalente a

var someOtherThing = someFunction(oneParameter);

Você tem certeza de que digitou exatamente como estava? Se sim, e se não foi algum tipo de ofuscação, então pode ser o resultado infeliz de alguma minificação. Se o código real fosse um pouco diferente, por exemplo (0, someObject.someFunction), poderia haver algum uso dessa chamada de função indireta.

EDITAR :

Sua edição confirma que o objetivo provavelmente era garantir que this, dentro da função, seja o objeto global (window em um navegador) e não o objeto no qual Va foi anexado (_).