[PYTHON] Langage de script KINX (introduction)

introduction

J'ai écrit ce genre de chose avant, mais en tant qu'artisan, j'ai été tenté de fabriquer mes propres outils.

• https://github.com/Kray-G/kinx
  • Looks like JavaScript, feels like Ruby, and it is the script language fitting in C programmers.

Eh bien, même si vous dites non, c'est quelque chose que vous pouvez trouver quelque part (je ne le dirai pas ici), mais je suis seul même si je suis satisfait de moi-même, alors laissons une piste d'explication. (Je mettrai à jour cet article un par un au fur et à mesure que je l'ajouterai à la table des matières)

Lorsque je l'ai posté régulièrement, le nombre d'articles a considérablement augmenté.

quelle?

Un langage de script qui hérite de la syntaxe traditionnelle de la série C familière à la main. Le but est "** ressemble à JavaScript **, ** cerveau (contenu) est Ruby **, ** la stabilité est AC / DC (?) **".

Je n'ai pas encore les bibliothèques et les méthodes de base, donc ce n'est pas encore pratique, mais la partie de base du langage fonctionne presque.

Cela ressemble à du JavaScript

Un bon adulte, pas un enfant.

JavaScript est le langage de script le plus performant de la famille C. Cependant, ce n'est pas bon pour le bureau. node.js est pratique mais trop lourd et trop décalé dans son comportement.

D'un autre côté, j'aime l'idée de Ruby, mais je suis réticent à utiliser la syntaxe qui «end» est perceptible. Les mots-clés ordinaires sont généralement enterrés ...

Le cerveau (contenu) est Ruby

Cela dit, je ne déteste pas la pensée de type Ruby. Oui, c'est juste une question d'apparence. Ensuite, ce devrait être Ruby qui a l'air différent.

Un sentiment de stabilité est AC / DC

Imitons l'endroit où il n'y a pas de flou.

Origine du nom

Je ne peux pas le toucher profondément (?), Mais le chef-d'œuvre "KING'S" de Red Warriors Disons simplement que ça remonte à KING'S).

Pour le moment, il est devenu "KINX", donc l'origine est "[You Really Got Me](https: /), qui est célèbre pour ([VAN HALEN](https://ja.wikipedia.org/wiki/Van Halen)). /ja.wikipedia.org/wiki/You Really Gut Me) "original) Kinks" Je réfléchis aussi aux choses.

échantillon

Des explications détaillées seront livrées dans une série. Je me fiche de la demande.

Si vous voulez connaître les spécifications détaillées dès maintenant ... "ici" prière de se référer à.

fibonacci

fib.kx

function fib(n) {
    if (n < 3) return n;
    return fib(n-2) + fib(n-1);
}

System.println(fib($$[1].toInt()));

La première chose à écrire est une référence. Cela ressemble à du JavaScript.

À cette époque, Ruby alimentait tout le monde en disant: "La vitesse n'est pas le but, n'est-ce pas amusant?" En regardant la quantité de gonflement depuis la sortie de YARV, j'ai vu que la position était exactement "raisins aigres" ... (Non, j'aime Ruby, sauf pour son apparence)

Comparons-le tout de suite. Au fait, j'aimerais le voir apparaître en Python, que Ruby considère comme un rival. Par rapport à ce domaine, vous pouvez estimer votre capacité. Le code source est le suivant. Python3 est plus lent que Python2, donc 2

fib.rb

def fib(n)
  if n < 3
    return n;
  else
    return fib(n-2) + fib(n-1);
  end
end

puts fib(ARGV[0].to_i)

fib.py

import sys

def fib(n):
    if n < 3:
        return n
    else:
        return fib(n-1) + fib(n-2)

print fib(int(sys.argv[1]))

résultat

Tout d'abord, l'affichage de la version.

$ ruby --version
ruby 2.5.1p57 (2018-03-29 revision 63029) [x86-64-linux-gnu]
$ python --version
Python 2.7.15+

Et le résultat. L'unité est ** "secondes" **. ʻUser avec la commande time`, par ordre croissant de temps. Le temps le plus rapide que j'ai fait environ 5 fois.

Ruby est super rapide. Slow Slow est juste une histoire du passé. Il semble plutôt que ce soit dans la catégorie rapide.

J'ai battu Python, donc c'est comme ça. Je ne pense pas devenir un roi de la vitesse, alors définissons-la comme une plage acceptable si c'est une vitesse pratique. Cependant, Kinx a en fait un mouvement spécial appelé «natif». Pour être honnête, je ne sais pas à quel point c'est utile dans la pratique, mais j'en ai senti la possibilité et je l'ai mis en pratique. Le code source est ci-dessous. Je viens de changer «function» en «native».

nfib.kx

native fib(n) {
    if (n < 3) return n;
    return fib(n-2) + fib(n-1);
}

