quinta-feira, 23 de dezembro de 2010

Magik básico

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!")

 

External links

Fonte: http://uk.ask.com/wiki/Magik_(programming_language)

Nenhum comentário :

Postar um comentário

Related Posts Plugin for WordPress, Blogger...