Final presentation of proposal language

INTRODUÇ ÃO LINGUAGEM IMPERATIVA LINGUAGEM FUNCIONAL LINGUAGEM L ÓGICA
Projeto de especificação da linguagem C+-
Caio Santos, Gabriel Valsiljevic, Jean Silva, Victor Henrique
Universidade Federal do Rio Grande do Norte
Centro de Ciências Exatas e da Terra
Departamento de Informática e Matemática Aplicada
4 de junho de 2013
1/40

CONTE ÚDO
INTRODUÇ ÃO
LINGUAGEM IMPERATIVA
Dom´ınio de Aplicação
Principais caracter´ısticas
Sistema de Tipos
Tipos Primitivos
Designadores dos tipos primitivos
Tipos compostos
Expressões da Linguagem
Entrada e Sa´ıda
Estruturas de Controle
LINGUAGEM FUNCIONAL
Diferenças marcantes do paradigma imperativo
Sistema de Tipos
Expressões da Linguagem
Escopo e Tempo de Vida
Arrays
Estruturas de controle
LINGUAGEM L ÓGICA
Diferenças marcantes do paradigma imperativo
Tipos
Escopo
Operadores e expressões
Armazenamento de valores
Arrays
Estruturas de controle
2/40

DOMÍNIO DE APLICAÇ ÃO
Linguagem baseada em C e FORTRAN
Dom´ınio de aplicação cient´ıfico
Estruturas de dados simples
Manipulação de grandes quantidades de dados
Alta precisão
Publico alvo
Matemáticos e cientistas
3/40

PRINCIPAIS CARACTERÍSTICAS
Legibilidade
Pequeno número de componentes básicos (simplicidade
global)
Nomes (designadores) dos tipos primitivos refletem bem
suas finalidades. Ex.: int ≡ inteiro
É case sensitve
Confiabilidade
É fortemente tipada
Oferece mecanismos de tratamento de exceç ões
Capacidade de escrita
É pouca ortogonal
Sistema de implementação: compilada
Usa compilação separada
4/40

SISTEMA DE TIPOS
A linguagem ´e fortemente tipada
Compatibilidade entre tipos
Compatibilidade de nomes e estruturas ser˜ao usados
5/40

TIPOS PRIMITIVOS
Tabela: Designadores dos tipos primitivos da linguagem
Nome Descri¸cão Tamanho Faixa
char Caractere 1byte −128 a 127 e unsigned: 0 a 255
short Inteiro curto 2bytes −32768 a 32767 e unsigned: 0 à 65535
int Inteiro 4bytes −2147483648 a 2147483647 e unsigned: 0
à 4294967295
long Inteiro longo 8bytes −263 à 263 − 1 e unsigned: 0 à 264 − 1
bigInt Inteiro muito longo 16bytes −2127 à 2127 − 1 e unsigned: 0 à 2128 − 1
bool Valor booleano. 1byte true ou false
float Pronto flutuante 4bytes ±3.4e ± 38
double Precisão dupla do
ponto flutuante
8bytes ±1.7e ± 308
complex Números comple-
xos
8bytes −264 à 264 − 1
6/40

TIPOS COMPOSTOS
Conjunto (Set)
1 import utility.set;
2 ...
3 set <int> A;
4 set < set <int> > B;
5 B.add(A);
6 /**
7 * $B supset A$
8 */
7/40

TIPOS COMPOSTOS
Conjunto (Set)
1 import utility.set;
2 ...
3 set <int> A;
4 set < set <int> > B;
5 B.add(A);
6 /**
7 * $B supset A$
8 */
Lista (List)
1 import utility.list;
2 ...
3 list <int> a;
4 list < list <int> > b;
7/40

TIPOS COMPOSTOS
Pilha (Stack)
1 import utility.stack
2 ...
3 stack <int> mystack;
4 mystack.push(5);
5 mystack.push(4);
6 mystack.push(3);
7 mystack.pop();
8 write("%dn", mystack.top());
8/40

TIPOS COMPOSTOS
Pilha (Stack)
1 import utility.stack
2 ...
3 stack <int> mystack;
4 mystack.push(5);
5 mystack.push(4);
6 mystack.push(3);
7 mystack.pop();
8 write("%dn", mystack.top());
Fila (Queue)
1 import utility.queque;
2 ...
3 queue f<int> myqueue;
4 myqueue.push_back(8);
5 myqueue.push_back(7);
6 write("front: %d; back: %dn", myqueue.front(), myqueue.back());
7 myqueue.pop_front();
8/40

TIPOS COMPOSTOS
Vetor
1 int v[10];
2 int vet[3] = {1, 2, 3};
3 int mat[2][2] = {1, 0;
4 0, 1};
9/40

