Rosetta Code

Modulinos: Difference between revisions

Page Discussion

Modulinos (view source)

Revision as of 10:33, 4 January 2024

38,648 bytes added ,  4 months ago
m
→‎{{header|Wren}}: Minor tidy
m (→‎{{header|Wren}}: Minor tidy)
 
(157 intermediate revisions by 50 users not shown)
Line 1:
{{draft task|Basic language learning}}
It is useful to be able to execute a main() function only when a program is run directly. This is a central feature in programming scripts;. theA featurescript that behaves this way is called a [http://www.slideshare.net/brian_d_foy/advanced-modulinos ''scripted mainmodulino''].
 
Examples from [https://github.com/mcandre/scriptedmain GitHub].modulinos
 
Sometimes getting the [[ScriptName]] is required in order to determine when to run main().
 
Care when manipulating command line arguments, due to subtle exec security constraints that may or not be enforced on implicit argv[0]. https://ryiron.wordpress.com/2013/12/16/argv-silliness/
 
: ''This is still a draft task, and the current task description has caused mega confusion. See '''[[Talk:Modulinos]]''' for numerous attempts to understand the task and to rewrite the task description.''
 
: '''The task [[Executable library]] is written to replace this task.''' ''This task's future is in doubt as its aims are not clear enough.''
<br><br>
 
=={{header|11l}}==
<syntaxhighlight lang="11l">// life.11l
 
F meaning_of_life()
R ‘*’.code
 
:start:
print(‘Main: The meaning of life is ’meaning_of_life())</syntaxhighlight>
 
<syntaxhighlight lang="11l">// death.11l
 
print(‘Life means ’life:meaning_of_life()‘.’)
print(‘Death means nothing.’)</syntaxhighlight>
 
=={{header|AppleScript}}==
 
AppleScript's equivalent of a main() function is a <tt>run</tt> handler, which can be either implicit or explicit:
 
<syntaxhighlight lang="applescript">display dialog "Hello"</syntaxhighlight>
or
<syntaxhighlight lang="applescript">on run
display dialog "Hello"
end run</syntaxhighlight>
 
A <tt>run</tt> handler's only executed when the script containing it is explicity ''run'', either from another script or application or as an application in its own right. It's not executed when a script's simply loaded as a library, although it can subsequently be so in the unlikely event of this being desirable. Scripts saved as applications aren't recognised by the "Libraries" system introduced in Mac OS X 10.9, but can be loaded and/or run using the older <tt>load script</tt> and <tt>run script</tt> commands. Script code can tell if it's running in its own application or being executed by an external agent by comparing its file path with that of the agent:
 
<syntaxhighlight lang="applescript">on run
if ((path to me) = (path to current application)) then
display dialog "I'm running in my own application."
else
display dialog "I'm being run from another script or application."
end if
end run</syntaxhighlight>
 
=={{header|Arturo}}==
 
===Library===
 
<syntaxhighlight lang="rebol">; modulinos - library
meaningOfLife: function [][
42
]
 
if standalone? ->
print ~"Library: The meaning of life is |meaningOfLife|"</syntaxhighlight>
 
{{out}}
 
<pre>Library: The meaning of life is 42</pre>
 
===Main===
 
<syntaxhighlight lang="rebol">do.import relative "modulinos - library.art"
print ~"Life means |meaningOfLife|."
print "Death means invisible scary skeletons."</syntaxhighlight>
 
{{out}}
 
<pre>Life means 42.
Death means invisible scary skeletons.</pre>
 
=={{header|C}}==
 
C programs cannot normally do scripted main, because main() is implicitly included by another program, test.c, even though scriptedmain.h omits any main() prototype. A compiler directive fixes this.
{{works with|GCC}}
 
C programs cannot normally do scripted main, because main() is implicitly included by another program, test.c, even though scriptedmain.h omits any main() prototype. However, preprocessor instructions can hide main unless a compiler flag is explicitly set.
 
Example
 
<syntaxhighlight lang="sh">$ make
./scriptedmain
Main: The meaning of life is 42
./test
Test: The meaning of life is</syntaxhighlight>
 
Makefile
 
<syntaxhighlight lang="make">all: scriptedmain test
./scriptedmain
./test
 
scriptedmain: scriptedmain.c scriptedmain.h
gcc -o scriptedmain -DSCRIPTEDMAIN scriptedmain.c scriptedmain.h
 
test: test.c scriptedmain.h scriptedmain.c
gcc -o test test.c scriptedmain.c scriptedmain.h
 
clean:
-rm scriptedmain
-rm test
-rm scriptedmain.exe
-rm test.exe</syntaxhighlight>
 
scriptedmain.h
 
<syntaxhighlight lang ="c">int meaning_of_life();</langsyntaxhighlight>
 
scriptedmain.c
 
<langsyntaxhighlight lang="c">#include <stdio.h>
 
int meaning_of_life() {
Line 19 ⟶ 120:
}
 
#ifdef SCRIPTEDMAIN
int __attribute__((weak)) main(int argc, char **argv) {
 
int main() {
printf("Main: The meaning of life is %d\n", meaning_of_life());
 
return 0;
}
}</lang>
 
#endif</syntaxhighlight>
 
test.c
 
<langsyntaxhighlight lang="c">#include "scriptedmain.h"
#include <stdio.h>
 
Line 35 ⟶ 140:
printf("Test: The meaning of life is %d\n", meaning_of_life());
return 0;
}</langsyntaxhighlight>
 
=={{header|C++}}==
C++ programs cannot normally do scripted main, because main() is implicitly included by another program, test.c, even though scriptedmain.h omits any main() prototype. APreprocessor instructions can hide main() unless a compiler directiveflat is fixesexplicitly thisset.
 
Example
 
<syntaxhighlight lang="sh">$ make
./scriptedmain
Main: The meaning of life is 42
./test
Test: The meaning of life is 42</syntaxhighlight>
 
Makefile
 
<syntaxhighlight lang="make">all: scriptedmain test
./scriptedmain
./test
 
scriptedmain: scriptedmain.cpp scriptedmain.h
g++ -o scriptedmain -static-libgcc -static-libstdc++ -DSCRIPTEDMAIN scriptedmain.cpp scriptedmain.h
 
test: test.cpp scriptedmain.h scriptedmain.cpp
g++ -o test -static-libgcc -static-libstdc++ test.cpp scriptedmain.cpp scriptedmain.h
 
clean:
-rm scriptedmain
-rm test
-rm scriptedmain.exe
-rm test.exe</syntaxhighlight>
 
scriptedmain.h
 
<syntaxhighlight lang ="cpp">int meaning_of_life();</langsyntaxhighlight>
 
scriptedmain.cpp
 
<langsyntaxhighlight lang="cpp">#include <iostream>
 
using namespace std;
Line 54 ⟶ 185:
}
 
#ifdef SCRIPTEDMAIN
int __attribute__((weak)) main(int argc, char **argv) {
cout << "Main: The meaning of life is " << meaning_of_life() << endl;
 
int main() {
cout << "Main: The meaning of life is " << meaning_of_life() << endl;
return 0;
}
}</lang>
 
#endif</syntaxhighlight>
 
test.cpp
 
<langsyntaxhighlight lang="cpp">#include "scriptedmain.h"
#include <iostream>
 
Line 69 ⟶ 203:
extern int meaning_of_life();
 
int main(int argc, char **argv) {
cout << "Test: The meaning of life is " << meaning_of_life() << endl;
 
return 0;
}</langsyntaxhighlight>
 
