Magik é uma linguagem de programação orientada a objetos que suporta herança múltipla, polimorfismo e tipos de dados dinâmicos. GE Energy o proporciona como parte da plataforma Smallworld e, a princípio, foi desenhado para implementar aplicações complexas para empresas como telecomunicações.
Magik foi criado originalmente em 1990, e através dos anos foi melhorado e atualizado.
Semelhanças com Smalltalk
Magik tem algumas semelhanças com Smalltalk em termos de características da linguagem e arquitetura: a linguagem Magik compila-se em bytecode que é interpretado pela Máquina virtual do Magik. A máquina virtual do Magik está disponível em várias plataformas, entre elas Microsoft Windows, várias versões de Unix e Linux.
Magik está baseado em console, e o código pode ser alterado em tempo de execução. O console pode ser utilizada tanto para executar código Magik como para ver os resultados.
O código compilado é salvo em um único arquivo chamado “arquivo imagem”. Cada “arquivo imagem” contém o bytecode completo e o estado da sessão (por exemplo valores de variáveis) do momento do último guardado da imagem.
Características da linguagem
Comentários
Magik usa o # para marcar seções de código como comentário:
# Isto é um comentário.
Atribuições
Magik usa o operador << para fazer atribuições:
a << 1.234
b << b + a
c << “foo” + “bar” # Concatenando strings
Esta anotação lê-se como "a recebe 1.234" ou "b recebe b+a". Isto serve para diferenciar corretamente atribuição de comparação.
Magik suporta também uma variação comprimida do operador que funciona de forma similar aos que podemos encontrar em C:
b +<< a # Equivalente a b << b + a Símbolos.
Bem como os tipos de dados convencionais como inteiros, números em ponto flutuante e strings, Magik também implementa símbolos. Os símbolos são um tipo de dado especial que são usados extensamente em Magik para identificar de forma única os objetos. Representa-se mediante dois pontos ":" seguidos de uma string de caracteres. Os símbolos podem se concatenarr mediante a barra vertical "|". Por exemplo:
a << :hello # Quando se encontra :hello referir-se-á à mesma instância
b << :|hello world|
Tipos dinâmicos
As variáveis de Magik não têm tipos fixados como em C# e podem referir diferentes objetos na execução. Qualquer coisa em Magik é um objeto (Não há distinção entre objetos e tipos de dados primitivos como os inteiros):
a << 1.2 # um número em ponto flutuante atribuído à variável 'a'
a << “1.2” # mais tarde atribui uma string à variável 'a'
Objetos
Os objetos são implementados em Magik usando instâncias. As instâncias são parecidas às classes de outras linguagens de programação como Java, mas com importantes diferenças. Magik suporta herança múltipla e misturas. As novas instâncias criam-se clonando uma já existente (que tipicamente é a instância, mas não tem o porquê de ser).
As novas instâncias criam-se com a sentença def_slotted_exemplar(), por exemplo:
def_slotted_exemplar(:my_object,
{
{:slot_a, 34},
{:slot_b, "hello"}
}, {:parent_object_a, :parent_object_b})
Este fragmento de código define uma instância chamada my_object que tem dois parâmeros (ou campos) chamados slot_a (pré-inicializado com o valor 34) e slot_b (pré-inicializado com o valor "hello") que herda de duas instâncias já existentes chamados parent_object_a e parent_object_b.
Comparação
Magik implementa todos os operadores binários tipicamente usados (=, <, <=, >, >=, =/<>) para a comparação, bem como alguns mais incomuns. Os operadores _is e _isnt usam-se para comparar instâncias específicas de objetos, ou referências de objetos em lugar de valores.
Por exemplo:
a << "hello"
b << "hello"
a = b retorna True (_true) porque os valores da e b são iguais
a _is b retorna False (_false) porque a e b não são a mesma instância
a << "hello"
b << a = b retorna True (_true) porque os valores da e b são iguais
a _is b retorna True (_true) porque b se atribui a uma instância específica do mesmo objeto que a, em lugar do mesmo valor que a.
Métodos
Os métodos definem-se nas instâncias usando as sentenças _method e _endmethod:
_method my_object.my_method(a, b)
_return a + b
_endmethod
Esta é uma forma de substituir os métodos new() (para criar novas instâncias) e init() (para inicializar uma instância).
# Método New
_method person.new(name, age)
_return _clone.init(name, age)
_endmethod
# Método Initialize
_private _method person.init(name, age)
# Chama a implementação do pai.
_super.init(name, age)
# Inicializa os campos.
.name << name
.age << age
_return _self
_endmethod
O _clone cria uma cópia física do objeto person. A sentença _super permite aos objetos invocar uma implementação de um método em uma instância pai. Os objetos podem referir-se a si mesmos usando a sentença _self.
Os métodos que não são parte da interface pública de um objeto podem ser marcados como privados usando a sentença _private. Os métodos privados só podem ser chamados por _self , _super e _clone.
Há argumentos opcionais que se podem declarar com a sentença _optional. Os argumentos opcionais que não são passados são atribuídos pelo Magik a um objeto especial _unset (o equivalente a NULL). A sentença _gather pode-se usar para declarar uma lista de argumentos opcionais.
_method my_object.my_method(_gather values)
_endmethod
Iteração
Em Magik as sentenças _for, _over, _loop e _endloop permitem iterar.
_method my_object.my_method(_gather values)
total << 0.0
_for a _over values.elements()
_loop
total +<< a
_endloop
_return total
_endmethod
m << my_object.new()
x << m.my_method(1.0, 2, 3.0, 4) # x = 10.0
Os novos métodos de iteração definem-se usando as sentenças _iter e _loopbody:
_iter _method my_object.even_elements()
_for a _over _self.elements()
_loop
_if a.even? _is _true
_then
_loopbody(a)
_endif
_endloop
_endmethod
Procedimentos
Magik também suporta funções chamadas procedimentos. Os procedimentos são também objetos, declarados com as sentenças _proc e _endproc. Os procedimentos são atribuídos a variáveis que podem ser invocadas:
my_procedure << _proc @my_procedure(a, b, c)
_return a + b + c
_endproc
x << my_procedure(1, 2, 3) # x = 6
Particularidades linguísticas
Já que Magik foi desenvolvido originalmente na Inglaterra, os métodos do núcleo e as livrarias de Smallworld estão esctitas em inglês britânico British English. Por exemplo:
Usa-se "initialise", em vez de "initialize".
Exemplo Hello World
O seguinte fragmento de código é o programa que emite a mensagem "hello world" escrito em Magik:
write ("Hello World!")
Nenhum comentário :
Postar um comentário