[JAVA] Bibliothèque Kinx - REPL

Bibliothèque Kinx - REPL

introduction

** "Ressemble à JavaScript, le cerveau (contenu) est Ruby, (la stabilité est AC / DC)" ** Langage de script Kinx ). La langue est la bibliothèque. Alors, comment utiliser la bibliothèque.

Cette fois, c'est REPL.

Au début, j'étais pessimiste de ne pas pouvoir faire de REPL, mais j'aimerais vous présenter quelque chose qui fonctionne comme ça.

Parce que, si vous exécutez ʻevel` docilement, la zone de code gonfle uniformément chaque fois que vous l'exécutez, j'ai donc introduit Isolate / 78cf553b65e286ea39c4) est maintenant exécuté dans un contexte différent. Cela a considérablement amélioré l'utilisation de la mémoire.

Cependant, dans ce cas, le contexte est différent, donc ** les objets ne peuvent pas être passés **. J'ai réussi à gérer cela en passant la définition de classe et la définition de fonction à ʻeval` à chaque fois. Par conséquent,,,

  1. Il est devenu utilisable comme ordinateur.
  2. Les fonctions («function» / «native»), les classes et les modules peuvent être utilisés tels quels.
  3. Séquence d'échappement ** colorée même sous Windows **.
  4. J'ai également essayé de compléter les mots-clés avec la touche [TAB].
  5. Prise en charge de la largeur de l'Asie de l'Est. Les caractères UTF8 doivent également être écrits comme «[BS]» ou «[DEL]». Au moins le japonais est OK.

Il a été achevé dans la mesure où. Travaillé dur...

What is REPL?

"Qu'est-ce que REPL?", => Read-Eval-Print-Loop. Lisez l'entrée, ʻeval () `(évaluez), et affichez le résultat, et ainsi de suite.

Comment utiliser

méthode de départ

REPL est intégré au corps Kinx, similaire à SpecTest. Exécutez comme suit.

$ ./kinx --exec:repl
kinx[  0]> _

Les couleurs sont différentes ici car elles sont décrites dans Markdown, mais en réalité, les invites et les mots-clés sont mis en surbrillance et affichés en couleur (Windows et Linux).

Au début, j'ai essayé de mettre en place une image pour la comprendre, mais comme il s'agit toujours d'une démo, j'ai essayé de faire une démo. ** Veuillez féliciter quelqu'un **.

repl.gif

Vous pouvez voir que la saisie semi-automatique (complétion de mot-clé) fonctionne également correctement. Ce domaine est difficile à comprendre sans une démo. voir c'est croire.

échantillon

