doc: Describe -e (module) on equal footing with (@ ...).

* doc/ref/guile-invoke.texi, doc/ref/scheme-scripts.texi:
describe the -e (module) shorthand as on equal footing with (@ ...)

Co-authored-by: Ludovic Courtès <ludo@gnu.org>

doc/ref/guile-invoke.texi

@@ -102,14 +102,10 @@ that is defined in the script.  It can also be of the form @code{(@@
 @var{module-name} @var{symbol})}, and in that case, the symbol is
 looked up in the module named @var{module-name}.
 
-For compatibility with some versions of Guile 1.4, you can also use the
+As a shorthand you can use the form @code{(symbol ...)}, that is, a list
-form @code{(symbol ...)} (that is, a list of only symbols that doesn't
+of only symbols that doesn't start with @code{@@}.  It is equivalent to
-start with @code{@@}), which is equivalent to @code{(@@ (symbol ...)
+@code{(@@ @var{module-name} main)}, where @var{module-name} is
-main)}, or @code{(symbol ...)  symbol} (that is, a list of only symbols
+@code{(symbol ...)} form.  @xref{Using Guile Modules} and @ref{Scripting
-followed by a symbol), which is equivalent to @code{(@@ (symbol ...)
-symbol)}.  We recommend to use the equivalent forms directly since they
-correspond to the @code{(@@ ...)}  read syntax that can be used in
-normal code.  See @ref{Using Guile Modules} and @ref{Scripting
 Examples}.
 
 @item -ds

doc/ref/scheme-scripts.texi

@@ -293,6 +293,11 @@ and exit.
 Load the file @file{/u/jimb/ex4}, and then call the function
 @code{main}, passing it the list @code{("/u/jimb/ex4" "foo")}.
 
+@item guile -e '(ex4)' -s /u/jimb/ex4.scm foo
+Load the file @file{/u/jimb/ex4.scm}, and then call the function
+@code{main} from the module '(ex4)', passing it the list
+@code{("/u/jimb/ex4" "foo")}.
+
 @item guile -l first -ds -l last -s script
 Load the files @file{first}, @file{script}, and @file{last}, in that
 order.  The @code{-ds} switch says when to process the @code{-s}
@@ -369,6 +374,7 @@ Suppose that we now want to write a script which computes the
 @code{(choose @var{n} @var{m})} is the number of distinct subsets
 containing @var{n} objects each.  It's easy to write @code{choose} given
 @code{fact}, so we might write the script this way:
+
 @example
 #!/usr/local/bin/guile \
 -l fact -e main -s
@@ -402,6 +408,68 @@ $ ./choose 50 100
 100891344545564193334812497256
 @end example
 
+To call a specific procedure from a given module, we can use the special
+form @code{(@@ (@var{module}) @var{procedure})}:
+
+@example
+#!/usr/local/bin/guile \
+-l fact -e (@@ (fac) main) -s
+!#
+(define-module (fac)
+  #:export (main))
+
+(define (choose n m)
+  (/ (fact m) (* (fact (- m n)) (fact n))))
+
+(define (main args)
+  (let ((n (string->number (cadr args)))
+        (m (string->number (caddr args))))
+    (display (choose n m))
+    (newline)))
+@end example
+
+We can use @code{@@@@} to invoke non-exported procedures.  For exported
+procedures, we can simplify this call with the shorthand
+@code{(@var{module})}:
+
+@example
+#!/usr/local/bin/guile \
+-l fact -e (fac) -s
+!#
+(define-module (fac)
+  #:export (main))
+
+(define (choose n m)
+  (/ (fact m) (* (fact (- m n)) (fact n))))
+
+(define (main args)
+  (let ((n (string->number (cadr args)))
+        (m (string->number (caddr args))))
+    (display (choose n m))
+    (newline)))
+@end example
+
+For maximum portability, we can instead use the shell to execute
+@command{guile} with specified command line arguments.  Here we need to
+take care to quote the command arguments correctly:
+
+@example
+#!/usr/bin/env sh
+exec guile -l fact -e '(@@ (fac) main)' -s "$0" "$@"
+!#
+(define-module (fac)
+  #:export (main))
+
+(define (choose n m)
+  (/ (fact m) (* (fact (- m n)) (fact n))))
+
+(define (main args)
+  (let ((n (string->number (cadr args)))
+        (m (string->number (caddr args))))
+    (display (choose n m))
+    (newline)))
+@end example
+
 Finally, seasoned scripters are probably missing a mention of
 subprocesses.  In Bash, for example, most shell scripts run other
 programs like @code{sed} or the like to do the actual work.