¿Está construyendo una aplicación Clojure con una interfaz de línea de comandos?

Acabo de empezar con Clojure (procedente de Ruby) y me gustaría crear una pequeña aplicación con una interfaz de línea de comandos. ¿Cómo manejo la entrada / salida a una CL?

Noté que hay una línea de comandos clojure.contrib.com, pero la documentación es escasa.

http://github.com/richhickey/clojure-contrib/blob/ffa868411cda6c617105b52b4f6f9e0f37ee8c24/src/clojure/contrib/command_line.clj

A continuación, se muestra un ejemplo del uso de su with-command-linemacro. El siguiente código especifica una clase trivial con un método principal que no hace más que imprimir los valores de sus argumentos de línea de comando.

(ns cmd-line-demo
  (:gen-class)
  (:use clojure.contrib.command-line))

(defn -main [& args]
  (with-command-line args
      "Command line demo"
      [[foo "This is the description for foo" 1]
       [bar "This is the description for bar" 2]
       [boolean? b? "This is a boolean flag."]
       remaining]
    (println "foo: " foo)
    (println "bar: " bar)
    (println "boolean?: " boolean?)
    (println "remaining: " remaining)))

Compile la clase en el REPL:

user> (compile 'cmd-line-demo)
cmd-line-demo

Uso de ejemplo

1) La ejecución sin argumentos de línea de comando hará que se muestre la información de ayuda. La información de ayuda también se puede mostrar con banderas --helpo -h. Tenga en cuenta que la información de ayuda se genera automáticamente desde su cmdspec.

$ java -classpath . cmd_line_demo
Command line demo
Options
  --foo <arg>    This is the description for foo  [default 1]
  --bar <arg>    This is the description for bar  [default 2]
  --boolean, -b  This is a boolean flag.  

2) Los argumentos no especificados reciben el valor predeterminado como se especifica en el enlace cmdspec. Por ejemplo, bartiene un valor predeterminado de 2.

$ java -classpath . cmd_line_demo --foo "changed value"
foo:  changed value
bar:  2
boolean?:  nil
remaining:  []

3) Las banderas booleanas se indican con el sufijo "?" en el cmdspec. Tenga en cuenta que la bandera en sí no incluye el "?" como parte de su nombre.

$ java -classpath . cmd_line_demo -boolean
foo:  1
bar:  2
boolean?:  true
remaining:  []

4) También tenga en cuenta que puede especificar alias de bandera especificando varios símbolos en cmdspec. He hecho esto con las banderas boolean?y b?.

5) Finalmente, he especificado que remainingcapture todos los argumentos restantes sin indicadores asociados.

$ java -classpath . cmd_line_demo -foo test file1 file2 file3
foo:  test
bar:  2
boolean?:  nil
remaining:  [file1 file2 file3]

La antigua línea clojure.contrib.command-line ha sido reemplazada con tools.cli.

https://github.com/clojure/tools.cli

tools.cli solía llamarse clargon. A continuación se muestran dos publicaciones de blog que brindan ejemplos del uso de tools.cli (simplemente reemplace cualquier referencia a clargon con tools.cli. Las publicaciones están desactualizadas).

Esto muestra algunas formas de métodos, incluido el antiguo clojure.contrib.command-line

Publicación centrada en Clargon por el autor original

Me gustaría agregar que puedes hacer

(apply -main *command-line-args*)

debajo del (defn -main ...)para que funcione en modo interpretado.

Mucho tiempo después de que se planteó la pregunta, puedo sugerir el uso de docoptbibliotecas cuando se trata de crear una interfaz CLI. Hay uno para Clojure -docopt.clj

docopt se basa en convenciones que se han utilizado durante décadas en mensajes de ayuda y páginas de manual para la descripción de la interfaz del programa. La descripción de la interfaz en docopt es un mensaje de ayuda, pero formalizado

Entonces puedes declarar su interfaz y documentarla al mismo tiempo, es increíble y fácil de hacer.

Para más detalles recomiendo consultar http://docopt.org/

También hay una aplicación en línea para verificar su interfaz http://try.docopt.org/

Y finalmente aquí está mi ejemplo de cómo se puede usar la biblioteca Clojure.

Tal vez pruebe con jark. Jark es una herramienta para ejecutar programas clojure en una JVM persistente. Tiene algunas utilidades de línea de comandos útiles.

https://clojars.org/jark

jark ns load file.clj
jark <namespace>.<function> <args>
jark if cli-json <namespace><function> args