janet
Janet 1.37.1
Janet é uma linguagem de programação para scripts do sistema, automação expressiva e programas de extensão escritos em C ou C ++ com recursos de script de usuário.
Janet cria uma boa linguagem de script do sistema, ou um idioma para incorporar em outros programas. É como Lua e Gnu Guile nesse sentido. Possui mais funcionalidades embutidas e uma linguagem central mais rica que o Lua, mas menor que GNU Guile ou Python. No entanto, é muito mais fácil incorporar e portar do que Python ou dolo.
Há um repl para experimentar o idioma, bem como a capacidade de executar arquivos de script. Este programa de clientes é separado do tempo de execução principal, para que Janet possa ser incorporada em outros programas. Experimente Janet em seu navegador em https://janet-lang.org.
Consulte o Diretório Exemplos para todos os programas de exemplo fornecidos.
# 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 ) A documentação também está disponível localmente no REPL. Use a macro (doc symbol-name) para obter documentação da API para símbolos na biblioteca principal. Por exemplo,
(doc apply)
Mostra documentação para a função apply .
Para obter uma lista de todas as ligações no ambiente padrão, use a função (all-bindings) . Você também pode usar a macro (doc) sem argumentos se estiver no repl para mostrar símbolos vinculados.
Você pode obter a fonte no Github ou SourceHut. Enquanto o repositório do Github é o repositório oficial, o espelho da fonte é mantido ativamente.
O Makefile não é portável e requer uma marca com sabor GNU.
cd somewhere/my/projects/janet
make
make test
make repl
make install
make install-jpm-git Saiba mais sobre os alvos disponíveis, make help .
As instruções de construção do Haiku de 32 bits são as mesmas que as instruções de construção do tipo UNIX, mas você precisa especificar um compilador alternativo, como gcc-x86 .
cd somewhere/my/projects/janet
make CC=gcc-x86
make test
make repl
make install
make install-jpm-git As instruções de construção do FreeBSD são as mesmas que as instruções de construção do tipo UNIX, mas você precisa de gmake . Como alternativa, instale o pacote diretamente com pkg install lang/janet .
cd somewhere/my/projects/janet
gmake
gmake test
gmake repl
gmake install
gmake install-jpm-git As instruções de construção do NetBSD são as mesmas que as instruções de construção do FreeBSD. Como alternativa, instale o pacote diretamente com pkgin install janet .
cl.exe e link.exe precisam estar no seu caminho) e cd para o diretório com Janet.build_win para compilar Janet.build_win test para garantir que tudo esteja funcionando. Para construir um .msi instalador executável, além das etapas acima, você terá que::
build_win dist . Agora você deve ter um .msi . Você pode executar build_win install para instalar o .msi ou executar o próprio arquivo.
Janet também possui um arquivo de compilação para o Meson, um sistema de construção cruzado. Embora o Meson tenha uma dependência do Python, o Meson é um sistema de construção muito completo que talvez seja mais conveniente e flexível para se integrar aos pipelines existentes. O Meson também fornece integração muito melhor do IDE do que arquivos de fabricação ou lote, bem como suporte para compilação cruzada.
Para o impaciente, a construção com Meson é a seguinte. As opções fornecidas à meson setup abaixo imitam o 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 pode ser invadida com praticamente qualquer ambiente que você quiser, mas para os amantes do IDE, o Gnome Builder é provavelmente a melhor opção, pois possui uma excelente integração de Meson. Ele também oferece a conclusão do código para a API C de Janet imediatamente, o que é muito útil para explorar. No entanto, o VSCODE, VIM, EMACS e Atom possuem pacotes de sintaxe para o idioma Janet.
Se você deseja apenas experimentar o idioma, não precisa instalar nada. Nesse caso, você também pode mover o executável janet para onde quiser no seu sistema e executá -lo. No entanto, para uma configuração mais completa, consulte a introdução para obter mais detalhes.
Um repl é lançado quando o binário é invocado sem argumentos. Passe o sinalizador -h para exibir as informações de uso. Scripts individuais podem ser executados com ./janet myscript.janet .
Se você deseja explorar, pode imprimir uma lista de todas as macros, funções e constantes disponíveis, inserindo o comando (all-bindings) no 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
Se instalado, você também pode executar man janet para obter informações de uso.
Janet pode ser incorporada em um programa host com muita facilidade. A compilação normal criará uma build/janet.c , que é um único arquivo C que contém toda a fonte para Janet. Este arquivo, juntamente com src/include/janet.h e src/conf/janetconf.h , pode ser arrastado para qualquer projeto C e compilado nele. Janet deve ser compilado com -std=c99 na maioria dos compiladores e precisará estar vinculado à biblioteca de matemática, -lm e ao ligante dinâmico, -ldl , se alguém quiser carregar módulos dinâmicos. Se não houver necessidade de módulos dinâmicos, adicione o define -DJANET_NO_DYNAMIC_MODULES às opções do compilador.
Consulte a seção de incorporação no site para obter mais informações.
Sinta -se à vontade para fazer perguntas e participar da discussão sobre a instância de Janet Zulip
É aproximadamente a mesma velocidade que a maioria dos idiomas interpretados sem um compilador JIT. Os loops críticos apertados provavelmente devem ser escritos em C ou C ++. Os programas tendem a ser um pouco mais rápidos do que em um idioma como o Python devido ao desânimo da abstração lenta orientada a objetos com muitas pesquisas de mesa de hash e explícitas explícitas de ligação tardia. Todos os valores são encaixotados em uma representação de 8 bytes por padrão e alocados na pilha, com exceção de números, nilos e booleanos. O mecanismo PEG é um intérprete especializado que pode processar eficientemente dados de string e buffer.
O GC é simples e parado com o mundo, mas os botões GC são expostos na biblioteca principal e os threads separados têm montes isolados e coletores de lixo. Os dados compartilhados entre os threads são contados de referência.
Ymmv.
Pode existir, pode não. Se você deseja propor um recurso de idioma importante, vá em frente e abra um problema, mas provavelmente será fechado como "não implementará". Freqüentemente, esses recursos tornam uma base de uso mais simples às custas de outras 5, tornando o idioma mais complicado.
Atualmente, não existe uma especificação além da documentação em https://janet-lang.org.
Não. Não há células contras aqui.
Não. É semelhante ao Clojure superficialmente porque eu gosto de Lisps e gosto da estética. Internamente, Janet não é nada como clojure, esquema ou lisp comum.
Não. São matrizes imutáveis e mesas de hash. Não tente usá -los como os vetores e mapas de Clojure; em vez disso, eles funcionam bem como chaves de mesa ou outros identificadores.
Até certo ponto, sim. No entanto, não é o método recomendado de abstração, e o desempenho pode sofrer. Dito isto, as tabelas podem ser usadas para criar objetos mutáveis com herança e polimorfismo, onde os métodos de objeto são implementados com palavras -chave.
( def Car @{ :honk ( fn [self msg] ( print " car " self " goes " msg)) })
( def my-car ( table/setproto @{} Car))
( :honk my-car " Beep! " )Geralmente, um dos poucos motivos:
Provavelmente, se esse idioma tiver uma boa interface com C., mas o programador pode precisar fazer algum trabalho extra para mapear o modelo de memória interna de Janet para o da linguagem ligada. Janet também usa setjmp / longjmp para retornos não locais internamente. Essa abordagem está em desuso com muitos programadores agora e nem sempre joga bem com outros idiomas que têm exceções ou empilhamento.
Verifique se o seu terminal suporta códigos de escape da ANSI. A maioria dos terminais modernos os suportará, mas alguns terminais mais antigos, consoles do Windows ou terminais incorporados não o farão. Se o seu terminal não suportar códigos de escape da ANSI, execute o repl com o sinalizador -n , que desativa a saída de cores. Você também pode experimentar o sinalizador -s se surgirem mais problemas.
Janet recebeu o nome do estar artificial quase onisciente e amigável no bom lugar.
