PONTIFÍCIA UNIVERSIDADE CATÓLICA DE MINAS GERAIS

Bacharelado em Sistema de Informação

Linguagens de Programação

Miranda

Luiz Henrique Diniz Sousa

Betim – MG

2010
 Luiz Henrique Diniz Sousa

Linguagens de Programação

Miranda

Trabalho apresentado à disciplina de Linguagens

de Programação, do Instituto de Informática da
Pontifícia Universidade Católica de Minas Gerais.

Prof.: Eustáquio S. J. Faria

Betim - MG

2010
2
 MIRANDA

“Uma linguagem potencial no ensino

de programação funcional”

3
 Sumário

Introdução ........................................................................................................ 5
História ............................................................................................................. 6
Paradigma ........................................................................................................ 7
Utilização .......................................................................................................... 8
Sintaxe ............................................................................................................. 9
Especificação ................................................................................................. 11
Implementação ............................................................................................... 12
Ambiente de Desenvolvimento ....................................................................... 13
Exemplos........................................................................................................ 14
Vantagens e Desvantagens ........................................................................... 15
Conclusões ..................................................................................................... 16
Referência ...................................................................................................... 17

4
 Introdução

A linguagem Miranda é uma linguagem de paradigma funcional desenvolvida pelo

Professor David Turner do Laboratório de Computação da Universidade de Kent
Cantbury na Inglaterra. Ela foi elaborada para trabalhar com sistemas baseados em
Unix e hoje é distribuída pela empresa Researcher Software LTD. de onde é uma marca
registrada. Como linguagem funcional os programas, mais usualmente chamados de
scripts, são constituídos por uma coleção de definições de funções e estrutura de
dados, geralmente formados com menos palavras do que em linguagens usuais.
Fatores como polimorfismo, abstração, ser fortemente tipada e ser puramente funcional,
tornam Miranda uma linguagem funcional muito interessante para diversas aplicações.

5
 História
Miranda foi criada para ser uma linguagem funcional mais atraente para o
mercado e para o meio acadêmico, oferecendo conceitos antes não disponíveis em
linguagens funcionais como abstração e polimorfismo. Criada pelo Professor Inglês
David Turner, Miranda é uma evolução das SASL e KCR (também desenvolvidas pelo
Prof. David) usando alguns conceitos de Hope e ML. O projeto de Miranda foi
desenvolvido no laboratório da Universidade de Kent na Inglaterra entre 1985 e 1986,
mas está atualmente sob o domínio da empresa Researcher Software LTD. que se
tornou dona na marca “Miranda”. Miranda pode ser utilizada em uma grande gama de
aplicações, mas suas principais são: prototipação rápida, ensino de linguagens
funcionais, como linguagem de especificação, e pesquisa sobre o paradigma funcional.

6
 Paradigma de programação

Mais usada no meio acadêmico que comercialmente, a programação funcional é

um paradigma que trata a computação como uma avaliação de funções matemáticas e
evita estados ou dados mutáveis. No entanto, mesmo dado seu caráter mais voltado
para estudo, o paradigma funcional possui linguagens relevantes para a indústria, tais
como: Erlang, Mathematica e XSLT. Outras linguagens representantes do paradigma
são Haskell, Lisp e Miranda, abordada nesse documento.

Sendo tratadas como valores de primeira importância, ou seja, podem ser

passadas como parâmetros ou retorno de outras funções, as funções podem ser
manipuladas de formas diversas na programação funcional. Portanto, podemos
entender o paradigma funcional como um mapeamento através de funções de valores
de entrada em valores de saída.

No fim dos anos 50 nasceu a primeira linguagem de programação funcional para

computadores. LISP, criada no MIT – Instituto de Tecnologia de Massachussetts por
John McCarthy, trouxe a maioria das características encontradas nas linguagens de
programação funcionais modernas, apesar de não ser uma linguagem puramente
funcional.

No entanto o cálculo lambda, projetado em 1930 por Alonzo Church e que

oferece uma maneira formal para a descrição de um cálculo de uma determinada
função, é que pode ser considerado a primeira linguagem de programação funcional,
mesmo nunca tendo sido, de fato, pensada para executar em um computador.

Na década de 70 do século passado foram criadas as linguagens Miranda, por

David Turner na Universidade de Kent e ML, pela Universidade de Edimburgo. No final
da década seguinte foi lançada Haskell, para tentar juntar muitas ideias na pesquisa de
programação funcional.

7
 Utilização

Miranda possui aplicações práticas principalmente no que diz respeito à

prototipação rápida, ensinar programação funcional e realizar pesquisas em
programação funcional, bem como uma linguagem de especificação e uma ferramenta
para programação em geral.
Devido ao fato de Miranda não ser uma linguagem muito usada no mercado de
software, há poucas aplicações escritas que possam ser encontradas na web.

