LP 05/09/2011

   # # # # # # # # # # # # # #
  # Linguagens de Programação #
  # Prof. Fernando Pereira    #
  # notasdogarcia.blog.com    #
   # # # # # # # # # # # # # #

Vantagens de tipagem estatica:
 - Melhor documentação do código pois ele fica mais legível.
 - Existem programas de verificação que podem evitar que um código entre em estado de erro que só são possíveis graças à tipagem estática.

Vantagens/Desvantagens de tipagem dinâmica:
 - Permite decisões de última hora.
 - Permite retirar um pouco do peso das decisões do ombro do programador, já que boa parte delas é realizada de última hora, o próprio compilador cuida delas.
   ( ou seja, no geral o programador escreve menos, pois tem menos detalhes pra se preocupar )
 - A decisão dos tipos se realizada durante a execução pode tornar a execução mais lenta, já que é uma operação de peso não desprezivel.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Em SML se dois tipos tem as mesmas características eles são usados como um único tipo,
Coisa que não se faz em C ou Java por exemplo que diferenciam os tipos simplesmente pelo nome.

Nota em SML para se definir um tipo que representa uma tupla de int`s se faz:

val U = int * int

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

CONCEITO:
Polimorfismo é essa caracteristica de se poder alterar um tipo de última hora, tranformar tipos e adaptar funções para aceitar outros tipos, etc.

CATEGORIZAÇÃO:
Polimorfirmo pode se dividir em 2 grupos:

 - Ad-hoc, que tem como característica ter um conjunto finito de tipos.
 - Universal, que tem como características ter um conjunto de tipos infinito.
// Provavelmente haveria mais a ser dito sobre esses 2 sub-grupos, mas o professor não citou em sala,
// Voces devem ser capazes de encontrar mais detalhes no livro.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

   O sub-conjunto "Ad-hoc" se sub-divide em mais dois grupos:

     - Coerção
       Coerção é quando voce faz uma soma do tipo: 1+1.0 e o C entende que 1 é para ser tratado como um float gerando assim uma operação de dois floats.
       Para esse tipo de polimorfismo é necessário uma tabela de conversões que indica o que é possível de ser feito, e essa tabela existe dentro do compilador.

     - Sobrecarga
       Um exemplo é a sobrecarga da operação de soma, onde um mesmo simbolo ("+") pode realizar tipos diferentes de somas, ex: 2+2 é diferente de 2.0+1.0
       Assim pode-se dizer que o simbolo + representa não uma mas duas operações no mesmo contexto, estando portanto sobrecarregado.
       Isso também se aplica a funções quando voce pode descrever uma função mais de uma vez alterando apenas os parâmetros dela, para casos diferentes.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

   O sub-conjunto do "Universal" se subdivide em mais 2:

     - Parametrico
       É um polimorfismo onde uma função vem preparada para se adaptar aos tipos dos parâmetros, sejam eles quais forem.
       Assim desde que o tipo recebido seja capaz de realizar as operações da função, (por exemplo soma, ou multiplicação, ou união, ou o que for necessário)
       A função se adapta para realizar estas operações corretamente.

     - Sub-tipagem
       Se um tipo possui sub-tipos, ou seja existem outros tipos que possuem as mesmas características que ela (pense nos filhos de uma classe de C++)
       então uma função é capaz de receber esses filhos, mesmo tendo sido preparada para receber o pai.

       Ex: Em C++ voce pode usar um ponteiro para um filho de uma classe em uma função preparada para receber o pai, e ela funcionará corretamente.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Nota sobre C++:

class batata
{
  int feijoada=10;
  public:
  batata operator+(int a){ this->feijoada+=a; return (*this); }
}

Essa declaração realizada dentro de uma classe é convertida pelo compilador para ser usada no lugar de somas.
Ou seja em uma soma do tipo:
batata A;
A = A + 12;

É convertida para:
A = A.operator+(12);

Pelo compilador.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Construtores de tipos em SML:
Existem 3 notações usada pelo construtor de tipos:

- "*" que gera uma tupla.
- "list" que descreve uma lista.
- "->" que descreve uma função.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Outra nota sobre C++:

Uso de Templates:

// Declare um template assim:
template <class T>

// Quando em uma função voce utilizar esse template como abaixo:
T getMax (T a, T b)
{
  return (a>b? a : b);
}
// Essa função fica "incompleta" esperando que seja decida na chamada da função qual o tipo do template T.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Assim voce definiu um molde para a funçào getMax, onde class T está função da chamada do template.
  Então se eu desejar fazer essa chamada para um inteiro eu informo isso assim:

    getMax<int>(5,6)

  para um float:

    getMax<float>(5.1,7.4)

  Assim quando a compilação se iniciar, o compilador cria várias copias de getMax uma para cada tipo diferente usado no programa.

// Bem fim da aula =].