TIPOS COMPOSTOS
Vetor
1 int v[10];
2 int vet[3] = {1, 2, 3};
3 int mat[2][2] = {1, 0;
4 0, 1};
O usuário pode desejar definir seus próprios tipos
1 struct ListaT {
2 int info;
3 ListaT * prox;
4 };
5 ...
9/40

EXPRESS ÕES DA LINGUAGEM
Operador Descrição
Operadores Aritiméticos
+ adição
- subtração
* multiplicação
/ divisão
% mod ou resto de divisão
Incremento e Decremento
++ incremento
– decremento
Operadores Relacionais
== Igualdade
!= Diferença
>, < maior que, e menor que
>=, <= maior igual, e menor igual
10/40

Operador Descrição
Operadores Lógicos
! NOT
&& AND
|| OR
Operadores bit-a-bit
& AND
| OR
ˆ XOR
˜ NOT
11/40

TIPOS DEFINIDOS PELO USU ÁRIO
Definição
1 template <typedef struct T>
2 typedef struct Par {
3 T a, b;
4 };
5
6 template <typedef struct T>
7 function getMax (Par <T> p ) : T {
8 return p.a > p.b ? p.a : p.b;
9 }
Uso
1 Par <double> p;
2 p.a = 5.5, p.b = 5.4;
3 write("%lf", getMax(p));
12/40

ENTRADA E SA´IDA
1 import io;
2
3 function main(): int {
4 int a, b;
5 read("%i %i", &a, &b);
6 int soma = a + b;
7 write("%in", soma);
8 return 0;
9 }
13/40

ESTRUTURAS DE CONTROLE
CONDICIONAL: COMANDO IF
1 import io;
2
4 int n;
5 read("%d", &n);
6 if (n > 0) {
7 write("%d eh um numero positivon", n);
8 } else if(n < 0){
9 write("%d eh um numero negativon", n);
10 } else {
11 write("%d eh zeron", n);
12 }
13 return 0;
14 }
14/40

CONDICIONAL: COMANDO SWITCH-CASE
1 import io;
2
4 string op;
5 read("%s", &op);
6 switch(op) {
7 case "um":
8 write("1n");
9 break;
10 case "dois":
11 write("2n");
12 break;
13 case "tres":
14 write("3n");
15 break;
16 default:
17 write("qwertyn");
18 break;
19 }
20 return 0;
21 }
15/40

REPETIC¸ ˜AO: COMANDO FOR
1 import io;
2
4 int n;
5 read("%d", &n);
6 for (int i = 0; i < n; i++) {
7 write("%d ", 2 * (i + 1));
8 }
9 write("n");
10 return 0;
11 }
16/40

REPETIC¸ ˜AO: COMANDO FOR-EACH
1 import io;
2 import utility.list;
3
5 list <int> lst;
6 lst.add(0);
7 lst.add(2);
8 lst.add(3);
9 lst.add(4);
10
11 foreach (int a : lst) {
12 write("%d ", a);
13 }
14 write("n");
15 return 0;
16 }
17/40

REPETIC¸ ˜AO: COMANDO WHILE
1 import io;
2
4 int n;
5 read("%d", &n);
6 int i = 0;
7 while(i < n) {
8 ++i;
9 write("%d ", 2 * i);
10 }
11 write("n");
12 return 0;
13 }
18/40

REPETIC¸ ˜AO: COMANDO DO-WHILE
1 import io;
2
4 int i = 5;
5 do {
6 write("%d ", i);
7 i--;
8 } while (i != 0);
9 write("n");
10 return 0;
11 }
19/40

TRATAMENTO DE EXCEC¸ ˜OES
1 procedure g() {
2 int x;
3 write("Digite um numero positivo: n");
4 try {
5 read(x);
6 if(x < 0){
7 throw x;
8 }
9 } catch(int erro) {
10 write("Erro! numero negativo: %i n", erro);
11 }
12 }
20/40

SUBPROGRAMAS
1 function fib(int n): int {
2 if (n == 0 || n == 1) return n;
3 else
4 return fib(n - 1) + fib(n - 2);
5 }
1 procedure printTest() {
2 write("Opa...aprendi C+-!");
3 }
21/40

LINGUAGEM FUNCIONAL
DIFERENÇ AS MARCANTES DO PARADIGMA IMPERATIVO
Linguagems de programação funcional tratam
computaçoes como avaliaç ões matemáticas.
Não usa variáveis ou instruç ões de atribuição.
Programas são definiç ões e aplicaç ões de funç ões.
Simplificação da semântica.
22/40

SISTEMA DE TIPOS
Praticamente todos os tipos primitivos permanecer˜ao.
Os tipos compotos ser˜ao representados pela tupla.
23/40

Os operadores aritméticos permanecem da mesma forma.
O incremento e decremento serão definidos como funç ões
primitivas.
1 (int, float, string)
24/40

