janet
Janet 1.37.1
Janet est un langage de programmation pour les scripts système, l'automatisation expressive et l'extension des programmes écrits en C ou C ++ avec les capacités de script utilisateur.
Janet fait un bon langage de script système ou une langue pour intégrer d'autres programmes. C'est comme Lua et Gnu Guile à cet égard. Il a plus de fonctionnalités intégrées et un langage de base plus riche que Lua, mais plus petit que GNU GUile ou Python. Cependant, il est beaucoup plus facile à intégrer et à porter que Python ou Guile.
Il y a un REPT pour essayer la langue, ainsi que la possibilité d'exécuter des fichiers de script. Ce programme client est distinct de l'exécution de base, donc Janet peut être intégrée dans d'autres programmes. Essayez Janet dans votre navigateur sur https://janet-lang.org.
Voir le répertoire des exemples pour tous les exemples de programmes fournis.
# John Conway's Game of Life
( def- window
( seq [ x :range [ -1 2 ]
y :range [ -1 2 ]
:when ( not ( and ( zero? x ) ( zero? y )))]
[ x y ]))
( defn- neighbors
[[ x y ]]
( map ( fn [[ x1 y1 ]] [( + x x1 ) ( + y y1 )]) window ))
( defn tick
" Get the next state in the Game Of Life. "
[ state ]
( def cell-set ( frequencies state ))
( def neighbor-set ( frequencies ( mapcat neighbors state )))
( seq [ coord :keys neighbor-set
:let [ count ( get neighbor-set coord )]
:when ( or ( = count 3 ) ( and ( get cell-set coord ) ( = count 2 )))]
coord ))
( defn draw
" Draw cells in the game of life from (x1, y1) to (x2, y2) "
[ state x1 y1 x2 y2 ]
( def cellset @{})
( each cell state ( put cellset cell true ))
( loop [ x :range [ x1 ( + 1 x2 )]
:after ( print )
y :range [ y1 ( + 1 y2 )]]
( file/write stdout ( if ( get cellset [ x y ]) " X " " . " )))
( print ))
# Print the first 20 generations of a glider
( var *state* '[( 0 0 ) ( -1 0 ) ( 1 0 ) ( 1 1 ) ( 0 2 )])
( for i 0 20
( print " generation " i )
( draw *state* -7 -7 7 7 )
( set *state* ( tick *state* ))) # A simple TCP echo server using the built-in socket networking and event loop.
( defn handler
" Simple handler for connections. "
[ stream ]
( defer ( :close stream )
( def id ( gensym ))
( def b @" " )
( print " Connection " id " ! " )
( while ( :read stream 1024 b )
( printf " %v -> %v " id b )
( :write stream b )
( buffer/clear b ))
( printf " Done %v! " id )
( ev/sleep 0.5 )))
( net/server " 127.0.0.1 " " 8000 " handler ) # Use the FFI to popup a Windows message box - no C required
( ffi/context " user32.dll " )
( ffi/defbind MessageBoxA :int
[ w :ptr text :string cap :string typ :int ])
( MessageBoxA nil " Hello, World! " " Test " 0 ) La documentation est également disponible localement dans le REP. Utilisez la macro (doc symbol-name) pour obtenir la documentation de l'API pour les symboles dans la bibliothèque de base. Par exemple,
(doc apply)
Affiche la documentation de la fonction apply .
Pour obtenir une liste de toutes les liaisons dans l'environnement par défaut, utilisez la fonction (all-bindings) . Vous pouvez également utiliser la macro (doc) sans arguments si vous êtes dans le REP pour afficher les symboles liés.
Vous pouvez obtenir la source sur GitHub ou SourceHut. Alors que le repo GitHub est le dépôt officiel, le miroir Sourcehut est activement maintenu.
Le makefile n'est pas portable et nécessite une marque à saveur de GNU.
cd somewhere/my/projects/janet
make
make test
make repl
make install
make install-jpm-git En savoir plus sur les cibles disponibles en cours d'exécution make help .
Les instructions de construction haiku 32 bits sont les mêmes que les instructions de construction de type UNIX, mais vous devez spécifier un compilateur alternatif, tel que gcc-x86 .
cd somewhere/my/projects/janet
make CC=gcc-x86
make test
make repl
make install
make install-jpm-git Les instructions de construction FreeBSD sont les mêmes que les instructions de construction de type Unix, mais vous avez besoin de compiler gmake . Alternativement, installez le package directement avec pkg install lang/janet .
cd somewhere/my/projects/janet
gmake
gmake test
gmake repl
gmake install
gmake install-jpm-git Les instructions de construction NetBSD sont les mêmes que les instructions de construction FreeBSD. Alternativement, installez le package directement avec pkgin install janet .
cl.exe et link.exe doivent être sur votre chemin) et cd vers le répertoire avec Janet.build_win pour compiler Janet.build_win test pour vous assurer que tout fonctionne. Pour créer un exécutable d'installation .msi , en plus des étapes ci-dessus, vous devrez:
build_win dist . Maintenant, vous devriez avoir un .msi . Vous pouvez exécuter build_win install pour installer le .msi , ou exécuter le fichier lui-même.
Janet a également un fichier de construction pour Meson, un système de construction multiplateforme. Bien que Meson ait une dépendance Python, Meson est un système de construction très complet qui est peut-être plus pratique et flexible pour l'intégration dans les pipelines existants. Meson fournit également une bien meilleure intégration IDE que les fichiers de fabrication ou de lots, ainsi que la prise en charge de la compilation croisée.
Pour l'impatient, le bâtiment avec Meson est le suivant. Les options fournies à meson setup ci-dessous imitent Makefile de Janet.
git clone https://github.com/janet-lang/janet.git
cd janet
meson setup build
--buildtype release
--optimization 2
--libdir /usr/local/lib
-Dgit_hash= $( git log --pretty=format: ' %h ' -n 1 )
ninja -C build
# Run the binary
build/janet
# Installation
ninja -C build installJanet peut être piratée avec à peu près tous les environnements que vous aimez, mais pour les amateurs d'IDE, Gnome Builder est probablement la meilleure option, car elle a une excellente intégration de Meson. Il offre également l'achèvement du code pour l'API C de Janet dès la sortie de la boîte, ce qui est très utile pour explorer. VSCODE, VIM, EMACS et ATOM ont chacun des packages de syntaxe pour la langue Janet.
Si vous voulez juste essayer la langue, vous n'avez rien à installer. Dans ce cas, vous pouvez également déplacer l'exécutable janet où vous voulez sur votre système et l'exécuter. Cependant, pour une configuration plus complète, veuillez consulter l'introduction pour plus de détails.
Un REP est lancé lorsque le binaire est invoqué sans arguments. Passez le drapeau -h pour afficher les informations d'utilisation. Les scripts individuels peuvent être exécutés avec ./janet myscript.janet .
Si vous cherchez à explorer, vous pouvez imprimer une liste de toutes les macros, fonctions et constantes disponibles en entrant la commande (all-bindings) dans le REP.
$ janet
Janet 1.7.1-dev-951e10f Copyright (C) 2017-2020 Calvin Rose
janet:1:> (+ 1 2 3)
6
janet:2:> (print "Hello, World!")
Hello, World!
nil
janet:3:> (os/exit)
$ janet -h
usage: janet [options] script args...
Options are:
-h : Show this help
-v : Print the version string
-s : Use raw stdin instead of getline like functionality
-e code : Execute a string of janet
-E code arguments... : Evaluate an expression as a short-fn with arguments
-d : Set the debug flag in the REPL
-r : Enter the REPL after running all scripts
-R : Disables loading profile.janet when JANET_PROFILE is present
-p : Keep on executing if there is a top-level error (persistent)
-q : Hide logo (quiet)
-k : Compile scripts but do not execute (flycheck)
-m syspath : Set system path for loading global modules
-c source output : Compile janet source code into an image
-i : Load the script argument as an image file instead of source code
-n : Disable ANSI color output in the REPL
-l lib : Use a module before processing more arguments
-w level : Set the lint warning level - default is "normal"
-x level : Set the lint error level - default is "none"
-- : Stop handling options
Si vous êtes installé, vous pouvez également exécuter man janet pour obtenir des informations d'utilisation.
Janet peut être intégrée très facilement dans un programme d'hôtes. La version normale créera une build/janet.c , qui est un seul fichier C qui contient toute la source de Janet. Ce fichier, ainsi que src/include/janet.h et src/conf/janetconf.h , peuvent être traînés dans n'importe quel projet C et compilé. Janet doit être compilé avec -std=c99 sur la plupart des compilateurs et devra être lié à la bibliothèque mathématique, -lm , et le linker dynamique, -ldl , si l'on veut pouvoir charger des modules dynamiques. S'il n'y a pas besoin de modules dynamiques, ajoutez le define -DJANET_NO_DYNAMIC_MODULES aux options du compilateur.
Consultez la section d'incorporation sur le site Web pour plus d'informations.
N'hésitez pas à poser des questions et à rejoindre la discussion sur l'instance de Janet Zulip
C'est à peu près la même vitesse que la plupart des langues interprétées sans compilateur JIT. Les boucles critiques serrées doivent probablement être écrites en C ou C ++. Les programmes ont tendance à être un peu plus rapides qu'ils ne le seraient dans une langue comme Python en raison du découragement de l'abstraction lente axée sur les objets avec beaucoup de recherches sur la table de hachage et rendant la liaison tardive explicite. Toutes les valeurs sont en boîte dans une représentation de 8 octets par défaut et allouées sur le tas, à l'exception des nombres, des nils et des booléens. Le moteur PEG est un interprète spécialisé qui peut traiter efficacement les données de chaîne et de tampon.
Le GC est simple et stop-the-world, mais les boutons GC sont exposés dans la bibliothèque de base et les fils séparés ont des tas isolés et des collectionneurs à ordures. Les données partagées entre les threads sont comptées par référence.
Ymmv.
Cela peut exister, il peut ne pas. Si vous souhaitez proposer une fonctionnalité linguistique majeure, allez-y et ouvrez un problème, mais il sera probablement fermé comme "ne mettra pas en œuvre". Souvent, de telles fonctionnalités rendent une utilisation plus simple au détriment de 5 autres en rendant la langue plus compliquée.
Il n'y a actuellement pas de spécifications en plus de la documentation sur https://janet-lang.org.
Non. Il n'y a pas de cellules contre ici.
Non. C'est similaire à Clojure superficiellement parce que j'aime les LISP et j'aime l'esthétique. En interne, Janet n'est pas du tout comme Clojure, Scheme ou Lisp commun.
Non. Ce sont des tableaux immuables et des tables de hachage. N'essayez pas de les utiliser comme les vecteurs et les cartes de Clojure, mais ils fonctionnent bien comme des clés de table ou d'autres identifiants.
Dans une certaine mesure, oui. Cependant, ce n'est pas la méthode d'abstraction recommandée et les performances peuvent en souffrir. Cela dit, les tableaux peuvent être utilisés pour fabriquer des objets mutables avec l'héritage et le polymorphisme, où les méthodes d'objets sont implémentées avec des mots clés.
( def Car @{ :honk ( fn [self msg] ( print " car " self " goes " msg)) })
( def my-car ( table/setproto @{} Car))
( :honk my-car " Beep! " )Habituellement, une des quelques raisons:
Probablement, si ce langage a une bonne interface avec C. mais le programmeur peut avoir besoin de faire un travail supplémentaire pour cartographier le modèle de mémoire interne de Janet à celui de la langue liée. Janet utilise également setjmp / longjmp pour les rendements non locaux en interne. Cette approche est en disgrâce avec de nombreux programmeurs maintenant et ne joue pas toujours bien avec d'autres langages qui ont des exceptions ou un sous-essai de pile.
Assurez-vous que votre terminal prend en charge les codes d'échappement ANSI. La plupart des terminaux modernes les soutiendront, mais certains terminaux plus anciens, consoles de fenêtres ou terminaux intégrés ne le feront pas. Si votre terminal ne prend pas en charge les codes d'échappement ANSI, exécutez le REP avec l'indicateur -n , qui désactive la sortie de la couleur. Vous pouvez également essayer le drapeau -s si d'autres problèmes s'ensuivent.
Janet porte le nom de l'être artificiel presque omniscient et amical dans le bon endroit.