8
 Sintaxe

Um programa (ou script, como é geralmente chamado) escrito em Miranda é uma

coleção de equações que definem várias funções e estruturas de dados interessantes à
computação. A ordem em que as equações aparecem não é, em geral, significante. Por
exemplo, não é necessário que a definição de uma entidade apareça antes que a
mesma seja usada. Dúvidas podem ser esclarecidas melhor a partir de um exemplo:

z = sq x / sq y
sq n = n * n
x=a+b
y=a–b
a = 10
b=5

Nota-se, a partir do script acima, que não há declaração dos tipos, bem como
não há ponto e vírgula no fim das definições. A notação para a aplicação de funções é
caracterizada apenas pela justaposição do nome da função e os parâmetros a serem
passados, como ocorre em "sq x" e "sq y", por exemplo, na primeira linha. Na definição
das funções o parâmetro possui apenas um escopo local, sendo usado apenas na
própria definição, como em "sq n = n * n", enquanto que os demais nomes possuem o
script inteiro como escopo.

dias_uteis_da_semana = ["seg", "ter", "qua", "qui", "sex"]

dias_da_semana = dias_uteis_da_semana ++ ["sab", "dom"]

É possível concatenar listas usando o operador "++". Outros operadores úteis

para manipular listas são ":", que coloca um elemento no início da lista, "#", que retorna
o tamanho da lista, "!", que retorna o elemento localizado numa determinada posição da
lista e "--", que retira elementos da lista.

9
Por exemplo:

0:[1, 2, 3] é equivalente a [0, 1, 2, 3]

#dias_da_semana possui o valor 7
dias_da_semana!0 possui o valor "seg"
dias_da_semana!3 possui o valor "qua"
[1, 2, 3, 4, 5] -- [2, 5] é equivalente a [1, 3, 4]

Existe também uma notação usando "..", para listas de elementos em uma
progressão aritmética. Por exemplo, eis as definições de uma função de fatorial e de um
número "resultado", que é a soma de todos os números ímpares entre 0 e 100:

fat n = product [1..n]

resutado = sum [1, 3..100]

Os elementos de uma lista devem ser do mesmo tipo. É escrita entre parênteses,
como no exemplo a seguir:

empregado = ("Francisco", True, False, 42]

Acima foram explanadas as ideias básicas da sintaxe de Miranda. Recursos mais

requintados, tais como criar funções com mais de uma lei de formação são detalhadas
no documento intitulado "An Overview Of Miranda", disponível em http://miranda.org.uk,
página oficial da linguagem de programação Miranda.

10
 Especificação

Segue abaixo uma lista de documentações de Miranda:

1 - Livro que dá uma boa explicação sobre linguagens funcionais e utiliza Miranda como
exemplo:

http://www.amazon.com/Miranda-Functional-Programming-International-
Computer/dp/0201422794/ref=sr_1_1/002-4634342-
4198420?ie=UTF8&s=books&qid=1180378586&sr=1-1

2 - Livro sobre miranda com estilo de tutorial. Livro escrito baseado na experiência de
professores utilizando miranda na universidade:

http://www.amazon.com/Programming-Miranda-Chris-
Clack/dp/013192592X/ref=sr_1_2/002-4634342-
4198420?ie=UTF8&s=books&qid=1180378586&sr=1-2

3 - Livro que constituem procedimentos do 6º Symposium internacional na programação

Funcional e da lógica. http://www.amazon.com/Functional-Logic-Programming-
International-Proceedings/dp/3540442332/ref=sr_1_4/002-4634342-
4198420?ie=UTF8&s=books&qid=1180378586&sr=1-4

4 - Paper de David Turner que dá uma Visão geral de Miranda:

http://www.cs.kent.ac.uk/people/staff/dat/miranda/ieOverview.html

5 - Site oficial da linguagem. Possui bons materiais como papers e livros sobre a
linguagem:

http://www.miranda.org.uk/

11
 Implementação

O compilador de Miranda trabalha em conjunto com um editor (normalmente o vi

ou algum editor configurado pelo usuário). Os scripts são automaticamente
recompilados depois de editados, sendo assim, qualquer erro de sintaxe ou de tipo é
detectado imediatamente. Isto é possível por causa do polimorfismo garantido pelo
sistema da linguagem que permite detectar esses e mais erros em tempo de
compilação. Miranda também pode ser considerada como sendo uma linguagem
interpretada, já que muitas de suas funções são executadas ou avaliadas no mesmo
momento em que o programador entra com comandos ou expressões diretamente
numa shell do UNIX.

12
 Ambiente de Desenvolvimento

Miranda possui um ambiente de desenvolvimento interativo que roda sob UNIX

