Logo do Bern

Uma linguagem de inspiração funcional focada em expressividade.

iex (irm https://bern-lang.github.io/Bern/install/install_bern.ps1)

Instale com PowerShell usando o comando acima.
Como alternativa, instale com Bash usando curl -fsSL https://bern-lang.github.io/Bern/install/install_bern.sh | bash

🔋

Baterias Inclusas

A biblioteca padrão oferece um conjunto rico de funções para manipulação de dados, E/S e muito mais, para você começar rapidamente.

1
2
3
4
5
6
7
8
import core
import random
import strings

-- Esta é de fato uma função 'random' que envolve um binding em C!
text = random_choice(['apple', 'banana', 'cherry'])

map(text, \c -> char_to_upper(c))
🎯

Casamento de Padrões

Defina funções com várias cláusulas que casam padrões, deixando seu código claro e fácil de manter.

1
2
3
4
5
def sign(0) -> "zero"
def sign(n) -> "positive"

def greet("Alice") -> "Hi, Alice!"
def greet(_) -> "Hello, someone else!"
📦

Tipos de Dados Algébricos

Crie tipos personalizados com vários construtores para modelar dados com segurança de tipos. ADTs combinam naturalmente com casamento de padrões.

1
2
3
4
5
6
7
8
9
adt Shape = Circle Double | Rectangle Double Double

def area(Circle(r)) -> 3.14159 * r * r
def area(Rectangle(w, h)) -> w * h

c = Circle(5.0)
r = Rectangle(3.0, 4.0)

area(c)  // Calcula a área do círculo
🔄

Sintaxe de Laço Unificada

Use a palavra-chave loop para todos os tipos de laço, inspirada em Odin. Sintaxe limpa para laços de repetição, condicionais e de iteração. (for ainda funciona como sinônimo.)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Laço de repetição
loop 3 do
    "Hello!"
end

// Laço condicional
loop counter > 0 do
    counter = counter - 1
end

// Laço loop-in
loop char : "Bern" do
    char
end
λ

Funções de Primeira Classe

Funções são valores que podem ser passados adiante, retornados e compostos. Expressões lambda tornam funções em linha algo natural.

1
2
3
4
5
6
7
8
import core

// Uso de função de ordem superior
map([1, 2, 3, 4, 5], \x -> x * 2)

// Expressões lambda
inc = \x -> x + 1
applyTwice(\n -> n * 2, 5)
➡️

Operador Pipe

O operador )| encaminha um valor para uma função como seu primeiro argumento, então as transformações de dados são lidas da esquerda para a direita.

1
2
3
4
5
import core

// x )| f  é o mesmo que  f(x)
[1, 2, 3, 4] )| filter(\x -> x % 2 == 0) )| map(\x -> x * 10)
// [20, 40]
📝

Operadores em Palavras Legíveis

É novo na programação? Você não precisa decorar símbolos enigmáticos. Todo operador tem um nome em palavras simples, então você escreve o que quer dizer e lê seu código em voz alta. Quando estiver à vontade, os símbolos também funcionam, e você pode misturar os dois livremente.

1
2
3
4
3 is-greater 2 and 5 is-less-or-equal 5  // true
[1, 2] concat [3, 4]                 // [1, 2, 3, 4]
total be 10 plus 5                      // atribuição com palavras
17 modulo 5                           // 2

🌟 Também Inclui

Exemplos

Uma amostra rápida abaixo. Para um passo a passo guiado e detalhadamente explicado de cada recurso, vá para a página de Exemplos aprofundada →

Básico

Em Bern, literais são interpretados e impressos automaticamente. Variáveis são definidas com uma atribuição simples.

integer = 2 double = 3.14 helloworld = "Hello, World!"

Condicionais

Use instruções if-then-else e cadeias else-if para lógica condicional.

age = 18 if age >= 18 then "You are an adult." else "You are a minor." end

Listas

Listas são coleções homogêneas com sintaxe de intervalo e diversas operações.

numbers = [1, 2, 3, 4, 5] range = [5..10] [1, 2] + 2 // Mapeia: [3, 4] [1, 2] <> [3, 4, 5] // Concatenação [1, 2, 3] <| [3, 4, 5] // União (sem duplicatas)

Conjuntos

Conjuntos cuidam da unicidade automaticamente e oferecem operações da teoria dos conjuntos.

{1, 2} + 3 // Adiciona elemento {1, 2, 3} |> {2, 3, 4} // Interseção {1, 2, 3} {2, 3, 4} // Diferença

Objetos (Hashmaps)

Objetos usam a notação #{...}# para pares chave-valor.

obj = #{ key: "value", hello: "world" }# obj["key"] = "new_value" obj["new_key"] = "added_value"

Funções com Corpo em Bloco

Use blocos do...end com return para funções mais complexas.

def sumList(xs) do total = 0 loop n : xs do total = total + n end return total end sumList([1, 2, 3, 4]) // Retorna 10

Importações

Estenda funcionalidades importando bibliotecas como core.

import core map([1, 2, 3, 4, 5], \x -> x + 2) def isEven(x) -> x % 2 == 0 filter([1, 2, 3, 4, 5, 6], isEven)

Operador Pipe

O operador )| passa um valor como primeiro argumento para uma função, deixando os encadeamentos serem lidos da esquerda para a direita.

import core [3, 1, 2] )| reverse // [2, 1, 3] [1, 2, 3, 4] )| filter(\x -> x > 2) // [3, 4]

Entrada do Usuário

Capture a entrada do usuário com a função input().

name = input("Type your name: ") import core age_text = input("Type your age: ") age = to_int(age_text)