Introdução ao Soyuz

Soyuz é uma linguagem de programação compilada, de propósito geral, projetada para ser expressiva, segura e pragmática. Ela compila para binários nativos via LLVM e abraça um estilo multiparadigma — combinando o melhor da programação orientada a objetos e funcional.

A extensão dos arquivos fonte é .sy.

---

Filosofia

Soyuz foca na legibilidade do código e segurança em tempo de compilação:

Imutabilidade como padrão. Variáveis imutáveis (val) são o caso comum. Mutabilidade (var) precisa ser declarada explicitamente. Não existe const; val é poderoso o suficiente para todos os casos de imutabilidade.

Erros são valores. Não há try/catch. Erros são representados pelo tipo Result[T] e tratados com pattern matching ou PipeQuest (|?>). O compilador garante que você trate as falhas, e o auto-wrapping torna o código limpo.

Extensível, não hierárquico. Sem herança de classes. Use interfaces para contratos e extensões (extend) para adicionar comportamento a tipos existentes, mantendo o sistema desacoplado e flexível.

Gerenciamento de memória automático. Soyuz usa um garbage collector transparente, permitindo que você foque na lógica do seu domínio enquanto o runtime cuida da alocação.

---

Características em destaque

Call Sugar & Auto-wrapping

Result e Option são facilitados: retorne o valor puro e o Soyuz o envolve em Ok() ou Some() automaticamente.

PipeQuest |?>

O operador |?> integra Option e Result perfeitamente, curto-circuitando falhas e facilitando o encadeamento funcional seguro.

Extensões (extend)

Adicione métodos a qualquer tipo (class ou primitivo), sem precisar de herança ou wrappers complexos.

Overloading & When Guards

Crie funções poderosas com despacho baseado em predicados (when), tornando o código declarativo e exaustivo.

Aplicação Parcial

Use o placeholder _ para criar novas funções fixando argumentos, facilitando o uso de funções de alta ordem.

Compilado para nativo

Backend LLVM gera binários nativos de alta performance para a sua plataforma.

---

Exemplo rápido

import (
    { List, Map } from @soyuz/collections
    { Error } from @soyuz/prelude
)

record Produto {
    id: Int
    nome: String
    preco: Float
}

interface Estoque {
    fn adicionar(self, p: Produto) -> Result[Unit]
    fn buscar(self, id: Int) -> Produto?
}

class LojaVirtual : Estoque {
    var produtos: List[Produto] = []

    // Overloading com when guard
    fn adicionar(self, p: Produto) -> Result[Unit] {
        if self.buscar(p.id).isSome() {
            return noneError("Produto já existe") // Auto-wrapped em Err()
        }
        self.produtos.add(p)
        return () // Auto-wrapped em Ok(Unit)
    }

    fn buscar(self, id: Int) -> Produto? {
        return self.produtos.find(fn(p) => p.id == id)
    }

    fn totalEstoque(self) -> Float {
        // Uso de partial application (_) e pipes
        return self.produtos
            |> map(_.preco)
            |> reduce(fn(acc, v) => acc + v, 0.0)
    }
}

fn main() {
    val loja = LojaVirtual { produtos: [] }
    val prod = Produto { id: 1, nome: "Teclado", preco: 250.0 }

    match loja.adicionar(prod) {
        Ok(_) => print("Sucesso!")
        Err(e) => print("Erro: $(e.message())")
    }
}

---

Influências

Soyuz é influenciada pelas seguintes linguagens:

Influência	O que foi inspirado
Kotlin	Sintaxe geral, null safety, extensões e parâmetros default
Rust	Pattern matching robusto, erros como valores e sem herança
Haskell	Pattern matching em parâmetros de função e ADTs
Go	Simplicidade e sistema de módulos pragmático
Dart	Interpolação de strings e operadores safe navigation
F# / Elixir	Estilo funcional com piping (|>)

---

Primeiros Passos

# Compilar seu programa
soyuz build main.sy

# Executar diretamente
soyuz run main.sy

# Apenas checagem de tipos
soyuz check main.sy