Converta Lua em Crystal usando IA

A tradução de código fonte para fonte de Lua usando IA envolve a utilização de técnicas de processamento de linguagem natural (PNL) e algoritmos de aprendizado de máquina para analisar e compreender o código-fonte

CoffeeScript

FAQ

Desafios de Tradução

Problema de Tradução Exemplo de Sintaxe Lua Exemplo de Sintaxe Crystal Pontuação (1-10)
1. Funções de Primeira Classe function f() return function() end end def f; -> { end }; end 6
2. Metatables e Sobrecarga de Operadores setmetatable(t, { __add = function(a, b) return a.value + b.value end }) struct A; def +(other : A) : Int; end; end 7
3. Corrotinas co = coroutine.create(function() end) # Sem equivalente direto 9
4. Tipagem Dinâmica x = 10; x = "string" x : Int = 10; x = "string" 8
5. Tabela como Objetos t = { key = "value" } class T; @key : String; end; t = T.new 5
6. Listas de Argumentos Variáveis function f(...) return {...} end def f(*args) return args end 4
7. Closures function outer() return function inner() end end def outer; -> { end }; end 6
8. Manipulação de Strings string.sub("hello", 1, 3) "hello"[0, 3] 3
9. Tratamento de Erros pcall(function() error("error") end) begin; raise "error"; rescue e; end 5
10. Variáveis Globais _G.var = 10 var = 10 (global por padrão) 2

1. Funções de Primeira Classe

Em Lua, funções são cidadãos de primeira classe, permitindo que sejam passadas como valores. Por exemplo:

function f()
    return function() end
end

Em Crystal, embora as funções também sejam de primeira classe, a sintaxe difere ligeiramente:

def f
  -> { }
end

Referência: Funções Lua

2. Metatables e Sobrecarga de Operadores

Lua permite sobrecarga de operadores através de metatables:

setmetatable(t, {
    __add = function(a, b)
        return a.value + b.value
    end
})

Em Crystal, a sobrecarga de operadores é feita através da definição de métodos em um struct:

struct A
  def +(other : A) : Int
    # implementação
  end
end

Referência: Metatables Lua

3. Corrotinas

Lua tem suporte embutido para corrotinas, que permite multitarefa cooperativa:

co = coroutine.create(function() end)

Crystal não possui um equivalente direto para corrotinas, tornando isso um desafio significativo.

Referência: Corrotinas Lua

4. Tipagem Dinâmica

Lua é tipada dinamicamente, permitindo que variáveis mudem de tipo:

x = 10
x = "string"

Em Crystal, você deve declarar o tipo explicitamente, o que pode levar a erros de tipo:

x : Int = 10
x = "string" # Isso gerará um erro em tempo de compilação

Referência: Tipos Lua

5. Tabela como Objetos

Em Lua, tabelas podem ser usadas como objetos:

t = { key = "value" }

Em Crystal, você normalmente definiria uma classe:

class T
  @key : String
end

t = T.new

Referência: Tabelas Lua

6. Listas de Argumentos Variáveis

Lua suporta listas de argumentos variáveis com a sintaxe ...:

function f(...)
    return {...}
end

Crystal usa uma sintaxe diferente com splats:

def f(*args)
  return args
end

Referência: Funções Lua

7. Closures

Lua suporta closures, permitindo que funções capturem seu ambiente:

function outer()
    return function inner() end
end

Crystal tem um conceito semelhante, mas com sintaxe diferente:

def outer
  -> { }
end

Referência: Closures Lua

8. Manipulação de Strings

Lua fornece um rico conjunto de funções de manipulação de strings:

string.sub("hello", 1, 3)

Em Crystal, o fatiamento de strings é feito de forma diferente:

"hello"[0, 3]

Referência: Funções de String Lua

9. Tratamento de Erros

Lua usa pcall para chamadas protegidas:

pcall(function() error("error") end)

Crystal usa begin e rescue para tratamento de erros:

begin
  raise "error"
rescue e
  # tratar erro
end

Referência: Tratamento de Erros Lua

10. Variáveis Globais

Em Lua, variáveis globais são definidas na tabela _G:

_G.var = 10

Em Crystal, variáveis são globais por padrão, a menos que especificado de outra forma:

var = 10

Referência: Variáveis Globais Lua