Implementação experimental de uma linguagem interpretada em Rust com suporte a:

• Structs
• Enums (variantes com payload) + shorthand .Variant com detecção de ambiguidade
• Pattern matching com guards (case .X(v) if v > 10:)
• Funções e closures (captura léxica)
• Métodos em structs e enums com auto-binding de self
• Introspecção em métodos de enum (variant, values)
• f-Strings com format specs (upper, lower, trim, hex, padN, debug placeholder)
• Result-like enums e operador ? (propagação inicial)
• Arrays com builtins (sum, count)
• Standard Library embutida: Collections (Map, Set), Math (abs, pow, clamp), Time & Rand, File IO (sandboxed).
• Métricas de execução (handled_errors, executed_statements, crash_free%)
• Language Server Protocol (LSP) básico com diagnósticos instantâneos na IDE (art lsp)

Complexidade Progressiva

Artcode é uma linguagem experimental implementada em Rust que foca em ser fácil para iniciantes e potente para especialistas — "Complexidade Progressiva": comece com ARC simples e suba a escada para arenas, weak/unowned e blocos performant quando precisar de controle de memória e máxima performance.

Por que Artcode é relevante

• Projeto modular, com lexer, parser, interpreter e runtime separados.
• Diagnósticos estruturados: erros com spans e sugestões, sem panics em parsing.
• Modelo de memória pragmático: ARC por padrão + weak/unowned explícitos; ferramenta de detecção de ciclos para testes.
• Plano de JIT/AOT com PGO: permite otimizações guiadas por perfil quando chegar a etapa de compilação AOT.

Principais recursos

• Structs e Enums (variants com payloads e shorthand .Variant com checagem de ambiguidade)
• Pattern matching com guards
• Funções, closures e métodos com auto-binding de self
• f-Strings com format specs e re-lex/parsing das expressões internas
• Standard Library Expansiva (Coleções Padrão de Map/Set, Manipulação de Matemática e IO Simples)
• Result-like enums e operador ? para propagação de erros
• Blocos performant {} com arenas experimentais e análise conservadora de escape

Status do projeto

• Código modular em crates: core, lexer, parser, interpreter, diagnostics, cli.
• Testes: suíte unitária e de integração com exemplos em examples.
• Ferramentas: xtask para cobertura e scripts para validar exemplos.

Instalação

Forma rápida (Linux / macOS)

curl -fsSL https://raw.githubusercontent.com/kitsuneislife/artcode/main/install.sh | bash

Isso baixa o binário da última release e instala em /usr/local/bin/art.

Windows: baixe o .exe direto na página de releases.

Compilar a partir do fonte

Prerequisitos: Rust stable toolchain (curl https://sh.rustup.rs -sSf | sh).

git clone https://github.com/kitsuneislife/artcode.git
cd artcode
cargo build -p cli --release
sudo cp target/release/art /usr/local/bin/

Uso básico

# Executar um script
art run examples/00_hello.art

# Métricas de execução
art metrics --json meu_script.art

# Language Server (LSP) para editores
art lsp

# Build e testes (desenvolvimento)
cargo test --all

Design e diferenciais (curto)

• Complexidade Progressiva: níveis de abstração claros (ARC default → weak/unowned → arenas/performant).
• Diagnósticos de qualidade: diagnostics crate centraliza mensagens e spans para boa DX.
• Foco em interoperabilidade e PGO a médio prazo.

Contribuindo

• Leia docs/ e as RFCs em docs/rfcs/ antes de mudanças maiores.
• Use o checklist operacional em /.kit/checklist.md para priorizar trabalho.
• Para mudanças de design: abra uma RFC (docs/rfcs/0000-template.md quando existir) e link no PR.

Licença & contato

• Projeto com licença MIT (ver LICENSE).
• Para discussões de design: abra issues ou PRs no repositório.

---

Documentação (pasta docs/)

A pasta docs/ contém material técnico e de design — roteiros que explicam decisões arquiteturais e guias de contribuição:

• overview.md — visão geral da linguagem e arquitetura dos crates.
• parser_lexer.md — como o lexer e o parser foram projetados, spans e diagnostics.
• interpreter.md — runtime model, representações de valores e execução.
• memory.md — especificação do modelo de memória (ARC, weak/unowned, arenas).
• fstrings.md, functions.md, enums.md — guias de recursos e exemplos.

Leia docs/SUMMARY.md para um índice rápido. Se você for contribuir com mudanças de linguagem, crie uma RFC em docs/rfcs/ e referencie-a nas PRs.

Links rápidos para os principais documentos:

• Visão geral
• Lexer & Parser
• Interpreter (runtime)
• Memória (ARC / weak / arenas)
• f-Strings (format specs)
• Funções & Closures
• Enums & Pattern Matching
• Coverage & Métricas
• Roadmap
• Sumário / Índice

Interoperabilidade / FFI (pasta docs/)

A pasta docs/ contém esboços e diretrizes para integrar Artcode com C/Rust/WASM. Resumo rápido:

• docs/ffi.md — visão geral e recomendações de ownership ao passar strings e buffers.
• Convenções propostas:
  • Strings: Arc<str> ↔︎ *const c_char com funções helper de conversão.
  • Tipos primitivos: mapeamento direto (i64, f64, bool).
  • Ownership: documentar claramente quando a posse é transferida (caller/callee).
• PoC: exemplos simples devem viver em examples/docs/ (C wrapper e macro art_extern!{} no futuro).

Se você pretende usar Artcode em um projeto existente em Rust/C, veja docs/ffi.md para padrões recomendados e exemplos mínimos.