umka lang
Umka 1.5
Umka es un lenguaje de programación integrable de tipo estático. Combina la simplicidad y flexibilidad necesarias para la creación de secuencias de comandos con una protección en tiempo de compilación contra errores de tipo. Su objetivo es seguir el principio Python Zen: Explícito es mejor que implícito de manera más consistente que lo que generalmente hacen los lenguajes tipados dinámicamente.
Multiplicación de matrices 400 x 400 (AMD A4-3300M @ 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)
}
}
Si bien Go es un lenguaje de programación de sistemas compilados con una biblioteca de tiempo de ejecución compleja y grandes archivos binarios de salida, Umka es un lenguaje de programación con un intérprete liviano que se puede integrar fácilmente en cualquier aplicación como una biblioteca compartida.
Umka es muy similar a Go sintácticamente. Sin embargo, en algunos aspectos es diferente. Tiene palabras clave más cortas: fn para func , str para string , in para range . Para una mejor legibilidad, se requiere un : entre nombres y tipos de variables en las declaraciones. No sigue la desafortunada tradición de C de desreferenciación de punteros. En lugar de *p , utiliza la sintaxis Pascal p^ . Como el carácter * ya no se usa para punteros, se convierte en la marca de exportación, como en Oberon, de modo que un programador puede usar libremente letras mayúsculas/minúsculas en los identificadores según su propio estilo. Las afirmaciones de tipo no tienen ninguna sintaxis especial; Parecen moldes tipo puntero. Las definiciones de cierre requieren listas explícitas de variables capturadas.
Umka permite conversiones de tipos implícitas y admite parámetros predeterminados en declaraciones de funciones. Presenta el operador condicional ternario omitido deliberadamente en Go. No tiene sectores como tipos de datos separados. En cambio, admite matrices dinámicas, que se declaran como los sectores de Go y se inicializan llamando make() . Los receptores de métodos deben ser punteros. El modelo de subprocesos múltiples en Umka está inspirado en Lua y Wren en lugar de Go. Ofrece hilos livianos llamados fibras en lugar de gorutinas y canales. El mecanismo de recolección de basura se basa en el recuento de referencias, por lo que Umka necesita admitir punteros weak . Se está desarrollando soporte total para Unicode.