como um subsistema próprio. Sendo assim é possível invocar programas diretamente
do shell do UNIX. Além de ser interpretado em UNIX/Linux, o Miranda também é
adaptável para as plataformas MacOS X, Windows pelo emulador Cygwin, e Solaris.

Através do terminal o usuário passa as expressões contextualizadas em um

determinado script, por exemplo:

z = sq x / sq y
sq n = n * n
x=a+b
y=a-b
a = 10
b=5

Neste caso o sistema avaliará z no contexto deste script como 9.

13
 Exemplos de Programas
Direto no Console: 3)

reverse “linguagens de programacao” funcao :: Int -> Int

funcao x = x^2
20*20

10^10 4)

[1..100]
divInt a b = if b == 0 then a else div a b
[2,4..100]
resto a b = if b /= 0 then a `mod` b else 0
[1..]
soma x y = (+) x y
Através de Scripts
1) vogal a = if a=='a' || a=='e' || a=='i' || a=='o' ||
a=='u'
z = sq x / sq y then True
sq n = n * n else False
x=a+b
y=a-b
a = 10 5)
b=5
Ao solicitar o valor de “z”, o retorno será “9”
comprimento l=length l
2)
vazia []= True
dias_uteis_da_semana = ["seg", "ter", "qua", vazia _ = False
"qui", "sex"]
primeiro :: [Int] -> Int
dias_da_semana = dias_uteis_da_semana primeiro lista = head lista
++ ["sab", "dom"]
junta :: [Int] -> [Int] -> [Int]
junta lista1 lista2 = lista1 ++ lista2

6)

vezes2 n = n * 2

7)

main = do putStrLn "Hello World"

14
 Vantagens e Desvantagens

Miranda é uma linguagem fortemente tipada, portanto ela possui algumas

vantagens e desvantagens que são consequência imediata disso.
Uma vantagem de uma tipagem forte é que todas as operações e declarações
que possam resultar em erros de tipos, são detectadas. Dessa forma o programador
não corre o risco de observar um comportamento inesperado, causado por erros de
tipagem, durante a execução do programa. Por outro lado, isso prejudica a flexibilidade
da linguagem e transfere para o programador a responsabilidade de declarar os tipos
de maneira coerente. No caso de Miranda, essa flexibilidade não é totalmente
extinguida, pois embora seja uma linguagem de programação fortemente tipada, ela
não exige declarações de tipo explícitas. Se o tipo de uma função não é explicitado na
declaração, o interpretador infere a ela um tipo baseado nos tipos dos seus parâmetros
e na maneira que eles são usados dentro da função.

Por se tratar de uma linguagem funcional Não-Estrita, os argumentos passados a

uma função não são avaliados até que sejam realmente requeridos dentro da chamada
da função. Consequentemente, qualquer parâmetro pode ser passado a uma função e
até que seu conteúdo seja necessário à função, este parâmetro não é avaliado. Essa
característica também é conhecida como "avaliação preguiçosa". Esse método traz
certas vantagens, como ganho de performance, já que cálculos desnecessários não
serão computados, e principalmente a possibilidade de se criar estruturas de dados
infinitas. Um exemplo de uma estrutura de dados infinitas seria uma função que cria
uma lista dos infinitos números de Fibonacci, nesse caso, o cálculo do n-ésimo número
de Fibonacci seria meramente a retirada desse elemento da lista, sendo necessário
para isso a avaliação apenas dos n primeiros números da sequência. No entanto, o
programador precisa usar cuidadosamente essa técnica, pois certos cálculos podem
requerer a avaliação de um número infinito de elementos; como por exemplo, o
tamanho da lista dos números de Fibonacci ou a soma de todos os termos da lista.

15
 Conclusões

A grande aplicação de Miranda atualmente tem sido no aprendizado de

linguagens funcionais. Por ter sido desenvolvida como uma versão comercial de uma
linguagem não-estrita e puramente funcional, o ambiente de desenvolvimento de
Miranda é bastante flexível e fácil de usar. Como ela apresenta algumas características
incomuns em linguagens funcionais (abstração, polimorfismo) e ainda assim mantém as
suas características funcionais, Miranda se torna uma ótima ferramenta acadêmica no
estudo desse tipo de linguagem, assim como uma ótima ferramenta também no meio
comercial.

16
 Referências

TURNER, D. An Overview of Miranda. Disponível em: 31/10/2010

<http://miranda.org.uk/>

The Miranda Programming Language. Disponível em: 31/10/2010

<http://www.engin.umd.umich.edu/CIS/course.des/cis400/miranda/miranda.html>

<http://tryhaskell.org/>. Disponível em: 31/10/2010

<http://www.portugal-a-programar.org/forum/index.php?topic=4614.0>. Disponível
em: 31/10/2010

<http://www.infowester.com/linuxvi.php>. Disponível em: 31/10/2010

17