umka lang
Umka 1.5
Umka é uma linguagem de script incorporável de tipo estaticamente. Ele combina a simplicidade e a flexibilidade necessárias para scripts com proteção em tempo de compilação contra erros de tipo. Seu objetivo é seguir o princípio Zen do Python Explícito é melhor que implícito de forma mais consistente do que as linguagens de tipo dinâmico geralmente fazem.
Multiplicação de matrizes 400 x 400 (AMD A4-3300M a 1,9 GHz, Windows 7) 
fn main() {
printf("Hello Umka!n")
}
const a = 3
const b* = 2.38 // Exported identifier
const (
c = sin(b) / 5
d = "Hello" + " World"
)
type IntPtr = ^uint16 // Pointer
type Arr = [a]real // Array
type (
DynArr = [][5]int // Dynamic array
String = str // String
Button = enum { // Enumeration
left
middle
right
}
MyMap = map[str]real // Map
Quat = struct { // Structure
q: [4]real
normalized: bool
}
Printable = interface { // Interface
print(): int
}
ErrFn = fn(code: int) // Function
)
var e: int
var f: String = d + "!"
var (
g: Arr = [3]real{2.3, -4.1 / 2, b}
h: DynArr
m: MyMap
)
q := Quat{q: [4]real{1, 0, 0, 0}, normalized: true}
fn tan(x: real): real {return sin(x) / cos(x)}
fn getValue(): (int, bool) {return 42, true}
fn (a: ^Arr) print(): int {
printf("Arr: %vn", a^)
return 0
}
h = make([][5]int, 3) // Dynamic arrays and maps are initialized with make()
m = make(MyMap)
m["Hello Umka"] = 3.14
sum := 0.0
y := tan(30 * std::pi / 180)
h = append(h, [5]int{10, 20, 30, 40, 50})
h = delete(h, 1)
g.print()
if x, ok := getValue(); ok {
printf("Got %vn", x)
}
switch a {
case 1, 3, 5, 7: std::println(std::itoa(a) + " is odd")
case 2, 4, 6, 8: std::println(std::itoa(a) + " is even")
default: std::println("I don't know")
}
switch v := type(a) {
case int: printf("int: %d + 5 = %dn", v, v + 5)
case str: printf("str: %s + 5 = %sn", v, v + "5")
default: printf("unknown: %vn", a)
}
for k := 1; k <= 128; k *= 2 {
printf("%vn", k)
}
for i, x in g {
if fabs(x) > 1e12 {break}
if x < 0 {continue}
sum += x
}
a := new(int)
child := make(fiber, |a| {
for i := 0; i < 5; i++ {
std::println("Child : i=" + std::itoa(i) + " buf=" + std::itoa(a^))
a^ = i * 3
resume()
}
})
for i := 0; i < 10; i++ {
std::println("Parent: i=" + std::itoa(i) + " buf=" + std::itoa(a^))
a^ = i * 7
if valid(child) {
resume(child)
}
}
Enquanto Go é uma linguagem de programação de sistemas compilada com uma biblioteca de tempo de execução complexa e grandes binários de saída, Umka é uma linguagem de script com um interpretador leve que pode ser facilmente incorporado em qualquer aplicativo como uma biblioteca compartilhada.
Umka é muito semelhante a Go sintaticamente. No entanto, em alguns aspectos é diferente. Possui palavras-chave mais curtas: fn para func , str para string , in para range . Para melhor legibilidade, é necessário um : entre nomes de variáveis e tipos nas declarações. Ele não segue a infeliz tradição C de desreferenciação de ponteiros. Em vez de *p , ele usa a sintaxe Pascal p^ . Como o caractere * não é mais usado para ponteiros, ele se torna a marca de exportação, como em Oberon, para que um programador possa usar livremente letras maiúsculas/minúsculas em identificadores de acordo com seu próprio estilo. As asserções de tipo não possuem nenhuma sintaxe especial; eles se parecem com conversões do tipo ponteiro. As definições de fechamento exigem listas explícitas de variáveis capturadas.
Umka permite conversões implícitas de tipo e suporta parâmetros padrão em declarações de função. Ele apresenta o operador condicional ternário omitido deliberadamente do Go. Não possui fatias como tipos de dados separados. Em vez disso, ele suporta arrays dinâmicos, que são declarados como fatias de Go e inicializados chamando make() . Os receptores de método devem ser ponteiros. O modelo multithreading em Umka é inspirado em Lua e Wren, e não em Go. Oferece fios leves chamados fibras em vez de goroutines e canais. O mecanismo de coleta de lixo é baseado na contagem de referências, portanto, Umka precisa oferecer suporte a indicadores weak . O suporte completo ao Unicode está em desenvolvimento.