ESCOPO E TEMPO DE VIDA
Comportamento de funç ões matemáticas.
Escopo das variáveis é estático.
Seu resultado não deve ser afetado pelo contexto em que a
função foi chamada.
25/40

ARRAYS
Arrays foram substituidos por Listas.
Avaliação preguiçosa, evita cálculos desnecessários e
permite construir estruturas infinitas.
26/40

As estruturas condicionais se resumem em uma mescla do
comportamento do switch-case com a avaliação de
condiç ões de guarda do if.
Estruturas de repetição interativas deixaram de existir.
Alteradores de fluxo (jumps e escapes) também serão
eliminados.
27/40

1 //Exemplo Imperativo
2 function ehPrimo(int n) : bool {
3 int i=2;
4 while(i*i){
5 if(i%n==0) return false;
6 i++;
7 }
8 return true;
9 }
10
11 //Exemplo Funcional
12 function ehPrimo n : int -> bool
13 ehPrimoAux(2,n)
14
15 function ehPrimoAux i, n : int, int
16 {i*i>n, true}
17 {i%n == 0, false}
18 ehPrimoAux i+1, n
28/40

LINGUAGEM L ÓGICA
DIFERENÇ AS MARCANTES DO PARADIGMA IMPERATIVO
Trabalha com regras e fatos
Variáveis não são blocos de memória
O programador se preocupa em descrever o problema, e
não sua solução
Utiliza backtracking para tentar unificar as variáveis
29/40

TIPOS PRIMITIVOS
Não haverá ponteiros
Não existirão blocos de memória vis´ıveis ao programador
unsigned e string serão substitu´ıdos por symbol
30/40

TIPOS COMPOSTOS
Usuários poderão definir predicados compostos
Exemplo:
#predicado simples
gosta(gabriel, lpcp).
#predicado composto
gosta(gabriel, disciplina(lpcp)).
31/40

ESCOPO
Fatos são vis´ıveis globalmente
Variáveis são vis´ıveis apenas dentro da regra onde estão
instanciadas
32/40

OPERADORES E EXPRESS ÕES
Operadores aritméticos e lógicos permanecem inalterados
Exceção: operador ‘=’ é utilizado para unificação, apenas
Utiliza-se ‘is’ para atribuição
Exemplo:
tenta_unificar(X,Y) :- X = Y.
atribuir(X, Y) :- X is Y + 3.
33/40

ARMAZENAMENTO DE VALORES
Fatos são armazenados em modelo estático
Variáveis são armazenadas em modelo dinâmico em pilha
Devido ao seu uso no backtracking, cujo comportamento é
recursivo
34/40

ARRAYS
Deﬁnidos como listas ligadas
Representadas como [H|T]
H ´e o primeiro elemento da lista e T seu restante (e.g.:
[1, 2, 3] seria [1|[2, 3]])
Exemplos:
somatorio([], 0).
somatorio([H|T], X) :- somatorio(T, Y), X is H + Y.
35/40

Não existirão estruturas de controle e fluxo como if-else e
while
Para utilizar estes recursos, deve-se utilizar métodos
lógicos e recursão
Comando “!” (cut) utilizado para interromper o processo
de resolução e impedir laços infinitos
36/40

EXEMPLO DE PROGRAMA
#numero de elementos de uma lista
num_elements([], 0).
num_elements([_|T], X) :- num_elements(T, Y), X is 1 + Y.
37/40

EXEMPLO DE PROGRAMA
# alguns fatos
progenitor(joao, mario).
progenitor(helena, carlos).
progenitor(mario, carlos).
sexo(jose, ’masculino’).
sexo(joao, ’masculino’).
sexo(maria, ’feminino’).
sexo(ana, ’feminino’).
38/40

EXEMPLO DE PROGRAMA
# diversas relacoes de parentesco
irma(X, Y) :- sexo(X, ’feminino’), progenitor(Z, X), progenitor(Z, Y).
irmao(X, Y) :- sexo(X, ’masculino’), progenitor(Z, X),progenitor(Z, Y)
mae(X, Y) :- sexo(X, ’feminino’), progenitor(X, Y).
pai(X, Y) :- sexo(X, ’masculino’), progenitor(X, Y).
avo(X, Y) :- sexo(X, ’masculino’), progenitor(X, Z), progenitor(Z, Y).
tio(X, Y) :- irmao(X, Z), progenitor(Z, Y).
descendente(X, Y) :- progenitor(Y, X).
descendente(X, Y) :- progenitor(Y, Z), descendente(X, Z).
39/40

FIM
D´uvidas?
40/40

Final presentation of proposal language

Mais conteúdo relacionado

Mais procurados (20)

Destaque (20)

Semelhante a Final presentation of proposal language (20)

Final presentation of proposal language