Histórico da Página

Qual a forma básica de dar tipos aos parâmetros?

Function name (parm1 as type1, parm2 as type2, ..., parmN as typeN)

Visite os Tipos Nativos.

Function typedFunc(parm1 as Numeric, parm2 as Character) as Variant

Quais são as checagens feitas em relação aos parâmetros?
Existem dois momentos em que a consistência dos parâmetros é checada:

1. Em tempo de compilação
   1. Estando a função ou método no mesmo fonte, o compilador observa se a quantidade de argumentos passados é coerente;
   2. Se os tipos dos argumentos passados são compatíveis com os tipos declarados.
      
      
2. Em tempo de execução
   1. Realiza os mesmos tratamentos de tempo de compilação, mas com potencial de olhar também funções ou métodos que foram definidos em outros fontes.

Function typedFunc(nVar as Numeric, cVar as Character) as NumericLogical
Local nVar := 10 as Numeric
Return nVar

Function typedFunc() as Numeric
Local cVar := "I Love TLPP"
Return cVar  // ERRO DE COMPILAÇÃO (Função Numeric tentando retornar um Character)

 lVar as Logical
lVar := IIF(cVar == "TLPP", .T., .F.) as LogicallVar   := lVar .AND. (nVar == 1)
Return lVar
Function Test()Local lVar as Logical
lVar := typedFunc(2, "TLPP")  // Compilação OK
lVar := typedFunc("TLPP", 2)  // Erro de Compilação (deveria ser Numeric e depois Character)
lVar := typedFunc(1)              // Erro de Compilação (poucos argumentos passados)
Return .T.

Agora considere uma função f2, que tenha sido declarada em um fonte diferente daquele onde a Function Test foi desenvolvida.
Admita ainda que a function f2 tenha a seguinte linha declarativa:

Function f2(nVar as Date)

Neste caso, o exemplo seguinte daria erro à chamada a f2 em tempo de execução, fazendo-se valer da tipagem dos parâmetros.
É importante frisar que esse erro acontece logo na chamada da função, de modo que ela sequer chega a ser de fato executada.
Isso é bem legal e pode antecipar problemas que só viriam à tona em um nível mais profundo da stack de execuçãoE o compilador também vai olhar as chamadas de funções?
Sim, o compilador também vai ficar atento a isso. No atual estágio, se a função chamada estiver no mesmo fonte, poderemos checar eventuais inconsistências de tipos.

Function typedFuncTest() as Numeric
Local nVardVar := 10 as Numeric
Return nVar
Function typedTestdate() as LogicalDate
Local cVar := "I Love TLPP" as Character
Local cResult as Character
cResult := cVar + typedFunc() // ERRO DE COMPILAÇÃO (typedFunc é Numeric e, portanto, não pode ser somada a cVar, que é Characterdtos(dVar)
f2(dVar) // Ok, sem problemasf2(cVar)    //  Valendo-se da tipagem, dará erro em tempo de execução.
Return .T.