janet
Janet 1.37.1
Janet es un lenguaje de programación para secuencias de comandos del sistema, automatización expresiva y extensión de programas escritos en C o C ++ con capacidades de secuencias de comandos de usuario.
Janet es un buen lenguaje de secuencias de comandos del sistema, o un idioma para incrustarse en otros programas. Es como Lua y Gnu Guile en ese sentido. Tiene una funcionalidad más incorporada y un lenguaje central más rico que Lua, pero más pequeño que GNU Guile o Python. Sin embargo, es mucho más fácil incrustar y puerto que Python o Guile.
Hay un REPL para probar el idioma, así como la capacidad de ejecutar archivos de script. Este programa de clientes está separado del tiempo de ejecución central, por lo que Janet puede integrarse en otros programas. Prueba a Janet en tu navegador en https://janet-lang.org.
Consulte el directorio de ejemplos para todos los programas de ejemplo proporcionados.
# 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 documentación también está disponible localmente en el repl. Use la macro (doc symbol-name) para obtener la documentación de API para los símbolos en la biblioteca central. Por ejemplo,
(doc apply)
Muestra documentación para la función apply .
Para obtener una lista de todos los enlaces en el entorno predeterminado, use la función (all-bindings) . También puede usar la macro (doc) sin argumentos si está en los símbolos replantes para mostrar.
Puede obtener la fuente en GitHub o SourceHut. Mientras que el repositorio de GitHub es el repositorio oficial, el espejo de SourceHut se mantiene activamente.
El Makefile no es portátil y requiere una marca con sabor a GNU.
cd somewhere/my/projects/janet
make
make test
make repl
make install
make install-jpm-git Obtenga más información sobre los objetivos de preparación disponibles ejecutando make help .
Las instrucciones de construcción de Haiku de 32 bits son las mismas que las instrucciones de compilación similares a UNIX, pero debe especificar un compilador alternativo, como gcc-x86 .
cd somewhere/my/projects/janet
make CC=gcc-x86
make test
make repl
make install
make install-jpm-git Las instrucciones de compilación de FreeBSD son las mismas que las instrucciones de compilación similares a UNIX, pero necesita gmake para compilar. Alternativamente, instale el paquete directamente con pkg install lang/janet .
cd somewhere/my/projects/janet
gmake
gmake test
gmake repl
gmake install
gmake install-jpm-git Las instrucciones de compilación de NetBSD son las mismas que las instrucciones de compilación de FreeBSD. Alternativamente, instale el paquete directamente con pkgin install janet .
cl.exe y link.exe necesita estar en su camino) y cd al directorio con Janet.build_win para compilar a Janet.build_win test para asegurarse de que todo funcione. Para construir un ejecutable de instalador .msi , además de los pasos anteriores, tendrá que:
build_win dist . Ahora deberías tener un .msi . Puede ejecutar build_win install para instalar .msi o ejecutar el archivo en sí.
Janet también tiene un archivo de compilación para Meson, un sistema de compilación multiplataforma. Aunque Meson tiene una dependencia de Python, Meson es un sistema de construcción muy completo que es quizás más conveniente y flexible para integrarse en las tuberías existentes. Meson también proporciona una integración IDE mucho mejor que los archivos de fabricación o lotes, así como soporte para compilación cruzada.
Para el impaciente, el edificio con Meson es el siguiente. Las opciones proporcionadas a meson setup a continuación emular el 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 puede ser pirateada con casi cualquier entorno que desee, pero para los amantes de IDE, Gnome Builder es probablemente la mejor opción, ya que tiene una excelente integración de Meson. También ofrece la finalización del código para la API C de Janet de inmediato, lo cual es muy útil para explorar. Sin embargo, VScode, VIM, Emacs y Atom tienen paquetes de sintaxis para el lenguaje Janet.
Si solo desea probar el idioma, no necesita instalar nada. En este caso, también puede mover el ejecutable janet donde quiera en su sistema y ejecutarlo. Sin embargo, para una configuración más completa, consulte la introducción para obtener más detalles.
Se lanza un replica cuando el binario se invoca sin argumentos. Pase la bandera -h para mostrar la información de uso. Los scripts individuales se pueden ejecutar con ./janet myscript.janet .
Si está buscando explorar, puede imprimir una lista de todas las macros, funciones y constantes disponibles ingresando el comando (all-bindings) en el repl.
$ 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 se instala, también puede ejecutar man janet para obtener información de uso.
Janet se puede integrar en un programa anfitrión muy fácilmente. La compilación normal creará un archivo build/janet.c , que es un solo archivo C que contiene toda la fuente a Janet. Este archivo, junto con src/include/janet.h y src/conf/janetconf.h , se puede arrastrar a cualquier proyecto C y compilarse en él. Janet debe compilarse con -std=c99 en la mayoría de los compiladores, y deberá estar vinculado a la biblioteca de matemáticas, -lm y el enlazador dinámico, -ldl , si uno quiere poder cargar módulos dinámicos. Si no hay necesidad de módulos dinámicos, agregue el define -DJANET_NO_DYNAMIC_MODULES a las opciones del compilador.
Consulte la sección de incrustación en el sitio web para obtener más información.
No dude en hacer preguntas y unirse a la discusión sobre la instancia de Janet Zulip
Es aproximadamente la misma velocidad que la mayoría de los idiomas interpretados sin un compilador JIT. Los bucles apretados y críticos probablemente deberían escribirse en C o C ++. Los programas tienden a ser un poco más rápidos de lo que serían en un lenguaje como Python debido al desánimo de la abstracción lenta orientada a objetos con muchas búsquedas de la mesa de hash y hacer explícito. Todos los valores están en caja en una representación de 8 bytes de forma predeterminada y se asignan en el montón, con la excepción de números, nils y booleanos. El motor PEG es un intérprete especializado que puede procesar de manera eficiente los datos de cadenas y buffer.
El GC es simple y se detiene el mundo, pero las perillas GC están expuestas en la biblioteca del núcleo y los hilos separados tienen montones y coleccionistas de basura aislados. Los datos que se comparten entre los subprocesos se cuentan con referencia.
Ymmv.
Puede existir, puede que no. Si desea proponer una característica de idioma importante, continúe y abra un problema, pero probablemente se cerrará como "no implementará". A menudo, tales características simplifican un lugar más simple a expensas de otros 5 al hacer que el idioma sea más complicado.
Actualmente no hay una especificación además de la documentación en https://janet-lang.org.
No. No hay células de contras aquí.
No. Es similar a Clojure superficialmente porque me gustan los LISP y me gustan la estética. Internamente, Janet no se parece en absoluto a Clojure, un esquema o al Lisp común.
No. Son matrices inmutables y tablas hash. No intente usarlos como los vectores y mapas de Clojure, sino que funcionan bien como teclas de mesa u otros identificadores.
Hasta cierto punto, sí. Sin embargo, no es el método recomendado de abstracción, y el rendimiento puede sufrir. Dicho esto, las tablas se pueden usar para hacer objetos mutables con herencia y polimorfismo, donde los métodos de objetos se implementan con palabras clave.
( def Car @{ :honk ( fn [self msg] ( print " car " self " goes " msg)) })
( def my-car ( table/setproto @{} Car))
( :honk my-car " Beep! " )Por lo general, una de las pocas razones:
Probablemente, si ese lenguaje tiene una buena interfaz con C., pero el programador puede necesitar hacer un trabajo adicional para asignar el modelo de memoria interna de Janet al del lenguaje vinculado. Janet también usa setjmp / longjmp para retornos no locales internamente. Este enfoque está en desgracia con muchos programadores ahora y no siempre juega bien con otros idiomas que tienen excepciones o sin viento.
Asegúrese de que su terminal admita los códigos de escape ANSI. La mayoría de los terminales modernos lo apoyarán, pero algunas terminales más antiguas, consolas de Windows o terminales integradas no lo harán. Si su terminal no admite los códigos de escape ANSI, ejecute el Bandero REPL con -n , que deshabilita la salida de color. También puede probar la bandera -s si se producen más problemas.
Janet lleva el nombre del ser artificial casi omnisciente y amigable en el buen lugar.