=={{header|Chicken SchemeClojure}}==
Uses [https://github.com/kumarshantanu/lein-exec lein-exec].
Chicken Scheme has the {{{ -ss }}} flag for the interpreter, but compiled Chicken Scheme programs do not have scripted main unless the behavior is added manually to the code.
 
scriptedmain.scmclj:
<syntaxhighlight lang="clojure">":";exec lein exec $0 ${1+"$@"}
":";exit
 
(ns scriptedmain
<lang scheme>#!/bin/bash
(:gen-class))
#|
exec csi -ss $0 ${1+"$@"}
exit
|#
 
(defn meaning-of-life [] 42)
(use posix)
(require-extension srfi-1) ; lists
 
(defn -main [& args]
(define (meaning-of-life) 42)
(println "Main: The meaning of life is" (meaning-of-life)))
 
(when (.contains (first *command-line-args*) *source-path*)
(define (main args)
(apply -main (rest *command-line-args*)))</syntaxhighlight>
(display (format "Main: The meaning of life is ~a\n" (meaning-of-life)))
(exit))
 
test.clj:
(define (program)
<syntaxhighlight lang="clojure">":";exec lein exec $0 ${1+"$@"}
(if (string=? (car (argv)) "csi")
":";exit
(let ((s-index (list-index (lambda (x) (string-contains x "-s")) (argv))))
(if (number? s-index)
(cons 'interpreted (list-ref (argv) (+ 1 s-index)))
(cons 'unknown "")))
(cons 'compiled (car (argv)))))
 
(ns test
(if (equal? (car (program)) 'compiled)
(:gen-class))
(main (cdr (argv))))</lang>
 
(load-string (slurp "scriptedmain.clj"))
test.scm
 
(defn -main [& args]
<lang scheme>#!/bin/bash
(println "Test: The meaning of life is" (scriptedmain/meaning-of-life)))
#|
 
exec csi -ss $0 ${1+"$@"}
(when (.contains (first *command-line-args*) *source-path*)
exit
(apply -main (rest *command-line-args*)))</syntaxhighlight>
|#
 
(define (main args)
=={{header|CoffeeScript}}==
(load "scriptedmain.scm")
scriptedmain.coffee:
(display (format "Test: The meaning of life is ~a\n" (meaning-of-life)))
<syntaxhighlight lang="coffeescript">#!/usr/bin/env coffee
(exit))</lang>
 
meaningOfLife = () -> 42
 
exports.meaningOfLife = meaningOfLife
 
main = () ->
console.log "Main: The meaning of life is " + meaningOfLife()
 
if not module.parent then main()</syntaxhighlight>
 
test.coffee:
<syntaxhighlight lang="coffeescript">#!/usr/bin/env coffee
 
sm = require "./scriptedmain"
 
console.log "Test: The meaning of life is " + sm.meaningOfLife()</syntaxhighlight>
 
=={{header|Common Lisp}}==
Line 122 ⟶ 265:
 
In CLISP, this code only works for ./scriptedmain.lisp.
 
~/.clisprc.lisp
 
<syntaxhighlight lang="lisp">;;; Play nice with shebangs
(set-dispatch-macro-character #\# #\!
(lambda (stream character n)
(declare (ignore character n))
(read-line stream nil nil t)
nil))</syntaxhighlight>
 
scriptedmain.lisp
 
<langsyntaxhighlight lang="lisp">#!/bin/bashsh
#|
exec clisp -q -q $0 $0 ${1+"$@"}
Line 155 ⟶ 307:
args
:test #'(lambda (x y) (search x y :test #'equalp)))
(main args)))</langsyntaxhighlight>
 
test.lisp
 
<langsyntaxhighlight lang="lisp">#!/bin/bashsh
#|
exec clisp -q -q $0 $0 ${1+"$@"}
Line 166 ⟶ 318:
 
(load "scriptedmain.lisp")
(format t "Test: The meaning of life is ~a~%" (meaning-of-life))</langsyntaxhighlight>
 
=={{header|D}}==
 
D manages to implement scriptedmain through the use of version directives, which require special options to rdmd and dmd.
 
scriptedmain.d:
 
<syntaxhighlight lang="d">#!/usr/bin/env rdmd -version=scriptedmain
 
module scriptedmain;
 
import std.stdio;
 
int meaningOfLife() {
return 42;
}
 
version (scriptedmain) {
void main(string[] args) {
writeln("Main: The meaning of life is ", meaningOfLife());
}
}</syntaxhighlight>
 
test.d:
 
<syntaxhighlight lang="d">#!/usr/bin/env rdmd -version=test
 
import scriptedmain;
import std.stdio;
 
version (test) {
void main(string[] args) {
writeln("Test: The meaning of life is ", meaningOfLife());
}
}</syntaxhighlight>
 
Example:
 
<syntaxhighlight lang="sh">$ ./scriptedmain.d
Main: The meaning of life is 42
$ ./test.d
Test: The meaning of life is 42
$ dmd scriptedmain.d -version=scriptedmain
$ ./scriptedmain
Main: The meaning of life is 42
$ dmd test.d scriptedmain.d -version=test
$ ./test
Test: The meaning of life is 42</syntaxhighlight>
 
=={{header|Dart}}==
scriptedmain.dart:
<syntaxhighlight lang="dart">#!/usr/bin/env dart
 
#library("scriptedmain");
 
meaningOfLife() {
return 42;
}
 
main() {
print("Main: The meaning of life is ${meaningOfLife()}");
}</syntaxhighlight>
 
test.dart:
<syntaxhighlight lang="dart">#!/usr/bin/env dart
 
#import("scriptedmain.dart", prefix: "scriptedmain");
 
main() {
print("Test: The meaning of life is ${scriptedmain.meaningOfLife()}");
}</syntaxhighlight>
 
Example:
<syntaxhighlight lang="sh">$ ./scriptedmain.dart
Main: The meaning of life is 42
$ ./test.dart
Test: The meaning of life is 42</syntaxhighlight>
 
=={{header|Emacs Lisp}}==
Line 173 ⟶ 402:
scriptedmain.el
 
<langsyntaxhighlight lang="lisp">:;exec emacs -batch -l $0 -f main $*
 
;;; Shebang from John Swaby
Line 181 ⟶ 410:
 
(defun main ()
(message "Main: The meaning of life is %d" (meaning-of-life)))</langsyntaxhighlight>
 
test.el
 
<langsyntaxhighlight lang="lisp">:;exec emacs -batch -l $0 -f main $*
 
;;; Shebang from John Swaby
Line 193 ⟶ 422:
(setq load-path (cons default-directory load-path))
(load "scriptedmain.el" nil t)
(message "Test: The meaning of life is %d" (meaning-of-life)))</langsyntaxhighlight>
 
=={{header|EMal}}==
{{trans|Wren}}
<syntaxhighlight lang="emal">
^|We have created a module named ModulinosPart.emal.
|^
in Org:RosettaCode
type ModulinosPart
fun meaningOfLife = int by block do return 42 end
fun main = void by block do writeLine("The meaning of life is " + meaningOfLife() + ".") end
if Runtime.direct() do main() end
</syntaxhighlight>
{{out}}
<pre>
emal.exe Org\RosettaCode\ModulinosPart.emal
The meaning of life is 42.
</pre>
<syntaxhighlight lang="emal">
^|Then we create a new module named Modulinos.emal,
|this imports the previous module.
|^
in Org:RosettaCode
load :ModulinosPart
type Modulinos
fun main = int by List args
writeLine("Who says the meaning of life is " + ModulinosPart.meaningOfLife() + "?")
return 0
end
exit main(Runtime.args)
</syntaxhighlight>
{{out}}
<pre>
emal.exe Org\RosettaCode\Modulinos.emal
Who says the meaning of life is 42?
</pre>
 
=={{header|Erlang}}==
Erlang has scripted main by default. scriptedmain.erl must be compiled before test.erl can access its functions.
 
Makefile:
scriptedmain.erl
<syntaxhighlight lang="make">all: t
 
<langt: erlang>-module(scriptedmain).beam test.beam
erl -noshell -s scriptedmain
-export([meaning_of_life/0]).
erl -noshell -s test
-import(lists, [map/2]).
 
scriptedmain.beam: scriptedmain.erl
meaning_of_life() -> 42.
erlc scriptedmain.erl
 
test.beam: test.erl
main(_) ->
erlc test.erl
io:format("Main: The meaning of life is ~w~n", [meaning_of_life()]).</lang>
 
clean:
test.erl
-rm *.beam</syntaxhighlight>
 
<lang erlang>% Compile scriptedmain.erl first.:
<syntaxhighlight lang="erlang">-module(scriptedmain).
-export([meaning_of_life/0, start/0]).
 
meaning_of_life() -> 42.
-module(test).
 
start() ->
io:format("Main: The meaning of life is ~w~n", [meaning_of_life()]),
init:stop().</syntaxhighlight>
 
test.erl:
<syntaxhighlight lang="erlang">-module(test).
-export([start/0]).
-import(scriptedmain, [meaning_of_life/0]).
 
mainstart(_) ->
io:format("Test: The meaning of life is ~w~n", [meaning_of_life()]).</lang>,
init:stop().</syntaxhighlight>
 
=={{header|F Sharp|F#}}==
 
Note 1: F# supports the scriptedmain behavior, but F# does not support hybrid script-compiled code files. The following programs work provided that they are compiled and then run, as .fs files, not interpreted or dotslashed as .fsx files.
 
Note 2: fsharpc has a backwards file ordering: Specify any dependencies BEFORE the code that depends on them.
 
Note 3: fsharpc also has that unpredictable DOS-flavored command line flag syntax, so the --out requires a colon between it and its value, and -h only generates an error; use --help instead.
 
Note 4: In Unix, mono is required to run F# executables. In Windows, mono is not required for execution.
 
Example:
 
<syntaxhighlight lang="sh">$ make
fsharpc --out:scriptedmain.exe ScriptedMain.fs
fsharpc --out:test.exe ScriptedMain.fs Test.fs
$ mono scriptedmain.exe
Main: The meaning of life is 42
$ mono test.exe
Test: The meaning of life is 42</syntaxhighlight>
 
Makefile:
 
<syntaxhighlight lang="make">all: scriptedmain.exe test.exe
 
scriptedmain.exe: ScriptedMain.fs
fsharpc --nologo --out:scriptedmain.exe ScriptedMain.fs
 
test.exe: Test.fs ScriptedMain.fs
fsharpc --nologo --out:test.exe ScriptedMain.fs Test.fs
 
clean:
-rm *.exe</syntaxhighlight>
 
ScriptedMain.fs:
 
<syntaxhighlight lang="fsharp">namespace ScriptedMain
 
module ScriptedMain =
let meaningOfLife = 42
 
let main =
printfn "Main: The meaning of life is %d" meaningOfLife</syntaxhighlight>
 
Test.fs:
 
<syntaxhighlight lang="fsharp">module Test =
open ScriptedMain
 
let main =
printfn "Test: The meaning of life is %d" ScriptedMain.meaningOfLife</syntaxhighlight>
 
=={{header|Factor}}==
Note: The INCLUDE/INCLUDING macros must be added to the ~/.factor-rc configuration file.
 
Example:
 
<syntaxhighlight lang="sh">$ ./scriptedmain.factor
Main: The meaning of life is 42
$ ./test.factor
Test: The meaning of life is 42</syntaxhighlight>
 
~/.factor-rc:
 
<syntaxhighlight lang="factor">! INCLUDING macro that imports source code files in the current directory
 
USING: kernel vocabs.loader parser sequences lexer vocabs.parser ;
IN: syntax
 
: include-vocab ( vocab -- ) dup ".factor" append parse-file append use-vocab ;
 
SYNTAX: INCLUDING: ";" [ include-vocab ] each-token ;</syntaxhighlight>
 
scriptedmain.factor:
 
<syntaxhighlight lang="factor">#! /usr/bin/env factor
 
USING: io math.parser ;
IN: scriptedmain
 
: meaning-of-life ( -- n ) 42 ;
 
: main ( -- ) meaning-of-life "Main: The meaning of life is " write number>string print ;
 
MAIN: main</syntaxhighlight>
 
test.factor:
 
<syntaxhighlight lang="factor">#! /usr/bin/env factor
 
INCLUDING: scriptedmain ;
USING: io math.parser ;
IN: test
 
: main ( -- ) meaning-of-life "Test: The meaning of life is " write number>string print ;
 
MAIN: main</syntaxhighlight>
 
=={{header|Forth}}==
 
Given this awful running reference:
 
<syntaxhighlight lang="forth">42 constant Douglas-Adams
 
: go ( -- )
." The meaning of life is " Douglas-Adams . cr ;</syntaxhighlight>
 
The bulk of Forth systems provide a way to generate an executable that enters GO (ar any word) on start.
 
{{works with|SwiftForth|SwiftForth|4.0}}
 
<syntaxhighlight lang="forth">' go 'MAIN !
program douglas-adams</syntaxhighlight>
 
Which creates a file named 'douglas-adams' that you can then run. If this is all in the same file, you can load the file, test parts of it, and then exit (or shell out) to run the executable.
 
A unix script requires that '#!' be a comment and that the system have some #!-compatible arguments.
 
{{works with|gforth}}
 
<syntaxhighlight lang="forth">#! /usr/bin/env gforth
 
42 constant Douglas-Adams
.( The meaning of life is ) Douglas-Adams . cr bye</syntaxhighlight>
 
Adding #! as a comment, as gforth does, is trivial. For a means by which this script could distinguish between 'scripted execution' and otherwise, a symlink like 'forthscript' could easily be used, and the zeroth OS argument tested for, but there's no convention.
 
{{works with|gforth}}
 
<syntaxhighlight lang="forth">#! /usr/bin/env forthscript
 
42 constant Douglas-Adams
 
s" forthscript" 0 arg compare 0= [IF]
.( The meaning of life is ) Douglas-Adams . cr bye
[THEN]
 
cr .( Why aren't you running this as a script? It only provides a constant.)</syntaxhighlight>
 
 
=={{header|FreeBASIC}}==
{{trans|Ring}}
<syntaxhighlight lang="freebasic">
Function meaningoflife() As Byte
Dim As Byte y = 42
Return y
End Function
 
Sub main()
Print "Main: The meaning of life is "; meaningoflife()
End Sub
 
main()
Sleep
</syntaxhighlight>
{{out}}
<pre>
Main: The meaning of life is 42
</pre>
 
 
=={{header|Go}}==
Go doesn't support scripted main directly.
 
Although the [https://github.com/mcandre/modulinos examples] linked to above include an example for Go, this is only a work around, not an emulation. To emulate a modulino, we need to proceed as in the [[https://rosettacode.org/wiki/Executable_library#Go Executable library]] task and split the 'main' package into two.
 
First create these two files in the 'modulino' directory:
<syntaxhighlight lang="go">// modulino.go
package main
 
import "fmt"
 
func MeaningOfLife() int {
return 42
}
 
func libMain() {
fmt.Println("The meaning of life is", MeaningOfLife())
}</syntaxhighlight>
 
<syntaxhighlight lang="go">// modulino_main.go
package main
func main() {
libMain()
}</syntaxhighlight>
 
To emulate a modulino:
{{out}}
<pre>
$ go run modulino
 
The meaning of life is 42
</pre>
 
Now create this file in the 'mol' directory:
<syntaxhighlight lang="go">// mol.go
package main
 
import "fmt"
 
func main() {
fmt.Println("The meaning of life is still", MeaningOfLife())
}</syntaxhighlight>
and copy modulino.go to the 'mol' directory. The library can then be used in the 'normal' way:
{{out}}
<pre>
$ go run mol
 
The meaning of life is still 42
</pre>
 
=={{header|Groovy}}==
 
Example:
 
<syntaxhighlight lang="sh">$ ./ScriptedMain.groovy
Main: The meaning of life is 42
$ ./Test.groovy
Test: The meaning of life is 42</syntaxhighlight>
 
ScriptedMain.groovy:
 
<syntaxhighlight lang="groovy">#!/usr/bin/env groovy
 
class ScriptedMain {
static def meaningOfLife = 42
 
static main(args) {
println "Main: The meaning of life is " + meaningOfLife
}
}</syntaxhighlight>
 
Test.groovy:
 
<syntaxhighlight lang="groovy">#!/usr/bin/env groovy
 
println "Test: The meaning of life is " + ScriptedMain.meaningOfLife</syntaxhighlight>
 
=={{header|Haskell}}==
Haskell has scripted main, but notgetting forscripted compiledmain scripts.to Thiswork iswith becausecompiled thescripts primary script must be a module Main, creating a nameis conflicttricky.
 
<syntaxhighlight lang="sh">$ runhaskell scriptedmain.shhs
Main: The meaning of life is 42
$ runhaskell test.hs
Test: The meaning of life is 42
$ ghc -fforce-recomp -o scriptedmain -main-is ScriptedMain scriptedmain.hs
$ ./scriptedmain
Main: The meaning of life is 42
$ ghc -fforce-recomp -o test -main-is Test test.hs scriptedmain.hs
$ ./test
Test: The meaning of life is 42</syntaxhighlight>
 
scriptedmain.hs
<lang haskell>#!/usr/bin/env runhaskell
 
<syntaxhighlight lang="haskell">#!/usr/bin/env runhaskell
-- Haskell has scripted main, but not for compiled scripts.
 
-- This is because the primary script must be a module Main,
-- Compile:
-- creating a name conflict.
--
-- ghc -fforce-recomp -o scriptedmain -main-is ScriptedMain scriptedmain.hs
 
module ScriptedMain where
Line 236 ⟶ 763:
 
main :: IO ()
main = putStrLn $ "Main: The meaning of life is " ++ show meaningOfLife</langsyntaxhighlight>
 
test.hs
 
<langsyntaxhighlight lang="haskell">#!/usr/bin/env runhaskell
 
-- Compile:
--
-- ghc -fforce-recomp -o test -main-is Test test.hs scriptedmain.hs
 
module Test where
 
import ScriptedMain hiding (main)
 
main :: IO ()
main = putStrLn $ "Test: The meaning of life is " ++ show meaningOfLife</langsyntaxhighlight>
 
=={{header|Io}}==
 
ScriptedMain.io:
 
<syntaxhighlight lang="io">#!/usr/bin/env io
 
ScriptedMain := Object clone
ScriptedMain meaningOfLife := 42
 
if( isLaunchScript,
"Main: The meaning of life is #{ScriptedMain meaningOfLife}" interpolate println
)</syntaxhighlight>
 
test.io:
 
<syntaxhighlight lang="io">#!/usr/bin/env io
 
"Test: The meaning of life is #{ScriptedMain meaningOfLife}" interpolate println</syntaxhighlight>
 
<syntaxhighlight lang="sh">$ ./ScriptedMain.io
Main: The meaning of life is 42
$ ./test.io
Test: The meaning of life is 42</syntaxhighlight>
 
=={{header|J}}==
 
modulinos.ijs:
Probably the simplest way to achive what I imagine "scripted main" to be, in J, involves the use of the [http://www.jsoftware.com/help/dictionary/dx009.htm Immex Phrase]. Here, just before the script ends, you define the "main" which would take control if the script was used as a stand alone program.
 
<syntaxhighlight lang="j">#!/usr/bin/env ijconsole
meaningOfLife =: 42
main =: monad define
echo 'Main: The meaning of life is ',": meaningOfLife
exit ''
)
 
shouldrun =: monad define
if. 1 e. 'modulinos.ijs' E. ;ARGV do.
main 0
end.
)
shouldrun 0</syntaxhighlight>
 
test.j:
 
<syntaxhighlight lang="j">#!/usr/bin/env jconsole
Here is an example "scripted main" program, using this approach:
 
load 'modulinos.ijs'
<lang j>NB. example "scripted main" code, saved as sm.ijs
myName=: 'My name is George'
9!:29]1
9!:27'smoutput myName'</lang>
 
echo 'Test: The meaning of life is ',": meaningOfLife
Here is an example consumer, which is another "scripted main" program:
 
exit ''</syntaxhighlight>
<lang j>NB. example "alternate main" code
require'sm.ijs'
9!:29]1
9!:27'smoutput ''length: '',":#myName'</lang>
 
Example:
Here is another example consumer. This example is library code, without any main:
 
<syntaxhighlight lang="sh">$ ./modulinos.ijs
<lang j>NB. example "non main" library code
Main: The meaning of life is 42
require'sm.ijs'
$ ./test.j
9!:29]0
Test: The meaning of life is 42</syntaxhighlight>
reversed=:|.myName</lang>
 
=={{header|Java}}==
Line 277 ⟶ 847:
ScriptedMain.java
 
<langsyntaxhighlight lang="java">public class ScriptedMain {
public static int meaningOfLife() {
return 42;
Line 285 ⟶ 855:
System.out.println("Main: The meaning of life is " + meaningOfLife());
}
}</langsyntaxhighlight>
 
Test.java
 
<langsyntaxhighlight lang="java">public class Test {
public static void main(String[] args) {
System.out.println("Test: The meaning of life is " + ScriptedMain.meaningOfLife());
}
}</langsyntaxhighlight>
 
=={{header|JavaScript}}==
{{Works with|Node.js}}
Node.js has scripted main.
 
scriptedmain.js
<syntaxhighlight lang="javascript">#!/usr/bin/env node
 
function meaningOfLife() { return 42; }
 
exports.meaningOfLife = meaningOfLife;
 
function main() {
console.log("Main: The meaning of life is " + meaningOfLife());
}
 
if (!module.parent) { main(); }</syntaxhighlight>
 
test.js
<syntaxhighlight lang="javascript">#!/usr/bin/env node
 
var sm = require("./scriptedmain");
 
console.log("Test: The meaning of life is " + sm.meaningOfLife());</syntaxhighlight>
 
=={{header|Julia}}==
Julia does not use scripted main by default, but can be set to run as such. Modules generally use a /test unit test subdirectory instead.
<br />
In module file Divisors.jl:
<syntaxhighlight lang="julia">module Divisors
 
using Primes
 
export properdivisors
 
function properdivisors(n::T) where T <: Integer
0 < n || throw(ArgumentError("number to be factored must be ≥ 0, got $n"))
1 < n || return T[]
!isprime(n) || return T[one(T), n]
f = factor(n)
d = T[one(T)]
for (k, v) in f
c = T[k^i for i in 0:v]
d = d*c'
d = reshape(d, length(d))
end
sort!(d)
return d[1:end-1]
end
 
function interactiveDivisors()
println("\nFind proper divisors between two numbers.\nFirst number: ")
lo = (x = tryparse(Int64, readline())) == nothing ? 0 : x
println("\nSecond number: ")
hi = (x = tryparse(Int64, readline())) == nothing ? 10 : x
lo, hi = lo > hi ? (hi, lo) : (lo, hi)
 
println("Listing the proper divisors for $lo through $hi.")
for i in lo:hi
println(lpad(i, 7), " => ", rpad(properdivisors(i), 10))
end
end
 
end
 
# some testing code
if occursin(r"divisors.jl"i, Base.PROGRAM_FILE)
println("This module is running as main.\n")
Divisors.interactiveDivisors()
end
</syntaxhighlight>
In a user file getdivisors.jl:
<syntaxhighlight lang="julia">include("divisors.jl")
 
using .Divisors
 
n = 708245926330
println("The proper divisors of $n are ", properdivisors(n))
</syntaxhighlight>
 
=={{header|LLVM}}==
LLVM hascan have scripted main bya la C, using the weak defaultattribute.
 
<syntaxhighlight lang="sh">$ make
<lang llvm>@msg_directory = internal constant [15 x i8] c"Directory: %s\0A\00"
llvm-as scriptedmain.ll
@msg_program = internal constant [13 x i8] c"Program: %s\0A\00"
llc scriptedmain.bc
@msg_argc = internal constant [20 x i8] c"Number of Args: %d\0A\00"
gcc -o scriptedmain scriptedmain.s
@msg_arg = internal constant [10 x i8] c"Arg = %s\0A\00"
./scriptedmain
Main: The meaning of life is 42
llvm-as test.ll
llc test.bc
gcc -o test test.s scriptedmain.s
./test
Test: The meaning of life is 42</syntaxhighlight>
 
Makefile
declare i32 @printf(i8* noalias nocapture, ...)
declare i8* @getcwd(i8*, i32)
 
<syntaxhighlight lang="make">EXECUTABLE_SM=scriptedmain
define i32 @main(i32 %argc, i8** %argv) {
EXECUTABLE_TEST=test
%cwd = alloca [1024 x i8]
 
all: test.ll scriptedmain.s
%cwd_ptr = getelementptr inbounds [1024 x i8]* %cwd, i32 0, i32 0
llvm-as test.ll
llc test.bc
gcc -o $(EXECUTABLE_TEST) test.s scriptedmain.s
./$(EXECUTABLE_TEST)
 
scriptedmain.s: scriptedmain.ll
call i8* @getcwd(i8* %cwd_ptr, i32 1024)
llvm-as scriptedmain.ll
llc scriptedmain.bc
gcc -o $(EXECUTABLE_SM) scriptedmain.s
./$(EXECUTABLE_SM)
 
clean:
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([15 x i8]* @msg_directory, i32 0, i32 0), i8* %cwd_ptr)
-rm $(EXECUTABLE_TEST)
-rm $(EXECUTABLE_SM)
-rm test.s
-rm test.bc
-rm scriptedmain.s
-rm scriptedmain.bc</syntaxhighlight>
 
scriptedmain.ll
%program_ptr = getelementptr inbounds i8** %argv, i32 0
 
<syntaxhighlight lang="llvm">@msg_main = internal constant [33 x i8] c"Main: The meaning of life is %d\0A\00"
%program = load i8** %program_ptr
 
declare i32 @printf(i8* noalias nocapture, ...)
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([13 x i8]* @msg_program, i32 0, i32 0), i8* %program)
 
define i32 @meaning_of_life() {
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([20 x i8]* @msg_argc, i32 0, i32 0), i32 %argc)
ret i32 42
}
 
define weak i32 @main(i32 %argc, i8** %argv) {
%i = alloca i32
%meaning = call i32 @meaning_of_life()
store i32 0, i32* %i
br label %for_args
 
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([33 x i8]* @msg_main, i32 0, i32 0), i32 %meaning)
for_args:
 
%i_val = load ret i32* %i0
}</syntaxhighlight>
 
test.ll
%arg_ptr = getelementptr inbounds i8** %argv, i32 %i_val
%arg = load i8** %arg_ptr
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([10 x i8]* @msg_arg, i32 0, i32 0), i8* %arg)
 
<syntaxhighlight lang="llvm">@msg_test = internal constant [33 x i8] c"Test: The meaning of life is %d\0A\00"
%new_i_val = add i32 %i_val, 1
store i32 %new_i_val, i32* %i
 
declare i32 @printf(i8* noalias nocapture, ...)
%more_args = icmp slt i32 %new_i_val, %argc
 
br i1 %more_args, label %for_args, label %end_for_args
declare i32 @meaning_of_life()
 
define i32 @main(i32 %argc, i8** %argv) {
%meaning = call i32 @meaning_of_life()
 
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([33 x i8]* @msg_test, i32 0, i32 0), i32 %meaning)
end_for_args:
 
ret i32 0
}</langsyntaxhighlight>
 
=={{header|Lua}}==
Lua has scripted main by default because files are largely indistinguishable from functions semantically (they compile to Lua functions.) Ellipses is Lua's var-arg syntax for functions, and, therefore, for files as well.
Lua has scripted main by default, using an obscure syntax (an ellipsis of all things).
 
scriptedmain.lua
 
<langsyntaxhighlight lang="lua">#!/usr/bin/env lua
 
function meaningoflife()
Line 365 ⟶ 1,037:
else
module(..., package.seeall)
end</langsyntaxhighlight>
 
test.lua
 
<langsyntaxhighlight lang="lua">#!/usr/bin/env lua
sm = require("scriptedmain")
print("Test: The meaning of life is " .. sm.meaningoflife())</langsyntaxhighlight>
 
=={{header|Make}}==
 
Example
<syntaxhighlight lang="sh">$ make -f scriptedmain.mf
The meaning of life is 42
(Main)
$ make -f test.mf
The meaning of life is 42
(Test)</syntaxhighlight>
 
scriptedmain.mf
<syntaxhighlight lang="make">all: scriptedmain
 
meaning-of-life:
@echo "The meaning of life is 42"
 
scriptedmain: meaning-of-life
@echo "(Main)"
</syntaxhighlight>
 
test.mf
<syntaxhighlight lang="make">all: test
 
test:
@make -f scriptedmain.mf meaning-of-life
@echo "(Test)"
</syntaxhighlight>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
 
scriptedmain.ma
<syntaxhighlight lang="mathematica">#!/usr/bin/env MathKernel -script
 
MeaningOfLife[] = 42
 
ScriptName[] = Piecewise[
{
{"Interpreted", Position[$CommandLine, "-script", 1] == {}}
},
$CommandLine[[Position[$CommandLine, "-script", 1][[1,1]] + 1]]
]
 
Program = ScriptName[];
 
If[StringMatchQ[Program, ".*scriptedmain.*"],
Print["Main: The meaning of life is " <> ToString[MeaningOfLife[]]]
]</syntaxhighlight>
 
test.ma:
<syntaxhighlight lang="mathematica">#!/usr/bin/env MathKernel -script
 
Get["scriptedmain.ma"]
 
Print["Test: The meaning of life is " <> ToString[MeaningOfLife[]]]</syntaxhighlight>
 
Example:
<syntaxhighlight lang="sh">$ ./scriptedmain.ma
Main: The meaning of life is 42
$ ./test.ma
Test: The meaning of life is 42</syntaxhighlight>
 
In Mac and Windows, the output will be surrounded by spurious quotes.
 
=={{header|Mozart/Oz}}==
Makefile:
<syntaxhighlight lang="make">all: run
 
run: scriptedmain test
./scriptedmain
./test
 
scriptedmain: scriptedmain.oz
ozc -x scriptedmain.oz
 
scriptedmain.ozf: scriptedmain.oz
ozc -c scriptedmain.oz
 
test: scriptedmain.ozf test.oz
ozc -x test.oz
 
clean:
-rm test
-rm scriptedmain
-rm *.ozf
-rm *.exe
</syntaxhighlight>
 
scriptedmain.oz:
<syntaxhighlight lang="oz">functor
export
meaningOfLife: MeaningOfLife
import
System
Application
Property
Regex at 'x-oz://contrib/regex'
define
fun {MeaningOfLife} 42 end
 
local ScriptName = {Property.get 'application.url'} in
if {Regex.search "scriptedmain" ScriptName} \= false then
{System.printInfo "Main: The meaning of life is "#{Int.toString {MeaningOfLife}}#"\n"}
{Application.exit 0}
end
end
end
</syntaxhighlight>
 
test.oz:
<syntaxhighlight lang="oz">functor
import
ScriptedMain
System
Application
Property
Regex at 'x-oz://contrib/regex'
define
local ScriptName = {Property.get 'application.url'} in
if {Regex.search "test" ScriptName} \= false then
{System.printInfo "Test: The meaning of life is "#{Int.toString {ScriptedMain.meaningOfLife}}#"\n"}
{Application.exit 0}
end
end
end</syntaxhighlight>
 
=={{header|newLISP}}==
Line 378 ⟶ 1,175:
scriptedmain.lsp
 
<langsyntaxhighlight lang="lisp">#!/usr/bin/env newlisp
 
(context 'SM)
Line 390 ⟶ 1,187:
(if (find "scriptedmain" (main-args 1)) (main))
 
(context MAIN)</langsyntaxhighlight>
 
test.lsp
 
<langsyntaxhighlight lang="lisp">#!/usr/bin/env newlisp
 
(load "scriptedmain.lsp")
(println (format "Test: The meaning of life is %d" (SM:meaning-of-life)))
(exit)</langsyntaxhighlight>
 
=={{header|Nim}}==
Nim provides the predicate <code>isMainModule</code> to use with conditional compilation. Here is an example:
 
<syntaxhighlight lang="Nim">proc p*() =
## Some exported procedure.
echo "Executing procedure"
 
# Some code to execute to initialize the module.
echo "Initializing the module"
 
when isMainModule:
# Some code to execute if the module is run directly, for instance code to test the module.
echo "Running tests"
</syntaxhighlight>
 
{{out}}
When run directly, the result of execution is:
<pre>Initializing the module
Running tests
</pre>
If we call “p” from another module, we get:
<pre>Initializing the module
Executing procedure
</pre>
 
=={{header|Objective-C}}==
 
scriptedmain.h:
 
<syntaxhighlight lang="objc">#import <objc/Object.h>
 
@interface ScriptedMain: Object {}
 
+ (int)meaningOfLife;
 
@end</syntaxhighlight>
 
scriptedmain.m:
 
<syntaxhighlight lang="objc">#import "scriptedmain.h"
#import <Foundation/Foundation.h>
 
@implementation ScriptedMain
 
+ (int)meaningOfLife {
return 42;
}
 
@end
 
int __attribute__((weak)) main(int argc, char **argv) {
@autoreleasepool {
 
printf("Main: The meaning of life is %d\n", [ScriptedMain meaningOfLife]);
 
}
 
return 0;
}</syntaxhighlight>
 
test.m:
 
<syntaxhighlight lang="objc">#import "scriptedmain.h"
#import <Foundation/Foundation.h>
 
int main(int argc, char **argv) {
@autoreleasepool {
 
printf("Test: The meaning of life is %d\n", [ScriptedMain meaningOfLife]);
 
}
 
return 0;
}</syntaxhighlight>
 
<syntaxhighlight lang="sh">$ gcc -o scriptedmain -lobjc -framework foundation scriptedmain.m
$ gcc -o test -lobjc -framework foundation test.m scriptedmain.m
$ ./scriptedmain
Main: The meaning of life is 42
$ ./test
Test: The meaning of life is 42</syntaxhighlight>
 
=={{header|OCaml}}==
 
scriptedmain.ml
 
<syntaxhighlight lang="ocaml">let meaning_of_life = 42
 
let main () =
Printf.printf "Main: The meaning of life is %d\n"
meaning_of_life
 
let () =
if not !Sys.interactive then
main ()</syntaxhighlight>
 
Invoked as a script:
 
<syntaxhighlight lang="sh">$ ocaml scriptedmain.ml
Main: The meaning of life is 42</syntaxhighlight>
 
Loaded into an ocaml toplevel/utop:
 
<syntaxhighlight lang="text">$ ocaml
...
# #use "scriptedmain.ml";;
val meaning_of_life : int = 42
val main : unit -> unit = <fun>
# meaning_of_life;;
- : int = 42
# </syntaxhighlight>
 
The limit of this technique is "avoiding running something when loading a script interactively". It's not applicable to other uses, like adding an example script to a file normally used as a library, as that code will also fire when users of the library are run.
 
=={{header|Octave}}/{{header|MATLAB}}==
Line 405 ⟶ 1,316:
meaningoflife.m
 
<langsyntaxhighlight lang="matlab">#!/usr/bin/env octave -qf
 
function y = meaning_of_lifemeaningoflife()
y = 42;
endfunction
 
function main()
printf("Main: The meaning of life is %d\n", meaning_of_lifemeaningoflife());
endfunction
 
main();</langsyntaxhighlight>
 
test.m
 
<langsyntaxhighlight lang="matlab">#!/usr/bin/env octave -qf
 
printf("Test: The meaning of life is %d\n", meaning_of_lifemeaningoflife());</langsyntaxhighlight>
 
=={{header|Pascal}}==
{{works with|Free_Pascal}}
Makefile:
 
<syntaxhighlight lang="make">all: scriptedmain
 
scriptedmain: scriptedmain.pas
fpc -dscriptedmain scriptedmain.pas
 
test: test.pas scriptedmain
fpc test.pas
 
clean:
-rm test
-rm scriptedmain
-rm *.o
-rm *.ppu</syntaxhighlight>
 
scriptedmain.pas:
 
<syntaxhighlight lang="pascal">{$IFDEF scriptedmain}
program ScriptedMain;
{$ELSE}
unit ScriptedMain;
interface
function MeaningOfLife () : integer;
implementation
{$ENDIF}
function MeaningOfLife () : integer;
begin
MeaningOfLife := 42
end;
{$IFDEF scriptedmain}
begin
write('Main: The meaning of life is: ');
writeln(MeaningOfLife())
{$ENDIF}
end.</syntaxhighlight>
 
test.pas:
 
<syntaxhighlight lang="pascal">program Test;
uses
ScriptedMain;
begin
write('Test: The meaning of life is: ');
writeln(MeaningOfLife())
end.</syntaxhighlight>
 
Example:
 
<syntaxhighlight lang="sh">$ make
$ ./scriptedmain
Main: The meaning of life is: 42
$ make test
$ ./test
Test: The meaning of life is: 42</syntaxhighlight>
 
=={{header|Perl}}==
Perl has scripted main. The code inside <tt>unless(caller) { ... }</tt> only runs when <tt>Life.pm</tt> is the main program.
Perl has scripted main.
 
<syntaxhighlight lang="perl">#!/usr/bin/env perl
scriptedmain.pm
 
# Life.pm
<lang perl>#!/usr/bin/env perl
package Life;
 
use strict;
use warnings;
 
sub meaning_of_life {
Line 436 ⟶ 1,407:
}
 
unless(caller) {
sub main {
print "Main: The meaning of life is " . meaning_of_life() . "\n";
}</syntaxhighlight>
}
 
<syntaxhighlight lang="perl">#!/usr/bin/env perl
unless(caller) { main; }</lang>
 
test# death.pl
use strict;
use warnings;
 
use Life;
<lang perl>#!/usr/bin/env perl
 
print "Life means " . Life::meaning_of_life . ".\n";
use strict;
print "Death means invisible scary skeletons.\n";</syntaxhighlight>
use ScriptedMain;
 
=={{header|Phix}}==
print "Test: The meaning of life is " . meaning_of_life() . "\n";</lang>
There is a builtin for this, which can even be asked to skip an arbitrary number of stack frames and that way find out exactly where it was effectively called from.
<!--<syntaxhighlight lang="phix">(notonline)-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (includefile)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">mori</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">include_file</span><span style="color: #0000FF;">()=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">?</span><span style="color: #008000;">"main"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"an include"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
 
=={{header|PHP}}==
Line 456 ⟶ 1,434:
scriptedmain.php
 
<langsyntaxhighlight lang="php"><?php
function meaning_of_life() {
return 42;
Line 468 ⟶ 1,446:
main($argv);
}
?></langsyntaxhighlight>
 
test.php
 
<langsyntaxhighlight lang="php"><?php
require_once("scriptedmain.php");
echo "Test: The meaning of life is " . meaning_of_life() . "\n";
?></langsyntaxhighlight>
 
=={{header|PicoLisp}}==
PicoLisp normally does it the other way round: It calls main from the command line with the '-' syntax if desired. Create an executable file (chmod +x) "life.l":
<syntaxhighlight lang="picolisp">#!/usr/bin/picolisp /usr/lib/picolisp/lib.l
 
(de meaningOfLife ()
42 )
 
(de lifemain ()
(prinl "Main: The meaning of life is " (meaningOfLife))
(bye) )</syntaxhighlight>
and an executable file (chmod +x) "test.l":
<syntaxhighlight lang="picolisp">#!/usr/bin/picolisp /usr/lib/picolisp/lib.l
 
(load "life.l")
 
(prinl "Test: The meaning of life is " (meaningOfLife))
(bye)</syntaxhighlight>
Test:
<pre>$ ./life.l -lifemain
Main: The meaning of life is 42
 
$ ./test.l
Test: The meaning of life is 42</pre>
 
=={{header|Python}}==
Python has scripted main.
 
<syntaxhighlight lang="python">#!/usr/bin/env python
scriptedmain.py
 
# life.py
<lang python>#!/usr/bin/env python
 
def meaning_of_life():
return 42
 
if __name__ == "__main__":
def main():
print print("Main: The meaning of life is %s" % meaning_of_life())</syntaxhighlight>
 
<syntaxhighlight lang="python">#!/usr/bin/env python
if __name__=="__main__":
main()</lang>
 
test# death.py
 
from life import meaning_of_life
<lang python>#!/usr/bin/env python
 
print("Life means %s." % meaning_of_life())
import scriptedmain
print("Death means invisible scary skeletons.")</syntaxhighlight>
 
print "Test: The meaning of life is %s" % scriptedmain.meaning_of_life()</lang>
 
=={{header|R}}==
A way to check if code is running at "top level" is to check <code>length(sys.frames())</code>. This value will be zero for a file being run with <code>Rscript</code>, the <code>--file=</code> argument, or at the command line, and will be greater than 0 in all other conditions (such as package loading or code being sourced from another file.)
R does not have scripted main, but the feature is easily added with regular expressions.
 
<syntaxhighlight lang="r">#!/usr/bin/env Rscript
scriptedmain.R
 
<lang R>#!/usr/bin/Rscript
 
meaningOfLife <- function() {
Line 512 ⟶ 1,510:
}
 
main <- function(program, args) {
cat("Main: The meaning of life is", meaningOfLife(), "\n")
}
 
if (length(sys.frames()) > 0) {
getProgram <- function(args) {
args <- commandArgs(trailingOnly = FALSE)
sub("--file=", "", args[grep("--file=", args)])
main(args)
}
 
args <- commandArgs(trailingOnly = FALSE)
program <- getProgram(args)
 
if (length(program) > 0 && length(grep("scriptedmain", program)) > 0) {
main(program, args)
q("no")
}</langsyntaxhighlight>
 
test.R
 
<langsyntaxhighlight Rlang="r">#!/usr/bin/env Rscript
 
source("scriptedmain.R")
Line 536 ⟶ 1,528:
cat("Test: The meaning of life is", meaningOfLife(), "\n")
 
q("no")</langsyntaxhighlight>
 
=={{header|Racket}}==
scriptedmain.rkt:
<syntaxhighlight lang="racket">#!/usr/bin/env racket
#lang racket
 
(provide meaning-of-life)
 
(define (meaning-of-life) 42)
 
(module+ main (printf "Main: The meaning of life is ~a\n" (meaning-of-life)))</syntaxhighlight>
 
test.rkt:
<syntaxhighlight lang="racket">#!/usr/bin/env racket
#lang racket
 
(module+ main
(require "scriptedmain.rkt")
(printf "Test: The meaning of life is ~a\n" (meaning-of-life)))</syntaxhighlight>
 
=={{header|Raku}}==
(formerly Perl 6)
Raku automatically calls MAIN on direct invocation, but this may be a multi dispatch, so a library may have multiple "scripted mains".
<syntaxhighlight lang="raku" line>class LUE {
has $.answer = 42;
}
 
multi MAIN ('test') {
say "ok" if LUE.new.answer == 42;
}
 
multi MAIN ('methods') {
say ~LUE.^methods;
}</syntaxhighlight>
 
=={{header|REXX}}==
<syntaxhighlight lang="rexx">/*REXX program detects whether or not it is a "scripted main" program. */
parse source . howInvoked @fn /*query REXX how this pgm got invoked. */
 
say 'This program ('@fn") was invoked as a: " howInvoked
 
if howInvoked\=='COMMAND' then do
say 'This program ('@fn") wasn't invoked via a command."
exit 12
end
 
/*╔════════════════════════════════════════════════════════════════════════════════╗
║ At this point, we know that this program was invoked via the "command line" ║
║ or a program using the "command interface" and not via another program. ║
╚════════════════════════════════════════════════════════════════════════════════╝*/
 
/*────────────────────────────── The main code follows here ... ────────────────────────*/
say
say '(from' @fn"): and away we go ···"</syntaxhighlight> <br><br>
 
=={{header|Ring}}==
<syntaxhighlight lang="ring">
# Project : Modulinos
 
func meaningoflife()
y = 42
return y
func main()
see "Main: The meaning of life is " + meaningoflife() + nl
</syntaxhighlight>
Output:
<pre>
Main: The meaning of life is 42
</pre>
 
=={{header|Ruby}}==
Ruby has scripted main.
 
<syntaxhighlight lang="ruby"># life.rb
scriptedmain.rb
 
<lang ruby>#!/usr/bin/env ruby
 
def meaning_of_life
42
end
 
def main
puts "Main: The meaning of life is #{meaning_of_life}"
end
 
if __FILE__ == $0
puts "Main: The meaning of life is #{meaning_of_life}"
main
end</langsyntaxhighlight>
 
<syntaxhighlight lang="ruby"># death.rb
test.rb
 
require 'life'
<lang ruby>#!/usr/bin/env ruby
 
puts "Life means #{meaning_of_life}."
require "scriptedmain"
puts "Death means invisible scary skeletons."</syntaxhighlight>
 
=={{header|Rust}}==
puts "Test: The meaning of life is #{meaning_of_life}"</lang>
'''Note:''' this code is deprecated, and does not compile with Rust 1.0.0 and newer.
 
Makefile:
<syntaxhighlight lang="make">all: scriptedmain
 
scriptedmain: scriptedmain.rs
rustc scriptedmain.rs
 
test: test.rs scriptedmain.rs
rustc --lib scriptedmain.rs
rustc test.rs -L .
 
clean:
-rm test
-rm -rf *.dylib
-rm scriptedmain
-rm -rf *.dSYM</syntaxhighlight>
 
scriptedmain.rs:
<syntaxhighlight lang="rust">#[link(name = "scriptedmain")];
 
use std;
 
fn meaning_of_life() -> int {
ret 42;
}
 
fn main() {
std::io::println("Main: The meaning of life is " + core::int::to_str(meaning_of_life(), 10u));
}</syntaxhighlight>
 
test.rs:
<syntaxhighlight lang="rust">use scriptedmain;
use std;
 
fn main() {
std::io::println("Test: The meaning of life is " + core::int::to_str(scriptedmain::meaning_of_life(), 10u));
}</syntaxhighlight>
 
Example:
<syntaxhighlight lang="sh">$ make
$ make test
$ ./scriptedmain
Main: The meaning of life is 42
$ ./test
Test: The meaning of life is 42</syntaxhighlight>
 
=={{header|SAC}}==
Makefile:
<syntaxhighlight lang="make">all: scriptedmain
 
scriptedmain: ScriptedMain.sac
sac2c -o scriptedmain ScriptedMain.sac -Dscriptedmain
 
test: test.sac ScriptedMain.sac
sac2c ScriptedMain.sac
sac2c -o test test.sac
 
clean:
-rm test
-rm test.c
-rm libScriptedMainTree.so
-rm libScriptedMainMod.so
-rm libScriptedMainMod.a
-rm scriptedmain
-rm scriptedmain.c</syntaxhighlight>
 
ScriptedMain.sac:
<syntaxhighlight lang="c">#ifndef scriptedmain
module ScriptedMain;
#endif
 
use StdIO: all;
use Array: all;
export all;
 
int meaning_of_life() {
return(42);
}
 
#ifdef scriptedmain
int main() {
printf("Main: The meaning of life is %d\n", meaning_of_life());
return(0);
}
#endif</syntaxhighlight>
 
test.sac:
<syntaxhighlight lang="c">use StdIO: all;
use Array: all;
use ScriptedMain: all;
 
int main() {
printf("Test: The meaning of life is %d\n", meaning_of_life());
return(0);
}</syntaxhighlight>
 
Example:
<syntaxhighlight lang="sh">$ make
$ make test
$ ./scriptedmain
Main: The meaning of life is 42
$ ./test
Test: The meaning of life is 42</syntaxhighlight>
 
=={{header|Scala}}==
{{libheader|Scala}}
{{works with|Scala|2.10.2}}
 
===Unix shell script===
This code must be stored as a shell script.
<syntaxhighlight lang="bash">#!/bin/sh
exec scala "$0" "$@"
!#
def hailstone(n: Int): Stream[Int] =
n #:: (if (n == 1) Stream.empty else hailstone(if (n % 2 == 0) n / 2 else n * 3 + 1))
 
val nr = argv.headOption.map(_.toInt).getOrElse(27)
val collatz = hailstone(nr)
println(s"Use the routine to show that the hailstone sequence for the number: $nr.")
println(collatz.toList)
println(s"It has ${collatz.length} elements.")</syntaxhighlight>
 
===Windows Command Script===
This code must be stored as a Windows Command Script e.g. Hailstone.cmd
<syntaxhighlight lang="winbatch">::#!
@echo off
call scala %0 %*
pause
goto :eof
::!#
def hailstone(n: Int): Stream[Int] =
n #:: (if (n == 1) Stream.empty else hailstone(if (n % 2 == 0) n / 2 else n * 3 + 1))
 
val nr = argv.headOption.map(_.toInt).getOrElse(27)
val collatz = hailstone(nr)
println(s"Use the routine to show that the hailstone sequence for the number: $nr.")
println(collatz.toList)
println(s"It has ${collatz.length} elements.")
</syntaxhighlight>
{{out}}
<pre>C:\>Hailstone.cmd 42
Use the routine to show that the hailstone sequence for the number: 42.
List(42, 21, 64, 32, 16, 8, 4, 2, 1)
It has 9 elements.</pre>
 
=={{header|Scheme}}==
{{Works with|Chicken Scheme}}
Chicken Scheme has the {{{ -ss }}} flag for the interpreter, but compiled Chicken Scheme programs do not have scripted main unless the behavior is added manually to the code.
 
scriptedmain.scm
 
<syntaxhighlight lang="scheme">#!/bin/sh
#|
exec csi -ss $0 ${1+"$@"}
exit
|#
 
(use posix)
(require-extension srfi-1) ; lists
 
(define (meaning-of-life) 42)
 
(define (main args)
(display (format "Main: The meaning of life is ~a\n" (meaning-of-life)))
(exit))
 
(define (program)
(if (string=? (car (argv)) "csi")
(let ((s-index (list-index (lambda (x) (string-contains x "-s")) (argv))))
(if (number? s-index)
(cons 'interpreted (list-ref (argv) (+ 1 s-index)))
(cons 'unknown "")))
(cons 'compiled (car (argv)))))
 
(if (equal? (car (program)) 'compiled)
(main (cdr (argv))))</syntaxhighlight>
 
test.scm
 
<syntaxhighlight lang="scheme">#!/bin/sh
#|
exec csi -ss $0 ${1+"$@"}
exit
|#
(define (main args)
(load "scriptedmain.scm")
(display (format "Test: The meaning of life is ~a\n" (meaning-of-life)))
(exit))</syntaxhighlight>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby"># Life.sm
 
func meaning_of_life {
42
}
 
if (__FILE__ == __MAIN__) {
say "Main: The meaning of life is #{meaning_of_life()}"
}</syntaxhighlight>
 
<syntaxhighlight lang="ruby"># test.sf
 
include Life
 
say "Test: The meaning of life is #{Life::meaning_of_life()}."</syntaxhighlight>
 
=={{header|Smalltalk}}==
 
Note that the ScriptedMain package must be installed in order for test.st to access code from scriptedmain.st.
 
Example
 
<syntaxhighlight lang="shell">$ gst-package -t ~/.st package.xml &>/dev/null
 
$ ./scriptedmain.st
Main: The meaning of life is 42
 
$ ./test.st
Test: The meaning of life is 42</syntaxhighlight>
 
package.xml
 
<syntaxhighlight lang="xml"><packages>
<package>
<name>ScriptedMain</name>
<filein>scriptedmain.st</filein>
<file>scriptedmain.st</file>
</package>
</packages></syntaxhighlight>
 
scriptedmain.st
 
<syntaxhighlight lang="smalltalk">"exec" "gst" "-f" "$0" "$0" "$@"
"exit"
 
Object subclass: ScriptedMain [
ScriptedMain class >> meaningOfLife [ ^42 ]
]
 
| main |
 
main := [
Transcript show: 'Main: The meaning of life is ', ((ScriptedMain meaningOfLife) printString); cr.
].
 
(((Smalltalk getArgc) > 0) and: [ ((Smalltalk getArgv: 1) endsWith: 'scriptedmain.st') ]) ifTrue: [
main value.
].</syntaxhighlight>
 
test.st
 
<syntaxhighlight lang="smalltalk">"exec" "gst" "-f" "$0" "$0" "$@"
"exit"
 
"
PackageLoader fileInPackage: 'ScriptedMain'.
 
Transcript show: 'Test: The meaning of life is ', ((ScriptedMain meaningOfLife) printString); cr.</syntaxhighlight>
 
=={{header|Swift}}==
 
Swift requires a number of hacks and boilerplate, but it is possible to write a modulino nevertheless.
 
Example
 
<syntaxhighlight lang="shell">$ make
mkdir -p bin/
swiftc -D SCRIPTEDMAIN -o bin/ScriptedMain ScriptedMain.swift
swiftc -emit-library -module-name ScriptedMain -emit-module ScriptedMain.swift
mkdir -p bin/
swiftc -D TEST -o bin/Test Test.swift -I "." -L "." -lScriptedMain -module-link-name ScriptedMain
bin/ScriptedMain
Main: The meaning of life is 42
bin/Test
Test: The meaning of life is 42</syntaxhighlight>
 
Makefile
 
<syntaxhighlight lang="make">all: bin/ScriptedMain bin/Test
bin/ScriptedMain
bin/Test
 
bin/ScriptedMain: ScriptedMain.swift
mkdir -p bin/
swiftc -D SCRIPTEDMAIN -o bin/ScriptedMain ScriptedMain.swift
 
ScriptedMain.swiftmodule: ScriptedMain.swift
swiftc -emit-library -module-name ScriptedMain -emit-module ScriptedMain.swift
 
bin/Test: Test.swift ScriptedMain.swiftmodule
mkdir -p bin/
swiftc -D TEST -o bin/Test Test.swift -I "." -L "." -lScriptedMain -module-link-name ScriptedMain
 
clean:
-rm -rf bin/
-rm *.swiftmodule
-rm *.swiftdoc
-rm *.dylib
</syntaxhighlight>
 
ScriptedMain.swift
 
<syntaxhighlight lang="swift">import Foundation
 
public class ScriptedMain {
public var meaningOfLife = 42
 
public init() {}
 
public class func main() {
var meaning = ScriptedMain().meaningOfLife
 
println("Main: The meaning of life is \(meaning)")
}
}
 
#if SCRIPTEDMAIN
@objc class ScriptedMainAutoload {
@objc class func load() {
ScriptedMain.main()
}
}
#endif
</syntaxhighlight>
 
Test.swift
 
<syntaxhighlight lang="swift">import Foundation
import ScriptedMain
 
public class Test {
public class func main() {
var meaning = ScriptedMain().meaningOfLife
 
println("Test: The meaning of life is \(meaning)")
}
}
 
#if TEST
@objc class TestAutoload {
@objc class func load() {
Test.main()
}
}
#endif
</syntaxhighlight>
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">proc main {args} {
puts "Directory: [pwd]"
puts "Program: $::argv0"
Line 575 ⟶ 1,979:
if {$::argv0 eq [info script]} {
main {*}$::argv
}</langsyntaxhighlight>
 
=={{header|UNIX Shell}}==
Line 582 ⟶ 1,986:
scriptedmain.sh
 
<langsyntaxhighlight lang="sh">#!/usr/bin/env sh
 
meaning_of_life() {
Line 596 ⟶ 2,000:
then
main
fi</langsyntaxhighlight>
 
test.sh
 
<syntaxhighlight lang ="sh">#!/usr/bin/env shbash
 
source scriptedmain.sh
path=$(dirname -- "$0")
source "$path/scriptedmain"
 
meaning_of_life
echo "Test: The meaning of life is $?"</lang>
</syntaxhighlight>
 
=={{header|Wren}}==
As far as Wren is concerned, a modulino and an executable library seem to be different names for the same thing. This therefore uses the same technique as the [[Executable_library#Wren]] task to create a simple modulino.
 
Note that Wren doesn't need or normally use a ''main()'' function to start a script, though we use one here to make the example clearer.
 
First we create a module for our modulino:
<syntaxhighlight lang="wren">/* Modulinos.wren */
 
var MeaningOfLife = Fn.new { 42 }
 
var main = Fn.new {
System.print("The meaning of life is %(MeaningOfLife.call()).")
}
 
// Check if it's being used as a library or not.
import "os" for Process
if (Process.allArguments[1] == "Modulinos.wren") { // if true, not a library
main.call()
}</syntaxhighlight>
 
and run it to make sure it works OK when run directly:
{{output}}
<pre>
The meaning of life is 42.
</pre>
 
Next we create another module which imports the modulino:
<syntaxhighlight lang="wren">/* Modulinos_main.wren */
 
import "./Modulinos" for MeaningOfLife
 
var main = Fn.new {
System.print("Who says the meaning of life is %(MeaningOfLife.call())?")
}
 
main.call()</syntaxhighlight>
 
and run this to make sure the modulino's ''main()'' function doesn't run:
{{output}}
<pre>
Who says the meaning of life is 42?
</pre>
 
=={{header|ZX Spectrum Basic}}==
 
On the ZX Spectrum, there is no main function as such, however a saved program can be made to start running from a particular line number by providing the line number as a parameter to save command. If the program is being merged as a module, then it does not run automatically. The following example will save the program in memory so that it starts running from line 500:
 
<syntaxhighlight lang="zxbasic">SAVE "MYPROG" LINE 500: REM For a program with main code starting at line 500</syntaxhighlight>
 
{{omit from|Ada}}
PureFox
9,482

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/174011...350597"