Crie um executável para um programa de esquema com argumentos

Question

Eu tenho um programa scheme que é executado usando o comando ; (primes<= n) para me dar todos os primos com menos de n

Por exemplo, ; (primes<= 200) me dá todos os primos com menos de 200

Como eu crio um executável no Linux para o programa abaixo levando n como um argumento

--------- Programa Scheme ------------------------------------ ------------

    #lang racket

(define  (interval-list m n)
  (if (> m n)
      '()
      (cons m (interval-list (+ 1 m) n))))
(define (sieve l)
  (define (remove-multiples n l)
    (if (null? l)
         '()
         (if  (= (modulo (car l) n) 0)      ; division test
              (remove-multiples n (cdr l))
              (cons (car l)
                    (remove-multiples n (cdr l))))))
  (if (null? l)
      '()
      (cons (car l)
             (sieve (remove-multiples (car l) (cdr l))))))
(define (primes<= n)
  (sieve (interval-list 2 n)))

O programa acima é executado como (primos < = 100) imprime todos os primos menores que 100

    

Answer 1

Acredito que você queira verificar a documentação do seu sistema Scheme para:

• compilação para o executável nativo e
• passando argumentos da linha de comando do shell do SO

Por exemplo, se você estivesse usando o Esquema MIT / GNU , eu o encaminharia para:

• Compilando Programas
• Comandos personalizados opções de linha

Se você tiver flexibilidade sobre qual interpretador de Scheme você usa, o MIT / GNU Scheme é portado para muitos sistemas operacionais, incluindo o Linux, então funcionaria bem com o exemplo acima.

    

Answer 2

Para transformar este programa Scheme em um arquivo que executa um interpretador Scheme, inicie-o com um shebang e torne-a executável ( chmod +x /path/to/program ). Uma linha shebang é a primeira linha de um arquivo executável e começa com #! seguido pelo caminho completo para o interpretador. Desde que você está usando o Racket:

#!/usr/bin/racket    

Se você não quiser especificar o caminho completo para o interpretador, mas quiser que ele seja pesquisado no caminho de pesquisa executável $PATH , use

#!/usr/bin/env racket

Para acessar os argumentos da linha de comando, o Racket fornece uma biblioteca de análise de linha de comando] ( link ), ou você pode recuperar os parâmetros da linha de comando diretamente com (current-command-line-arguments) . Você precisará invocar racket com a opção -f :

#!/usr/bin/racket -f
…
(define arg (string->number (vector-ref (current-command-line-arguments) 0)))
(display (primes<= arg))
(newline)

Isso não pode ser combinado com #!/usr/bin/env para pesquisar racket em $PATH . Se você quiser, torne seu script poliglota :

#!/bin/sh
":"; exec racket -f "$0" "$@"
…

Se você quiser que seu script seja portátil na implementação do esquema, isso é possível desde que a implementação siga SRFI 22 (que Racket não faz).

#!/usr/bin/env scheme-r5rs
…
(define (main argv)
  (display (primes<= (string->number (list-ref argv 1))))
  (newline))