Pular para o conteúdo
cajulang

Exemplos

Programas completos em Caju, com a saída que cada um imprime. Copie, salve num arquivo .caju e rode com caju run.

O básico

Tipos opcionais

Com tipos, o compilador encontra erros antes de rodar. Sem eles, os tipos são inferidos.

types.caju
fn average(total: num, n: int) -> num {
  return total / n
}
 
let sum = 0
let count: int = 0
for i = 1 to 4 {
  sum = sum + i * 1.5
  count = count + 1
}
print("average:", average(sum, count))
 
# count = "four"   error: int does not accept str
$ caju run types.caju
average: 3.75

Funções são valores

Uma closure guarda as variáveis de fora e continua com elas.

closures.caju
fn counter() -> fn() -> int {
  n := 0
  return fn() -> int {
    n++
    return n
  }
}
 
a := counter()
b := counter()
print(a(), a(), a(), b())
$ caju run closures.caju
1 2 3 1

Slices e mapas

Listas que crescem com append e mapas de chave e valor, já na linguagem.

maps.caju
stock := map[str]int{"banana": 12, "cashew": 30}
stock["mango"] = 5
stock["banana"] -= 2
delete(stock, "mango")
 
if qty, ok := stock["cashew"]; ok {
  print("cashews in stock:", qty)
}
print(stock)
 
grades := []int{7, 9, 4}
grades = append(grades, 10)
print(grades, len(grades))
$ caju run maps.caju
cashews in stock: 30
map["banana":10 "cashew":30]
[7 9 4 10] 4

defer

Agende uma chamada para quando a função terminar. As chamadas rodam da última para a primeira.

defer.caju
fn chores() {
  defer print("3. clear the table")
  defer print("2. wash the dishes")
  print("1. have dinner")
}
 
chores()
$ caju run defer.caju
1. have dinner
2. wash the dishes
3. clear the table

Tipos e estruturas

Structs, métodos e interfaces

Um tipo atende a uma interface só por ter os métodos dela, sem declarar nada.

shapes.caju
interface Shape { area() -> num }
 
struct Rect { w: num, h: num }
struct Circle { r: num }
 
fn (r: Rect) area() -> num { return r.w * r.h }
fn (c: Circle) area() -> num { return 3.14159 * c.r * c.r }
 
shapes := []Shape{Rect{2, 3}, Circle{1}}
for _, s := range shapes { print(s.area()) }
$ caju run shapes.caju
6
3.14159

Structs embutidas

Car ganha os campos e os métodos de Engine.

embed.caju
struct Engine { power: int }
fn (e: Engine) roar() -> str { return "vroom " + str(e.power) }
fn (e: *Engine) boost() { e.power *= 2 }
 
struct Car {
  Engine
  model: str
}
 
car := Car{Engine{90}, "beetle"}
car.boost()
print(car.model, car.power, car.roar())
$ caju run embed.caju
beetle 180 vroom 180

Switch de tipos

Descubra o tipo guardado num any e trate cada caso.

typeswitch.caju
fn describe(x: any) -> str {
  switch v := x.(type) {
  case int: return "integer " + str(v)
  case num: return "number " + str(v)
  case str: return "text with " + str(len(v)) + " bytes"
  case nil: return "nil"
  default: return "something else"
  }
}
 
for _, x := range []any{7, 2.5, "caju", nil, true} {
  print(describe(x))
}
$ caju run typeswitch.caju
integer 7
number 2.5
text with 4 bytes
nil
something else

Erros

Erros são valores

A função devolve o resultado e um erro, sem exceções escondidas.

divide.caju
fn divide(a: int, b: int) -> (int, error) {
  if b == 0 { return 0, errors.New("division by zero") }
  return a / b, nil
}
 
for _, d := range []int{5, 0} {
  q, err := divide(10, d)
  if err != nil {
    print("error:", err)
    continue
  }
  print("10 /", d, "=", q)
}
$ caju run divide.caju
10 / 5 = 2
error: division by zero