System.println(fib($$[1].toInt()));

Ajoutons au tableau ci-dessus pour montrer les résultats de la façon dont cette modification mineure nous affectera.

Kita.

Comme son nom l'indique, une fonction avec le mot-clé native est compilée nativement en code de langage machine et exécutée par JIT. C'est rapide, n'est-ce pas? Cependant, le code d'assemblage de sortie n'est pas optimisé ou attribué aux registres, il n'est donc pas beau du tout. Je ne sais pas si c'est pratique car il y a diverses restrictions. J'y reviendrai plus tard, mais je n'y toucherai pas aujourd'hui. Voir "ici" pour plus d'informations.

Autres caractéristiques

Je n'expliquerai pas en détail cette fois car ce sera une série, mais je ne montrerai que ce que vous pouvez faire.

Base de prototype

Basé sur des prototypes comme JavaScript. Cependant, «proto» n'existe pas. La méthode est directement liée à la propriété de l'objet. Si vous souhaitez le remplacer, écrasez-le simplement. Le mot-clé class est préparé et la classe peut être définie. Comme ça.

class ClassName {

    var privateVar_;

    private initialize() {
        privateVar_ = 0;
        this.publicVar = 0;
    }

    /* private method */
    private method1() { /* ... */ }
    private method2() { /* ... */ }

    /* public method */
    public method3() { /* ... */ }
    public method4() { /* ... */ }

}

var obj = new ClassName();

Collecte des ordures

Une marque et un balayage Stop The World simples et clairs. Je n'ai pas de problèmes pour l'instant (je ne l'ai pas tellement utilisé), donc il n'y a pas de problème. S'il y a un problème, pensez-y alors.

fermeture

Les objets fonction ont une portée lexicale et peuvent réaliser des fermetures. Si cela devient JavaScript (mais pas), cela fonctionne naturellement. Comme ça.

function newCounter() {
    var i = 0;          // a lexical variable.

    return function() { // an anonymous function.
        ++i;            // a reference to a lexical variable.
        return i;
    };
}

var c1 = newCounter();
System.println(c1()); // 1
System.println(c1()); // 2
System.println(c1()); // 3
System.println(c1()); // 4
System.println(c1()); // 5

lambda

Les objets de fonction anonymes peuvent être écrits de manière concise. La fonction de flèche a été introduite dans ES6, mais elle n'est pas exactement la même et nécessite un & au début. Pourquoi demandes-tu? Je ne pouvais pas bien écrire avec Yacc. Je ne peux pas résoudre le conflit (désolé). Comme ça.

function calc(x, y, func) {
    return func(x, y);
}

System.println("add = " + calc(10, 2, &(a, b) => a + b));
System.println("sub = " + calc(10, 2, &(a, b) => a - b));
System.println("mul = " + calc(10, 2, &(a, b) => a * b));
System.println("div = " + calc(10, 2, &(a, b) => a / b));
// add = 12
// sub = 8
// mul = 20
// div = 5

Fibre

En fait, je n'ai jamais utilisé cette fonction. C'est juste dans Ruby, et cela semble pratique, alors je l'ai implémenté. Je l'ai essayé avec un léger sentiment que je pouvais le faire de cette façon, et cela a très bien fonctionné. Cependant, comme l'état de la pile n'est pas conservé pendant «yield», «yield» n'est valide que comme une seule instruction d'expression. La substitution est possible. Cela signifie que vous ne pouvez pas incorporer yield directement comme argument de fonction, mais des expressions comme ʻa = yield 10; sont OK. A ce moment, ʻa est livré avec un tableau d'arguments de l'appelant. Un exemple simple ressemble à ceci.

var fiber = new Fiber(function() {
    System.println("fiber 1");
    yield;
    System.println("fiber 2");
});

System.println("main 1");
fiber.resume();
System.println("main 2");
fiber.resume();
System.println("main 3");
// main 1
// fiber 1
// main 2
// fiber 2
// main 3

Opérateur de propagation

L'opérateur spread (reste) introduit dans ES6 (n'est-ce pas?). Oui, je voulais ça. Super pratique. Il existe différentes utilisations, mais cela ressemble à ceci.

function sample(a1, a2, ...a3) {
    // a1 = 1
    // a2 = 2
    // a3 = [3, 4, 5]
}

sample(1, 2, 3, 4, 5);

finalement

Merci d'avoir lu jusqu'ici. Eh bien, si vous en avez envie, veuillez l'utiliser. Je ne pense pas qu'il y ait encore d'utilisation pratique.

Les contributions sont les bienvenues. Le moyen le plus simple de contribuer est de cliquer sur le "★". C'est encore peu, mais si vous l'augmentez, vous serez plus motivé. J'espère qu'il y en aura plus ★.

Ici (https://github.com/Kray-G/kinx).