Auto-detect Guile in a text editor

[HiPhish]

Hello Schemers

When I open a Scheme file (Neo)vim the file type is set to "scheme", but I
would like to be able to detect that it is not just Scheme, but Guile Scheme.
So far I have set up the editor to scan the first line for a shebang and if
the word "guile" appears to set the file type to "scheme.guile":

if getline(1) =~? '\v^#!.*[Gg]uile'
let &filetype .= '.guile'
endif

If you are not familiar with Vim, the important part is the regex
'^#!.*[Gg]uile'. This works OK, but is there a better way than adding a
shebang or some other manual hing to the head of every script? How does Emacs
do it?

And while I'm at that topic, what is the proper way of writing a shebang when
I don't know where Guile is installed to? For example, the Guile manual
frequently uses

#!/usr/local/bin/guile

but what if I have Guile installed via Guix and it is somewhere in my Guix
store? A common solution is to abuse env:

#!/usr/bin/env guile

But now I cannot pass arguments (like '-s') to Guile, because everything
following the first space will be treated as one argument to 'env'. Is there a
solution or am I just overthinking things?

[Tkprom]

Post by HiPhish
Hello Schemers
When I open a Scheme file (Neo)vim the file type is set to "scheme", but I
would like to be able to detect that it is not just Scheme, but Guile Scheme.
So far I have set up the editor to scan the first line for a shebang and if
if getline(1) =~? '\v^#!.[Gg]uile'
let &filetype .= '.guile'
endif
If you are not familiar with Vim, the important part is the regex
'^#!.[Gg]uile'. This works OK, but is there a better way than adding ashebang or some other manual hing to the head of every script? How does Emacs
do it?
And while I'm at that topic, what is the proper way of writing a shebang when
I don't know where Guile is installed to? For example, the Guile manual
frequently uses
#!/usr/local/bin/guile
but what if I have Guile installed via Guix and it is somewhere in my Guix
#!/usr/bin/env guile
But now I cannot pass arguments (like '-s') to Guile, because everything
following the first space will be treated as one argument to 'env'. Is there a
solution or am I just overthinking things?

Hi,

Maybe you could look into how Geiser does it in Emacs. As far as I know, Geiser is a de-facto Guile IDE for Emacs (http://www.nongnu.org/geiser/).

Your approach will only work for the she-banged scripts. For anything else, I suppose there is going to be some guess-work involved. For example, often used Guile constructs are "define-module", #:use-module, use-modules ... they all usually appear at the top. Ditto "ice-9" . Scan top 20-50 lines for those keywords and there is a high probability the Scheme file is a Guile file if it contains any of those.

About your second question: yes, that sucks! This is why i stopped using executable guile scripts and am now just doing:

$ guile my-program.scm options to the program

Perhaps someone else has a better solution.

Hope this helps,

Tk

[Tk]

‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐

Post by Tkprom

Post by HiPhish
Hello Schemers
When I open a Scheme file (Neo)vim the file type is set to "scheme", but I
would like to be able to detect that it is not just Scheme, but Guile Scheme.
So far I have set up the editor to scan the first line for a shebang and if
if getline(1) =~? '\v^#!.[Gg]uile'
let &filetype .= '.guile'
endif
If you are not familiar with Vim, the important part is the regex
'^#!.[Gg]uile'. This works OK, but is there a better way than adding ashebang or some other manual hing to the head of every script? How does Emacs
do it?
And while I'm at that topic, what is the proper way of writing a shebang when
I don't know where Guile is installed to? For example, the Guile manual
frequently uses
#!/usr/local/bin/guile
but what if I have Guile installed via Guix and it is somewhere in my Guix
#!/usr/bin/env guile
But now I cannot pass arguments (like '-s') to Guile, because everything
following the first space will be treated as one argument to 'env'. Is there a
solution or am I just overthinking things?

Hi,
Maybe you could look into how Geiser does it in Emacs. As far as I know, Geiser is a de-facto Guile IDE for Emacs (http://www.nongnu.org/geiser/).
Your approach will only work for the she-banged scripts. For anything else, I suppose there is going to be some guess-work involved. For example, often used Guile constructs are "define-module", #:use-module, use-modules ... they all usually appear at the top. Ditto "ice-9" . Scan top 20-50 lines for those keywords and there is a high probability the Scheme file is a Guile file if it contains any of those.
$ guile my-program.scm options to the program
Perhaps someone else has a better solution.
Hope this helps,
Tk

One more thing: since the current attempts at standardisation of Scheme language are pushing for uniformity among different implementations (I know, I know, it may never happen), perhaps scanning for dialect-specific usage is not the nicest approach.

I prefer the approach where leaving a comment marker somewhere would activate the required functionality. For example, in Emacs, you could write something like,

; -*- mode: Scheme; eval: (whatever-minor-guile-mode-is-used 1); -*- .

[Matt Wette]

Post by HiPhish
And while I'm at that topic, what is the proper way of writing a shebang when
I don't know where Guile is installed to? For example, the Guile manual
frequently uses
#!/usr/local/bin/guile
but what if I have Guile installed via Guix and it is somewhere in my Guix
#!/usr/bin/env guile
But now I cannot pass arguments (like '-s') to Guile, because everything
following the first space will be treated as one argument to 'env'. Is there a
solution or am I just overthinking things?

Sometime I need to do shell processing, so I use

  #!/bin/sh

  exec guile $0 "$@"

  !#
(define foo 1)
...

[Barry Fishman]

Post by HiPhish
Hello Schemers
When I open a Scheme file (Neo)vim the file type is set to "scheme", but I
would like to be able to detect that it is not just Scheme, but Guile Scheme.
So far I have set up the editor to scan the first line for a shebang and if
if getline(1) =~? '\v^#!.*[Gg]uile'
let &filetype .= '.guile'
endif
If you are not familiar with Vim, the important part is the regex
'^#!.*[Gg]uile'. This works OK, but is there a better way than adding a
shebang or some other manual hing to the head of every script? How does Emacs
do it?

Vim like Emacs recognizes modelines in the file. I start guile scripts
with:

#! /bin/sh
## -*- mode: scheme; coding: utf-8 -*-
## Time-stamp: <2018-09-14 08:43:42 barry>
exec ${GUILE:-guile} -e main -s $0 ${1+"$@"}
!#

--
Barry Fishman