Introdução
O meu interesse mesmo para a minha próxima linguagem é Red mas, como o desenvolvimento é meio confuso e lento (é só uma constatação e não uma reclamação) e ainda faltam coisas que eu desejo, resolvi olhar uma outra linguagem que passou na minha frente. Ring. Achei que podia me divertir um pouco.
A linguagem
Em primeiro lugar, não faz nada a mais do que a sua ou minha linguagem favorita (com maior ou menor trabalho). O que eu achei interessante:
- Pode gerar programas para CLI, GUI (usa o QT) e WEB com ambiente que facilita o desenvolvimento.
- Gera executáveis. No caso mais simples, nada que um shebag mais chmod +x não resolva mas pode facilitar a distribuição em outros casos. Na realidade é apenas um empacotamento do script e não gera executável nativo.
- Multiplataforma (Windows, Mac, Linux, Android).
- Multiparadigma.
- etc..
Sintaxe
É baseada em diversas linguagens (Lua, Python, Ruby, C, Basic, etc.) e é interpretada. Diversas construções aceitam mais de uma sintaxe, tipo:
for i=1 to 10
put i
next
ou
for i=1 to 10 {
put i
}
A definição de funções também é interessante. Se você não gosta de uma, utilize a outra. Uma função para somar e mostrar o resultado de dois número será chamada como:
soma(2, 4) e retorna 6. Pode ser definida de qualquer uma das seguintes formas:
// tipo 1 (endentada)
def soma a, b
c = a + b
put c
// tipo 2 (end no final)
def soma a, b
c = a + b
put c
end
// tipo 3 (entre chaves)
def soma a, b {
c = a + b
put c
}
// tipo 4 (inline?)
def soma a,b c =a + b put c
Obs.: Você poderá trocar def por func que tudo funcionará da mesma forma. Mas existem algumas regrinhas para a utilização.
Variáveis
Existem variáveis globais e locais e o conceito é extendido para os objetos (globais dentro do objeto e locais dentro dos métodos). Tipagem dinâmica e fraca.
As variáveis apontam para um valor e não referência, mesmo objetos e listas. Sendo assim, se a variável a contém uma lista e você usar a expressão b = a, b continuará com o valor inicial mesmo que você altere a.
Dados
Existem diversas funções para a verificação do tipo de dado (isstring(), isnumber(), isList(), islower(), etc.) que retornam verdadeiro (1) ou falso (0) e para a conversão de dados (number(), string(), hex(), etc.)
Bibliotecas e funções
Um bom número de funções estão disponíveis na linguagem e não necessittam de nenhum comando adicional. Funções para listas (find, sort, reverse, swap, etc.), strings (lower, upper, left, right, trim, lines, substr, etc.), data e hora (time, date, adddays, diffdays, etc.), matemáticas (sin, cos, log, ceil, power, sqrt, random, etc.), arquivos (read, write, fopen, fread, fexists, dir, etc.), sistema (system, currentdir, exefilename, version, etc.) entre outras.
Na forma mais simples, para uma biblioteca de funções basta escrever um programa em Ring e, em outro, utilizar Load para ter acesso a todas as funções. Como podem existir variáveis globais e ocorrer um conflito, pode-se usar Load package e todas as variáveis serão locais.
Existem também bibliotecas com interface para bibliotecas em C/C++ para finalidades diversas como banco de dados (odbclib, mysql, sqlite), internet e segurança (internet com md5, sha512, libcurl), arquivos compactados (ziplib), interface gráfica QT (guilib) entre outras.
Existe a biblioteca stdlib que possui diversas classes e funções para facilitar a programação. Alguns exemplos de funções:
times (3, func {put "Hello World!" + nl})
map (1:10, func x {return x*x})
filter (1:20, func x {if x<5 return true else return false ok})
split ("um,dois,três,quatro",",")
lineCount("teste.ring")
isPrime(7)
a = [[1,2,3],[4,5,6],[7,8,9]]
b = [[1,0,0],[0,1,1],[0,0,1]]
MatrixMulti(a,b)
Alguns exemplos de classes de stdlib são
String, List, Stack, Queue, HashTable, Tree, Math, System, etc.
Basicamente são criadas classes encapsulando as funções já existentes podendo adicionar algumas funções. Em String, por exemplo, existe o método toFile(arquivo) que irá gravar o conteúdo da string em um arquivo especificado. Outras como HashTable, apenas, facilitam o trabalho com estrutura que pode ser feitas com listas (veja o tópico lista abaixo). Já Queue e Tree, apesar de poderem ser feitas proceduralmente, facilitam trabalhando com objetos.
nota: Não sei se esqueceram, está em desenvolvimento ou não irão colocar mas algumas classes poderiam ter outros métodos adicionados. Entre outras coisinhas, acho que a classe List poderia ter Map e Filter. Vamos tentar resolver depois.
Operadores
Os operadores matemáticos normais de qualquer linguagem (adição, subtração, divisão e multiplicação) e mais (incremento ++ e decremento —), lógicos (and, or, xor, complemento, rotação de bits para direita e esquerda. Eles podem ser combinados (a+=2) para diminuir o trabalho de digitação. A exponenciação é feita por função pow(x,y).
Estruturas de controle
Para o controle condicional temos os normais sendo que alguns aceitam diversas sintaxes. Nos exemplos abaixo, se você deseja fechar o comando com a chave, deverá colocar a chave inicial. Você pode escolher uma das opções separadas pela barra.
if cond [ { ]
comandos
but | elseif cond
comandos
...
else
comandos
end | ok | }
switch var [{]
on | case cond
comandos
...
other | else
comandos
off | end | }
while cond [{]
comandos
end | }
for var=inicio to fim | range [step passo] [{]
comandos
next | end | }
do
comandos
again cond
try | [{]
comandos
catch
comandos
end | }
Para os diversos laços, tem o loop para voltar o início e o exit para sair do laço. Até aqui, sem novidades. Mas elas aceitam um número indicando o número de níveis que devem ser executadas em laços aninhados.
? "inicio"
for x in 1:10 // nível 2
for y = 1 to 10 // nivel 1
if x > 3
exit 2
ok
if y = 4 loop 2 ok
? "(" + x + "," + y + ")"
next
next
? "fim
resulta:
inicio
(1,1)
(1,2)
(1,3)
(2,1)
(2,2)
(2,3)
(3,1)
(3,2)
(3,3)
fim
Para finalizar, também funcionam dentro de funções. Por exemplo:
for x in 1:10
ignore(x,5,7)
see x + nl
next
def ignore x,y,z
if (x < y) or (x > z)
loop
ok
irá mostrar apenas os números 5,6,7 (lembrei do setjump/longjump de C).
Listas
Este tópico entrou mais para que eu possa desabafar. Em Ring, são indexadas iniciando em 1. Li comentários de gente reclamando pois não iniciava em zero. Mais ou menos como discutir se é bolacha ou biscoito. Bom mesmo é o Pascal onde pode-se iniciar com qualquer valor. Se eu fosse trabalhar com dados entre os anos de 1980 e 2018, a melhor forma seria algo como eventos : array [1980..2018] of evento;. E não precisaria ficar fazendo continhas do tipo eventos[ano - 1980].
Mas já que toquei no assunto, listas podem armazenar valores variados e não estão restritas um um determinado tipo. Um caso especial das listas é a matriz tipo nx2 que pode ser utilizada como um hash. Se você definir uma lista como: aList = [["um",1], ["oito",8], ["quatro",4]] poderá acessar os valores com aLista["um"] e alterá-los com aList["oito"]=9. Só lembrando que aList[1] retorna ["um",1]. Em Ring, o operador dois pontos pode ser utilizado antes de um identificador para convertê-lo em literal então, ficaria mais fácil definir como aList = [:um = 1, :oito = 8, :quatro = 4] e acessar como aLista[:oito]=9.
Como listas podem ser passadas como argumentos para as funções, podemos utilizar o método acima para nomear os parâmetros sem se preocupar com a ordem dos mesmos. Por exemplo:
p = new point([:y = 1, :x = 23])
p.print()
Class Point
x y
def init aList
x = aList[:x]
y = aList[:y]
def print
put "(" + x + "," + y + ")"
Como resultado, o código acima mostrará (23,1).
Alterações nos elementos de uma lista podem ser feitos facilmente sem a necessidade de referenciar a lista e seu índice. Por exemplo:
lista = 1:6
for x in lista
switch x
on 2 x = "dois"
on 3 x = "três"
on 4 x = x * 2
on 6 x = "seis"
end
next
? lista
retorna
1
dois
três
8
5
seis
Objetos
A implementação de objetos em Ring até que ficou legal. Tem private, this, self, super entre outras coisinhas e, usando algumas coisas de metaprogramação e linguagem natural implementadas em Ring, ganham um charme especial. Por exemplo:
// início do programa
o1 = new Retangulo(8, 9)
o1.area()
o1.perimetro()
metodos(o1)
o2 = new Quadrado(7)
o2 {
? "{ início em o2"
funcao()
variavel
area()
perimetro()
? "} fim em o2"
}
metodos(o2)
sublinhado(nl+"Classes:")
? classes()
// funções do programa
def metodos o
sublinhado(nl+"Métodos da classe "+classname(o))
? methods(o1)
def sublinhado s
? s
? copy("-",len(s))
// classes do programa
Class Retangulo
l1 l2
def init l1, l2
this.l1 = l1
this.l2 = l2
? "Retangulo de lados: "+l1+" e "+l2
def area
a = l1 * l2
? "Área: " + a
def perimetro()
p = l1 * 2 + l2 * 2
? "Perímetro: " + p
Class Quadrado from Retangulo
def init x
l1 = x
l2 = x
? "Retangulo de lado = "+x
def perimetro
? "- Executando operações específicas antes."
super.perimetro()
? "- Executando operações específicas depois."
def braceStart
? "-------- 8< --------"
def braceEnd
? "-------- >8 --------"
def braceError
? cCatchError
No trecho acima, as funções methods e classes são da parte de metaprogramação da linguagem e retornam as classes definidas no programa e os métodos disponíveis em uma classe. As chaves estão na parte de propgramação orientada ao objeto indicando que tudo o que está entre elas faz referencia ao objeto logo antes. As funções braceStart, braceEnd e braceError estão na parte de programação natural. As duas primeiras são chamadas no momento em que encontraram as respectivas chaves. A última é acionada quando é encontrado um erro. Pode ser interessante para tratamento de erros dentro da função, baseando-se no código de erro.
Retangulo de lados: 8 e 9
Área: 72
Perímetro: 34
Métodos da classe retangulo
-----------------------------
init
area
perimetro
Retangulo de lado = 7
-------- 8< --------
{ início em o2
Error (R3) : Calling Function without definition !: funcao
Error (R24) : Using uninitialized variable : variavel
Área: 49
- Executando operações específicas antes.
Perímetro: 28
- Executando operações específicas depois.
} fim em o2
-------- >8 --------
Métodos da classe quadrado
----------------------------
init
area
perimetro
Classes:
---------
retangulo
quadrado
TDD
A linguagem não traz maiores facilidades para desenvolvimento de testes mas, por dois motivos, nem é necessário. Primeiro eu não erro então são supérfluos. Segundo, mesmo não sendo mais profissionais, são relativamente fáceis de acoplar ao desenvolvimento. Vejamos o problema da classe lista da biblioteca stdlib que eu gostaria que tivesse Map e Filter. Para não alterar a biblioteca do sistema e não conflitar com os metodos da classe, fui obrigado a chamá-los de @Map e @Filter (ficaria mais bonitinho se eu alterasse o nome das funções globais para $Map e o método poderia ficar como Map).
O primeiro passo seria olhar a classe List. Verifiquei que ela possui testes mas é algo mais visual. Apenas são mostrados os valores o que para mim não são testes. Apenas resultados. Utilizei assert para os testes ficarem mais rígidos. Também não tinha a comparação entre listas diretamente então foi criado o método Compare que irá retornar -1, 0 ou 1 se a primeira lista for menor, igual ou maior que a segunda (poderia retornar apenas true e false). Criei o arquivo ListPlus.ring que ficou assim:
Load "stdlib.ring"
if IsMainSourceFile()
listPlus_test()
ok
func listPlus_test()
aList = new listPlus([1,2,3])
assert(aList.Compare(aList.Value())=0)
assert(aList.Compare([1,2,3]) = 0)
assert(aList.Compare([1,2]) = 1)
assert(aList.Compare([1,2,3,6]) = -1)
assert(aList.Compare([1,2,1]) = 1)
assert(aList.Compare([1,2,6]) = -1)
assert(aList.String() = "[1, 2, 3]")
assert(aList.@Map(func x { return x*x}).Compare([1,4,9]) =0)
assert(aList.@Filter(func x {if x%2 = 0 return false ok return true}).Compare([1,3])=0)
aList.@Permutation()
aList.@Permutation()
assert(aList.Compare([2,1,3])=0)
? "Passou nos testes"
end
Class listPlus From List
func @Filter aFunc
return new listPlus (Filter(vValue, aFunc))
func @Map aFunc
return new listPlus (Map(vValue, aFunc))
func @Permutation
Permutation(vValue)
func Compare aList
v1 = len(vValue)
v2 = len(aList)
if v1 < v2
return -1
but v1 > v2
return 1
ok
for i=1 to v1
if vValue[i] = aList[i]
loop
ok
if vValue[i] > aList[i]
return 1
else
return -1
ok
next
return 0
func String
s= "["
for i=1 to len(vValue)
s = s +vValue[i]+", "
next
return left(s,len(s)-2) + "]"
Se o arquivo for chamado com ring listPlus.ring, a função IsMainSourceFile retorna true e os testes serão executados. Se for via Load, serão ignorados. Bem, é para efeitos didáticos. Poderia ser melhor colocar os testes em poutro arquivo.
Ambiente de desenvolviemto
Pode ser utilizado qualquer editor de textos para a criação dos programas. Existem extensões para o Notepad++, Geany, Atom, Sublime Text 2, Visual Studio e Emacs. Não tem para o Vim e para o Emacs é quase como se não tivesse. Existem alguns programa feitos em Ring como dois REPL (CLI e GUI) sendo os dois bem rudimentares. Porém existe o rnote que é escrito em Ring e é bem legal.
rnote
É um ambiente de desenvolvimento escrito em ring. Em vez de ficar escrevendo, melhor ir mostrando as funcionalidades.
Na aba Source Code o usuário pode entrar com o código (novidade?). É bem básico e os maiores problemas que encontrei foram o de carregar apenas um arquivo por vez e não endentar automaticamente o código. Aqueles números de linhas grandes eu não gostei. Não sei se os problemas são inexperiência ou existem mesmo. Podemos executar o código e a saída será mostrada no painel da direita. No painel também é possível ver uma lista de funções e classes do programa e é possível clicar para posicionar o código no elemento desejado. Se como editor deixa a desejar, como REPL é bem bom.
Na aba Form Designer é possível montar a nossa janela com facilidade. Quem conhece Delphi/Lazarus e outros sabe que é bem prático. Após o termino do design, se salvarmos com o nome de teste, por exemplo, serão gerados os seguintes arquivos. O arquivo teste.rform, o testeView.ring e testeController.ring. Basta editar o testeController.ring para executar as tarefas desejadas.
A aba Web Browser parece mais para ver a documentação. Falta uma integração maior o com o código tipo pressionar F1 e abrir a documentação no item correspondente.
Exemplo besta
Basicamente o programa irá ler os arquivos de um determinado diretório, mostrar o nome e um cabeçalho (caracteres de controles e outros não imprimíveis serão mostrados como ponto) e deverá rodar no console, GUI e navegador.
Primeiramente vou definir um arquivo com funções comuns (acho que o ideal seria criar uma classe mas, para fins didáticos, ficamos com uma programação procedural mesmo).
CLI
GUI
WEB
Como foi desenvolvido em estágio precário de conhecimento, vou fazer algumas alterações nos fontes e depois eu disponibilizo (se alguém se interessar).
No mais …
Não testei em outros ambientes fora o Linux. Mas pareceu ser interessante e até útil. É relativamente nova e ainda precisa de mais testes. Tive um problema com Dir() que retorna uma lista com o nome do arquivo e o tipo (0=arquivo, 1=diretório). Quando chamado para um local diferente do diretório que o programa estava rodando, embaralhava o tipo do arquivo. Pode ser só no Linux, no meu Linux, ou em qualquer SO.
O resto funcionou como deveria funcionar. Quando tiver mais tempo, pretendo testar para o Android+QT. Fiquei mais tempo do que desejava testando a linguagem e agora terei que trabalhar no final de semana. LOL.
Referências
No próprio site da lnguagem http://ring-lang.net/.
Acho que, mais importante que este artigo, é ler o conteúdo da página inicial e a FAQ. Diversas informações interessantes sobre a linguagem, os paradigmas, etc..