Pour commencer, essayez celui répertorié ici (Ruby qui commence dans 20 minutes) (https://www.ruby-lang.org/en/documentation/quickstart/). C'est bien, c'est bien fait à ce niveau.

$ ./kinx --exec:repl
kinx[  0]> "Hello, world"
=> "Hello, world"

kinx[  1]> System.println("Hello, world")
Hello, world
=> (null)

kinx[  2]> 3+2
=> 5

kinx[  3]> 3*2
=> 6

kinx[  4]> 3**2
=> 9

kinx[  5]> Math.sqrt(9)
=> 3

kinx[  6]> a = 3 ** 2
=> 9

kinx[  7]> b = 4 ** 2
=> 16

kinx[  8]> Math.sqrt(a+b)
=> 5

Ensuite, c'est le sujet principal.

Liste des commandes

Toutes les commandes commencent par «.».

commander Contenu
.help Voir aide
.quit Fin
.history Afficher l'historique des commandes
.vars Affichage de la liste des variables en cours
.delete name À partir de la liste actuelle des variablesnameSupprimer la variable
.showdef name Afficher les définitions de fonction et de classe
.cursor [*on/off] Activer l'affichage du curseur/OFF (ON par défaut)
.fullcode [on/*off] Mode d'entrée complet (OFF par défaut),.runNe pas exécuter tant que la commande n'est pas entrée
.time [on/*off] Mode de mesure du temps d'exécution (OFF par défaut), affichage du temps d'exécution après exécution
.run Utilisé pour exécuter en mode d'entrée complet

Veuillez noter que vous pouvez également quitter avec Ctrl-C.

Tapez .help pour obtenir l'aide suivante.

kinx[  0]> .help
Kinx REPL Command: * means by default
    .help               Display this help.
    .quit               Quit REPL.
    .history            Display command history.
    .vars               Display variables with its value.
    .delete name        Delete a variable by name.
    .showdef name       Display function/class definition by name.
    .cursor [*on|off]   Set to 'off' to make the cursor invisible.
    .fullcode [on|*off] Set to 'on', and the code will be executed by .run instead of immediately.
    .time [on|*off]     Set to 'on' to measure and display elapsed time.
    .run                Execute the code only with .fullcode 1.

REPL Operation:
    [^] Arrow up        Choose a previous command.
    [v] Arrow down      Choose a next command.
    [<] Arrow left      Move cursor to left.
    [>] Arrow right     Move cursor to right.
    Ctrl+[<]            Move cursor to left by word.
    Ctrl+[>]            Move cursor to right by word.
    [DEL]               Delete character on cursor.
    [BS]                Delete previous character.
    [TAB]               Move to the next tab stop, or auto-complete.

Déplacez le curseur vers la gauche et la droite avec les touches fléchées et déplacez mot par mot avec Ctrl + gauche et droite. Vous pouvez voir l'historique avec les touches haut et bas.

Editeur de ligne

Fondamentalement, l'éditeur de ligne accepte l'entrée et exécute immédiatement l'entrée.

kinx[  0]> 10 * 2
=> 20

Jugement multiligne automatique et indentation automatique

Il reconnaît automatiquement le «{» et le «}» correspondant et reste en mode éditeur jusqu'à ce que tout le bloc soit rempli. À ce stade, le retrait de 4 espaces est automatiquement ajouté en fonction du nombre de {.

Cependant, vous ne pouvez modifier que cette ligne, vous ne pouvez donc pas la modifier après avoir entré «[Entrée]».

Utilisez cette fonction pour définir «fonction», «classe», «module», etc.

kinx[  0]> function func(...a) {
	[  1]>     return a.reduce(&(r, e) => r + e);
	[  2]> }
=> function func

En faisant cela, vous pouvez utiliser la fonction comme suit.

kinx[  0]> function func(...a) {
    [  1]>     return a.reduce(&(r, e) => r + e);
    [  2]> }
=> function func

kinx[  3]> func(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
=> 55

Vous pouvez vérifier la fonction enregistrée comme suit.

kinx[  4]> .vars
function func(...a)

kinx[  5]> .showdef func
function func(...a) {
    return a.reduce(&(r, e) => r + e);
}

Saisie des mots clés

Les commandes et les mots-clés sont mis en mode de complétion en appuyant sur la touche [TAB]. Le mode de complétion complète une chaîne qui peut suivre la chaîne précédente en gris clair. Vous pouvez le vérifier dans la démo ci-dessus que j'ai essayé de faire. Cependant, il serait gênant de revenir en haut, donc je le posterai à nouveau (car je l'ai fait).

repl.gif

Si vous appuyez sur la touche [TAB] alors que ce candidat est affiché, vous pouvez passer au candidat suivant. À ce stade, les opérations clés suivantes sont effectuées.

Les candidats à l'achèvement changent en fonction du contexte du poste. Par exemple, si on estime qu'il s'agit d'un tableau de l'historique passé, la méthode de ʻArrayest également ajoutée en tant que candidat. De plus, si vous affectez un objet instancié avec l'opérateurnew` dans l'historique passé, cette méthode de classe etc. sera ajoutée en tant que candidat.

Vous pouvez voir une partie de cet exemple dans la démo présentée au début. Par exemple, «valeur» et «somme» sont affichés comme candidats pour «s» dans la dernière ligne.

Cela peut ne pas fonctionner correctement dans certains cas, mais si vous entrez une chaîne de caractères à mi-chemin et appuyez sur la touche [TAB], les candidats commençant par cette chaîne de caractères apparaîtront les uns après les autres, alors essayez différentes choses. S'il te plait donne moi.

De plus, «namespace» n'est pas pris en charge.

Liste des variables

La commande .vars affiche une liste des variables actuellement activées. Notez que les noms de fonctions et les noms de classes sont traités dans la même colonne comme des noms de variables, ils ne peuvent donc pas être enregistrés avec le même nom. Il sera remplacé par celui défini ultérieurement.

kinx[ 20]> .vars
class Sample(...a)
a = 10
b = 20
c = 30
d = 40
e = 50
f = 60
g = 70
sample = new Sample(a, b, c, d, e, f, g)

Supprimer des variables

Vous pouvez utiliser la commande .delete pour spécifier et supprimer les variables dont vous n'avez plus besoin. Si vous lui attribuez le même nom de variable, il sera écrasé, vous n'aurez donc peut-être pas beaucoup de chance de l'utiliser. Cependant, il y a des cas où "Compile Error" se produit lorsque l'ordre d'enregistrement des variables est incorrect en raison d'un écrasement répété, ou lorsque la dépendance des variables est incorrecte en raison de l'utilisation de la commande ".delete". Dans un tel cas, supprimez la variable étrange et réenregistrez-la pour qu'elle puisse fonctionner correctement.

Par exemple, il existe des cas où les variables ci-dessus sont enregistrées comme suit.

kinx[ 25]> .delete g      //Supprimer g
kinx[ 26]> sample.sum()   //L'instance d'échantillon est mal formée car g est parti.
=> Error: Compile Error.

kinx[ 27]> .vars
class Sample(...a)
a = 10
b = 20
c = 30
d = 40
e = 50
f = 60
sample = new Sample(a, b, c, d, e, f, g)  // <-Forme illégale car g ici est parti.

kinx[ 28]> g = 60         //Je veux enregistrer un nouveau g, mais il y a une erreur de compilation.
=> Error: Compile Error.

kinx[ 29> .delete sample  //L'instance mal formée interfère avec l'exécution, supprimez-la également.
kinx[ 30]> g = 60         //g peut être réenregistré.
=> 60

kinx[ 31]> var sample = new Sample(a, b, c, d, e, f, g)  //l'échantillon est également réenregistré.
=> (null)

kinx[ 32]> sample.sum() //Peut être exécuté en utilisant le nouveau g.
=> 270

Afficher les définitions de fonction, de classe et de module

Dans .vars, le nom de la fonction et le nom de la classe sont affichés dans l'affichage de liste, mais la définition n'est pas affichée. Vous pouvez ensuite utiliser la commande .showdef pour voir le contenu de la définition.

kinx[ 33]> .showdef Sample
class Sample(...a) {
    @value = a;
    public sum() {
        return @value.reduce(&(r, e) => r + e);
    }
}

Historique d'exécution

Vous pouvez vérifier l'historique d'exécution jusqu'à présent avec la commande .history. Par exemple, l'affichage suivant s'affiche (le numéro est différent de l'exemple ci-dessus, mais il s'agit d'un échantillon).

[  0]: class Sample(...a) {
[  1]:     @value = a;
[  2]:     public sum() {
[  3]:         return @value.reduce(&(r, e) => r + e);
[  4]:     }
[  5]: }
[  6]: a = new Sample(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
[  7]: .vars
[  8]: System.println(a.sum());
[  9]: a = 10
[ 10]: b = 20
[ 11]: c = 30
[ 12]: d = 40
[ 13]: e = 50
[ 14]: f = 60
[ 15]: g = 70
[ 16]: .vars
[ 17]: var sample = new Sample(a, b, c, d, e, f, g)
[ 18]: sample.sum()
[ 19]: .vars
[ 20]: sample.sum()
[ 21]: .showdef System
[ 22]: .showdef Sample
[ 23]: .vars
[ 24]: sample.sum()
[ 25]: .delete g
[ 26]: sample.sum()
[ 27]: .vars
[ 28]: g = 60
[ 29]: g = 60
[ 30]: .vars
[ 31]: .delete sample
[ 32]: g = 60
[ 33]: var sample = new Sample(a, b, c, d, e, f, g)
[ 34]: sample.sum()
[ 35]: .history

À partir de l'historique passé, vous pouvez également vous y référer en utilisant ! Comme indiqué ci-dessous.

kinx[ 36]> !34
=> "sample.sum();"
=> 270

Vous pouvez également sélectionner l'historique comme cible de rentrée en appuyant sur les touches de curseur haut et bas.

Mesure du temps d'exécution

Si vous définissez .time on, le résultat de l'exécution sera affiché. Etant donné que le résultat de la mesure est simplement le temps écoulé jusqu'à ce qu'il soit renvoyé comme "eval", il comprend divers frais généraux, mais ce sera un guide.

kinx[  0]> native fib(n) {
    [  1]>     return n if (n < 3);
    [  2]>     return fib(n-2) + fib(n-1);
    [  3]> }
=> native<int> fib

kinx[  4]> .time on
.time: on

kinx[  5]> fib(39)
=> 102334155

elapsed:    1.238 s

kinx[  6]> fib(34)
=> 9227465

elapsed:    0.131 s

Mode d'entrée complet

Avec .fullcode activé, il suffit d'appuyer sur la touche [Entrée] pour ne pas l'exécuter. Continuez à taper jusqu'à ce que vous saisissiez la commande .run. Cependant, pour le moment, en mode d'entrée complète, les variables et les définitions de classe ne sont pas ** enregistrées **. Tout sera une exécution unique de cette entrée uniquement.

kinx[  0]> .fullcode on
.fullcode: on

kinx[  1]> class Something() {
    [  2]>         public println(...a) {
    [  3]>                 System.println(a);
    [  4]>         }
    [  5]> }
    [  6]> s = new Something();
    [  7]> s.println(1, 2, 3, 4, 5, 6, 7, 8);
    [  8]> .run
[1, 2, 3, 4, 5, 6, 7, 8]
=> {"s":null}

kinx[  9]> .vars

kinx[ 10]>

Lire un fichier externe

Utilisez la commande .load pour importer un fichier externe. Les modules qui «utilisent» comme bibliothèques normales sont également chargés avec «.load». Vous pouvez activer la complétion de certains noms de méthodes en chargeant avec .load.

Par exemple, si vous utilisez DateTime, vous pouvez effectuer les opérations suivantes:

kinx[  0]> .load DateTime
=> Successfully loaded.

kinx[  1]> var dt = new DateTime(2020, 1, 1, 9, 30, 0)
=> (null)

kinx[  2]> .vars
dt = new DateTime(2020, 1, 1, 9, 30, 00)

kinx[  3]> dt.weekday()
=> 3

kinx[  4]> System.println(dt)
2020/01/01 09:30:00

Le nom du fichier de recherche est «nom spécifié.kx». La cible de recherche est effectuée dans l'ordre suivant. Vous pouvez donc également vous référer à la bibliothèque standard.

  1. Répertoire actuel
  2. Dans le dossier lib sous le dossier contenant le fichier exécutable kinx
  3. Dans le dossier lib / std sous le dossier contenant le fichier exécutable kinx
  4. Dans le dossier ../ lib vu du dossier contenant le fichier exécutable kinx
  5. Dans le dossier kinxlib sous le dossier contenant le fichier exécutable kinx
  6. Dans le dossier kinxlib / std sous le dossier contenant le fichier exécutable kinx

Excusez-moi, dans la version v0.9.2, j'obtiens une erreur avec .load DateTime sur Linux en raison d'un manque de considération (5 et 6 étaient nécessaires pour Linux mais pas encore implémentés). Spécifiez .load / usr / bin / kinxlib / std / DateTime comme solution de contournement. C'est dur. Je suis désolé.

Cependant, il existe actuellement deux mises en garde concernant DateTime. Il pourrait s'améliorer dans les versions futures.

East Asian Width

Prend en charge l'entrée en UTF8. Étant donné que le curseur est déplacé selon la définition de la largeur de l'Asie de l'Est, les caractères pleine largeur se déplacent avec cette largeur. Dans l'exemple suivant, ʻaiueo déplace également le curseur un caractère à la fois en pleine largeur, et Aiueo` déplace le curseur en demi-largeur. De plus, la suppression avec les touches «[DEL]» et «[BS]» fonctionne correctement.

$ ./kinx --exec:repl
kinx[  0]> a = "Aiueo Aiueo";
=> "Aiueo Aiueo"

kinx[  1]> System.println(a);
Aiueo Aiueo
=> (null)

kinx[  2]> a = "Ce genre d'aio";  //Sur "U"[DEL]Et sur "O"[BS]Presse.
=> "Ce genre d'aio"

kinx[  3]> System.println(a);
Ce genre d'aio
=> (null)

en conclusion

J'ai lu quelque part que le langage de programmation était ** à moitié sans REPL **, alors j'ai fait de mon mieux pour le faire (c'était difficile ...). Cela dit, il est encore en développement. Avec ceci comme première édition, j'aimerais apporter des améliorations si nécessaire.

Ce serait formidable si davantage de personnes pouvaient saisir cette opportunité. Nous avons également publié une version de version, donc si vous le souhaitez.

À la prochaine.

Recommended Posts

Bibliothèque Kinx - REPL
Bibliothèque Kinx --Obtenir
Bibliothèque Kinx --DateTime
Bibliothèque Kinx - Processus
Bibliothèque de compilateur Kinx Library-JIT
Bibliothèque de compilateur Kinx Library-JIT (édition supplémentaire)