umka lang
Umka 1.5
Umka est un langage de script intégrable à typage statique. Il combine la simplicité et la flexibilité nécessaires aux scripts avec une protection au moment de la compilation contre les erreurs de type. Son objectif est de suivre le principe Python Zen. Explicit vaut mieux qu'implicite de manière plus cohérente que ne le font généralement les langages typés dynamiquement.
Multiplication matricielle 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)
}
}
Alors que Go est un langage de programmation système compilé doté d'une bibliothèque d'exécution complexe et de gros binaires de sortie, Umka est un langage de script doté d'un interpréteur léger qui peut être facilement intégré à n'importe quelle application en tant que bibliothèque partagée.
Umka est très similaire à Go syntaxiquement. Cependant, à certains égards, c'est différent. Il contient des mots-clés plus courts : fn pour func , str pour string , in pour range . Pour une meilleure lisibilité, il nécessite un : entre les noms et types de variables dans les déclarations. Il ne suit pas la malheureuse tradition C du déréférencement de pointeur. Au lieu de *p , il utilise la syntaxe Pascal p^ . Le caractère * n'étant plus utilisé pour les pointeurs, il devient la marque d'export, comme dans Oberon, afin qu'un programmeur puisse librement utiliser les lettres majuscules/minuscules dans les identifiants selon son propre style. Les assertions de type n'ont pas de syntaxe particulière ; ils ressemblent à des moulages de type pointeur. Les définitions de fermeture nécessitent des listes explicites de variables capturées.
Umka autorise les conversions de type implicites et prend en charge les paramètres par défaut dans les déclarations de fonction. Il comporte l’opérateur conditionnel ternaire délibérément omis de Go. Il ne comporte pas de tranches en tant que types de données distincts. Au lieu de cela, il prend en charge les tableaux dynamiques, qui sont déclarés comme les tranches de Go et initialisés en appelant make() . Les récepteurs de méthodes doivent être des pointeurs. Le modèle multithreading d'Umka s'inspire de Lua et Wren plutôt que de Go. Il propose des fils légers appelés fibres au lieu de goroutines et de canaux. Le mécanisme de récupération de place est basé sur le comptage de références, Umka doit donc prendre en charge les pointeurs weak . La prise en charge complète d'Unicode est en cours de développement.