panic e recover

recover, dentro de um defer, interrompe o panic. Um índice fora da lista também vira panic.

recover.caju
fn safe(f: fn()) -> (err: error) {
  defer fn() {
    if r := recover(); r != nil { err = errors.New("recovered: " + str(r)) }
  }()
  f()
  return nil
}
 
print(safe(fn() { panic("something went wrong") }))
print(safe(fn() {
  list := []int{1, 2, 3}
  i := 5
  print(list[i])
}))
$ caju run recover.caju
recovered: something went wrong
recovered: Index 5 out of range (length 3)

Pacotes

Usando um pacote

Adicione a dependência com caju pkg add e importe pelo caminho do repositório.

app.caju
import "github.com/acme/strutil"
 
print(strutil.shout("caju"))
$ caju pkg add github.com/acme/strutil
downloading github.com/acme/strutil@1.1.0
added github.com/acme/strutil@1.1.0; 1 packages ok
$ caju run app.caju
CAJU!

Publicando um pacote

Um caju.toml na raiz do repositório e uma tag git com a versão, como v1.1.0. O export define o que outros projetos podem usar.

strutil.caju
# caju.toml
# [package]
# name = "github.com/acme/strutil"
# version = "1.1.0"
 
import "std/strings"
 
export fn shout(s: str) -> str { return strings.to_upper(s) + "!" }

Biblioteca padrão

JSON

Converta structs em JSON e JSON em structs com std/json.

json.caju
import "std/json"
 
struct Fruit {
  name: str
  price: num
  tags: []str
}
 
text, _ := json.marshal(Fruit{"cashew", 2.5, []str{"tropical", "sweet"}})
print(text)
 
f := Fruit{}
err := json.unmarshal("{\"name\": \"mango\", \"price\": 3}", &f)
print(f.name, f.price, err)
$ caju run json.caju
{"name":"cashew","price":2.5,"tags":["tropical","sweet"]}
mango 3 nil

Arquivos e textos

std/fs para ler e gravar arquivos; std/strings para trabalhar o texto.

files.caju
import "std/fs"
import "std/strings"
 
fs.write_file("notes.txt", "cashew\nmango\nguava\n", 0o644)
 
text, err := fs.read_file("notes.txt")
if err != nil {
  print("error:", err)
} else {
  lines := strings.split(strings.trim_space(text), "\n")
  print(len(lines), "lines:", strings.join(lines, ", "))
}
$ caju run files.caju
3 lines: cashew, mango, guava

Hash e codificação

SHA-256, base64, hex e outros, sem dependências externas.

crypto.caju
import "std/crypto"
import "std/base64"
 
print(crypto.sha256_hex("caju"))
print(base64.encode("caju"))
$ caju run crypto.caju
247b3a76c41fb983655aeeb0955751d31eac8e76a817b2508bc4e297f09aad90
Y2FqdQ==

Um servidor web com a biblioteca padrão

O std/http já vem junto. Este programa vira um executável de cerca de 100 KB.

hello-server.caju
import "std/http"
import "std/os"
 
http.handle("/", fn(req: *http.Request, res: *http.Response) {
  res.write("hello world")
})
print("listening on http://localhost:3200/")
err := http.listen_and_serve("0.0.0.0", 3200)
if err != nil {
  os.eprintln(err.Error())
  os.exit(1)
}

Testes ao lado do código

Arquivos _test.caju no estilo BDD, rodados com caju test.

strings_test.caju
import "std/strings"
import { describe, it, expect } from "std/testing"
 
describe("strings.split", fn() {
  it("cuts the text at every separator", fn() {
    expect(strings.split("a,b", ",")).to_equal([]str{"a", "b"})
  })
})
$ caju test strings_test.caju
ok strings_test.caju (1 tests)
1 passed, 0 failed, 0 skipped in 1 files

Pronto para testar?

Instalar a Caju