Modulinos
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. A script that behaves this way is called a modulino.
Examples from https://github.com/mcandre/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.
11l
// life.11l
F meaning_of_life()
R ‘*’.code
:start:
print(‘Main: The meaning of life is ’meaning_of_life())
// death.11l
print(‘Life means ’life:meaning_of_life()‘.’)
print(‘Death means nothing.’)
AppleScript
AppleScript's equivalent of a main() function is a run handler, which can be either implicit or explicit:
display dialog "Hello"
or
on run
display dialog "Hello"
end run
A run 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 load script and run script 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:
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
Arturo
Library
; modulinos - library
meaningOfLife: function [][
42
]
if standalone? ->
print ~"Library: The meaning of life is |meaningOfLife|"
- Output:
Library: The meaning of life is 42
Main
do.import relative "modulinos - library.art"
print ~"Life means |meaningOfLife|."
print "Death means invisible scary skeletons."
- Output:
Life means 42. Death means invisible scary skeletons.
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. However, preprocessor instructions can hide main unless a compiler flag is explicitly set.
Example
$ make
./scriptedmain
Main: The meaning of life is 42
./test
Test: The meaning of life is
Makefile
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
scriptedmain.h
int meaning_of_life();
scriptedmain.c
#include <stdio.h>
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
test.c
#include "scriptedmain.h"
#include <stdio.h>
extern int meaning_of_life();
int main(int argc, char **argv) {
printf("Test: The meaning of life is %d\n", meaning_of_life());
return 0;
}
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. Preprocessor instructions can hide main() unless a compiler flat is explicitly set.
Example
$ make
./scriptedmain
Main: The meaning of life is 42
./test
Test: The meaning of life is 42
Makefile
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
scriptedmain.h
int meaning_of_life();
scriptedmain.cpp
#include <iostream>
using namespace std;
int meaning_of_life() {
return 42;
}
#ifdef SCRIPTEDMAIN
int main() {
cout << "Main: The meaning of life is " << meaning_of_life() << endl;
return 0;
}
#endif
test.cpp
#include "scriptedmain.h"
#include <iostream>
using namespace std;
extern int meaning_of_life();
int main() {
cout << "Test: The meaning of life is " << meaning_of_life() << endl;
return 0;
}
Clojure
Uses lein-exec.
scriptedmain.clj:
":";exec lein exec $0 ${1+"$@"}
":";exit
(ns scriptedmain
(:gen-class))
(defn meaning-of-life [] 42)
(defn -main [& args]
(println "Main: The meaning of life is" (meaning-of-life)))
(when (.contains (first *command-line-args*) *source-path*)
(apply -main (rest *command-line-args*)))
test.clj:
":";exec lein exec $0 ${1+"$@"}
":";exit
(ns test
(:gen-class))
(load-string (slurp "scriptedmain.clj"))
(defn -main [& args]
(println "Test: The meaning of life is" (scriptedmain/meaning-of-life)))
(when (.contains (first *command-line-args*) *source-path*)
(apply -main (rest *command-line-args*)))
CoffeeScript
scriptedmain.coffee:
#!/usr/bin/env coffee
meaningOfLife = () -> 42
exports.meaningOfLife = meaningOfLife
main = () ->
console.log "Main: The meaning of life is " + meaningOfLife()
if not module.parent then main()
test.coffee:
#!/usr/bin/env coffee
sm = require "./scriptedmain"
console.log "Test: The meaning of life is " + sm.meaningOfLife()
Common Lisp
Common Lisp has few standards for POSIX operation. Shebangs and command line arguments are hacks.
In CLISP, this code only works for ./scriptedmain.lisp.
~/.clisprc.lisp
;;; Play nice with shebangs
(set-dispatch-macro-character #\# #\!
(lambda (stream character n)
(declare (ignore character n))
(read-line stream nil nil t)
nil))
scriptedmain.lisp
#!/bin/sh
#|
exec clisp -q -q $0 $0 ${1+"$@"}
exit
|#
;;; Usage: ./scriptedmain.lisp
(defun meaning-of-life () 42)
(defun main (args)
(format t "Main: The meaning of life is ~a~%" (meaning-of-life))
(quit))
;;; With help from Francois-Rene Rideau
;;; http://tinyurl.com/cli-args
(let ((args
#+clisp ext:*args*
#+sbcl sb-ext:*posix-argv*
#+clozure (ccl::command-line-arguments)
#+gcl si:*command-args*
#+ecl (loop for i from 0 below (si:argc) collect (si:argv i))
#+cmu extensions:*command-line-strings*
#+allegro (sys:command-line-arguments)
#+lispworks sys:*line-arguments-list*
))
(if (member (pathname-name *load-truename*)
args
:test #'(lambda (x y) (search x y :test #'equalp)))
(main args)))
test.lisp
#!/bin/sh
#|
exec clisp -q -q $0 $0 ${1+"$@"}
exit
|#
(load "scriptedmain.lisp")
(format t "Test: The meaning of life is ~a~%" (meaning-of-life))
D
D manages to implement scriptedmain through the use of version directives, which require special options to rdmd and dmd.
scriptedmain.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());
}
}
test.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());
}
}
Example:
$ ./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
Dart
scriptedmain.dart:
#!/usr/bin/env dart
#library("scriptedmain");
meaningOfLife() {
return 42;
}
main() {
print("Main: The meaning of life is ${meaningOfLife()}");
}
test.dart:
#!/usr/bin/env dart
#import("scriptedmain.dart", prefix: "scriptedmain");
main() {
print("Test: The meaning of life is ${scriptedmain.meaningOfLife()}");
}
Example:
$ ./scriptedmain.dart
Main: The meaning of life is 42
$ ./test.dart
Test: The meaning of life is 42
Emacs Lisp
Emacs has scripted main, though older versions require an obscure shebang syntax.
scriptedmain.el
:;exec emacs -batch -l $0 -f main $*
;;; Shebang from John Swaby
;;; http://www.emacswiki.org/emacs/EmacsScripts
(defun meaning-of-life () 42)
(defun main ()
(message "Main: The meaning of life is %d" (meaning-of-life)))
test.el
:;exec emacs -batch -l $0 -f main $*
;;; Shebang from John Swaby
;;; http://www.emacswiki.org/emacs/EmacsScripts
(defun main ()
(setq load-path (cons default-directory load-path))
(load "scriptedmain.el" nil t)
(message "Test: The meaning of life is %d" (meaning-of-life)))
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
- Output:
emal.exe Org\RosettaCode\ModulinosPart.emal The meaning of life is 42.
^|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)
- Output:
emal.exe Org\RosettaCode\Modulinos.emal Who says the meaning of life is 42?
Erlang
Erlang has scripted main by default. scriptedmain.erl must be compiled before test.erl can access its functions.
Makefile:
all: t
t: scriptedmain.beam test.beam
erl -noshell -s scriptedmain
erl -noshell -s test
scriptedmain.beam: scriptedmain.erl
erlc scriptedmain.erl
test.beam: test.erl
erlc test.erl
clean:
-rm *.beam
scriptedmain.erl:
-module(scriptedmain).
-export([meaning_of_life/0, start/0]).
meaning_of_life() -> 42.
start() ->
io:format("Main: The meaning of life is ~w~n", [meaning_of_life()]),
init:stop().
test.erl:
-module(test).
-export([start/0]).
-import(scriptedmain, [meaning_of_life/0]).
start() ->
io:format("Test: The meaning of life is ~w~n", [meaning_of_life()]),
init:stop().
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:
$ 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
Makefile:
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
ScriptedMain.fs:
namespace ScriptedMain
module ScriptedMain =
let meaningOfLife = 42
let main =
printfn "Main: The meaning of life is %d" meaningOfLife
Test.fs:
module Test =
open ScriptedMain
let main =
printfn "Test: The meaning of life is %d" ScriptedMain.meaningOfLife
Factor
Note: The INCLUDE/INCLUDING macros must be added to the ~/.factor-rc configuration file.
Example:
$ ./scriptedmain.factor
Main: The meaning of life is 42
$ ./test.factor
Test: The meaning of life is 42
~/.factor-rc:
! 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 ;
scriptedmain.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
test.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
Forth
Given this awful running reference:
42 constant Douglas-Adams
: go ( -- )
." The meaning of life is " Douglas-Adams . cr ;
The bulk of Forth systems provide a way to generate an executable that enters GO (ar any word) on start.
' go 'MAIN !
program douglas-adams
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.
#! /usr/bin/env gforth
42 constant Douglas-Adams
.( The meaning of life is ) Douglas-Adams . cr bye
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.
#! /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.)
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
- Output:
Main: The meaning of life is 42
Go
Go doesn't support scripted main directly.
Although the 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 [Executable library] task and split the 'main' package into two.
First create these two files in the 'modulino' directory:
// modulino.go
package main
import "fmt"
func MeaningOfLife() int {
return 42
}
func libMain() {
fmt.Println("The meaning of life is", MeaningOfLife())
}
// modulino_main.go
package main
func main() {
libMain()
}
To emulate a modulino:
- Output:
$ go run modulino The meaning of life is 42
Now create this file in the 'mol' directory:
// mol.go
package main
import "fmt"
func main() {
fmt.Println("The meaning of life is still", MeaningOfLife())
}
and copy modulino.go to the 'mol' directory. The library can then be used in the 'normal' way:
- Output:
$ go run mol The meaning of life is still 42
Groovy
Example:
$ ./ScriptedMain.groovy
Main: The meaning of life is 42
$ ./Test.groovy
Test: The meaning of life is 42
ScriptedMain.groovy:
#!/usr/bin/env groovy
class ScriptedMain {
static def meaningOfLife = 42
static main(args) {
println "Main: The meaning of life is " + meaningOfLife
}
}
Test.groovy:
#!/usr/bin/env groovy
println "Test: The meaning of life is " + ScriptedMain.meaningOfLife
Haskell
Haskell has scripted main, but getting scripted main to work with compiled scripts is tricky.
$ runhaskell scriptedmain.hs
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
scriptedmain.hs
#!/usr/bin/env runhaskell
-- Compile:
--
-- ghc -fforce-recomp -o scriptedmain -main-is ScriptedMain scriptedmain.hs
module ScriptedMain where
meaningOfLife :: Int
meaningOfLife = 42
main :: IO ()
main = putStrLn $ "Main: The meaning of life is " ++ show meaningOfLife
test.hs
#!/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
Io
ScriptedMain.io:
#!/usr/bin/env io
ScriptedMain := Object clone
ScriptedMain meaningOfLife := 42
if( isLaunchScript,
"Main: The meaning of life is #{ScriptedMain meaningOfLife}" interpolate println
)
test.io:
#!/usr/bin/env io
"Test: The meaning of life is #{ScriptedMain meaningOfLife}" interpolate println
$ ./ScriptedMain.io
Main: The meaning of life is 42
$ ./test.io
Test: The meaning of life is 42
J
modulinos.ijs:
#!/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
test.j:
#!/usr/bin/env jconsole
load 'modulinos.ijs'
echo 'Test: The meaning of life is ',": meaningOfLife
exit ''
Example:
$ ./modulinos.ijs
Main: The meaning of life is 42
$ ./test.j
Test: The meaning of life is 42
Java
Java has scripted main by default.
ScriptedMain.java
public class ScriptedMain {
public static int meaningOfLife() {
return 42;
}
public static void main(String[] args) {
System.out.println("Main: The meaning of life is " + meaningOfLife());
}
}
Test.java
public class Test {
public static void main(String[] args) {
System.out.println("Test: The meaning of life is " + ScriptedMain.meaningOfLife());
}
}
JavaScript
Note that JavaScript modulinos may break in NPM executable application publications, especially if version managers like ASDF, NVM, etc. are involved.
(ES modules)
Node.js has scripted main.
package.json
{ "type": "module" }
scriptedmain.js
#!/usr/bin/env node
'use strict';
export default function meaningOfLife() { return 42; }
function main() {
console.log("Main: The meaning of life is " + meaningOfLife());
}
if (import.meta.url === `file://${process.argv[1]}`) { main(); }
test.js
#!/usr/bin/env node
'use strict';
import meaningOfLife from "./scriptedmain.js";
console.log("Test: The meaning of life is " + meaningOfLife());
(classical CommonJS module type)
Node.js has scripted main.
scriptedmain.js
#!/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(); }
test.js
#!/usr/bin/env node
var sm = require("./scriptedmain");
console.log("Test: The meaning of life is " + sm.meaningOfLife());
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.
In module file Divisors.jl:
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
In a user file getdivisors.jl:
include("divisors.jl")
using .Divisors
n = 708245926330
println("The proper divisors of $n are ", properdivisors(n))
LLVM
LLVM can have scripted main a la C, using the weak attribute.
$ make
llvm-as scriptedmain.ll
llc scriptedmain.bc
gcc -o scriptedmain scriptedmain.s
./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
Makefile
EXECUTABLE_SM=scriptedmain
EXECUTABLE_TEST=test
all: test.ll scriptedmain.s
llvm-as test.ll
llc test.bc
gcc -o $(EXECUTABLE_TEST) test.s scriptedmain.s
./$(EXECUTABLE_TEST)
scriptedmain.s: scriptedmain.ll
llvm-as scriptedmain.ll
llc scriptedmain.bc
gcc -o $(EXECUTABLE_SM) scriptedmain.s
./$(EXECUTABLE_SM)
clean:
-rm $(EXECUTABLE_TEST)
-rm $(EXECUTABLE_SM)
-rm test.s
-rm test.bc
-rm scriptedmain.s
-rm scriptedmain.bc
scriptedmain.ll
@msg_main = internal constant [33 x i8] c"Main: The meaning of life is %d\0A\00"
declare i32 @printf(i8* noalias nocapture, ...)
define i32 @meaning_of_life() {
ret i32 42
}
define weak i32 @main(i32 %argc, i8** %argv) {
%meaning = call i32 @meaning_of_life()
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([33 x i8]* @msg_main, i32 0, i32 0), i32 %meaning)
ret i32 0
}
test.ll
@msg_test = internal constant [33 x i8] c"Test: The meaning of life is %d\0A\00"
declare i32 @printf(i8* noalias nocapture, ...)
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)
ret i32 0
}
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.
scriptedmain.lua
#!/usr/bin/env lua
function meaningoflife()
return 42
end
function main(arg)
print("Main: The meaning of life is " .. meaningoflife())
end
if type(package.loaded[(...)]) ~= "userdata" then
main(arg)
else
module(..., package.seeall)
end
test.lua
#!/usr/bin/env lua
sm = require("scriptedmain")
print("Test: The meaning of life is " .. sm.meaningoflife())
Make
Example
$ make -f scriptedmain.mf
The meaning of life is 42
(Main)
$ make -f test.mf
The meaning of life is 42
(Test)
scriptedmain.mf
all: scriptedmain
meaning-of-life:
@echo "The meaning of life is 42"
scriptedmain: meaning-of-life
@echo "(Main)"
test.mf
all: test
test:
@make -f scriptedmain.mf meaning-of-life
@echo "(Test)"
Mathematica /Wolfram Language
scriptedmain.ma
#!/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[]]]
]
test.ma:
#!/usr/bin/env MathKernel -script
Get["scriptedmain.ma"]
Print["Test: The meaning of life is " <> ToString[MeaningOfLife[]]]
Example:
$ ./scriptedmain.ma
Main: The meaning of life is 42
$ ./test.ma
Test: The meaning of life is 42
In Mac and Windows, the output will be surrounded by spurious quotes.
Mozart/Oz
Makefile:
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
scriptedmain.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
test.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
newLISP
newLISP lacks scripted main, but the feature is easily added.
scriptedmain.lsp
#!/usr/bin/env newlisp
(context 'SM)
(define (SM:meaning-of-life) 42)
(define (main)
(println (format "Main: The meaning of life is %d" (meaning-of-life)))
(exit))
(if (find "scriptedmain" (main-args 1)) (main))
(context MAIN)
test.lsp
#!/usr/bin/env newlisp
(load "scriptedmain.lsp")
(println (format "Test: The meaning of life is %d" (SM:meaning-of-life)))
(exit)
Nim
Nim provides the predicate isMainModule
to use with conditional compilation. Here is an example:
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"
- Output:
When run directly, the result of execution is:
Initializing the module Running tests
If we call “p” from another module, we get:
Initializing the module Executing procedure
Objective-C
scriptedmain.h:
#import <objc/Object.h>
@interface ScriptedMain: Object {}
+ (int)meaningOfLife;
@end
scriptedmain.m:
#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;
}
test.m:
#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;
}
$ 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
OCaml
scriptedmain.ml
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 ()
Invoked as a script:
$ ocaml scriptedmain.ml
Main: The meaning of life is 42
Loaded into an ocaml toplevel/utop:
$ ocaml
...
# #use "scriptedmain.ml";;
val meaning_of_life : int = 42
val main : unit -> unit = <fun>
# meaning_of_life;;
- : int = 42
#
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.
Octave /MATLAB
Octave and MATLAB have scripted main by default, because only the first function listed in a program are importable by other programs.
meaningoflife.m
#!/usr/bin/env octave -qf
function y = meaningoflife()
y = 42;
endfunction
function main()
printf("Main: The meaning of life is %d", meaningoflife());
endfunction
main();
test.m
#!/usr/bin/env octave -qf
printf("Test: The meaning of life is %d", meaningoflife());
Pascal
Makefile:
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
scriptedmain.pas:
{$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.
test.pas:
program Test;
uses
ScriptedMain;
begin
write('Test: The meaning of life is: ');
writeln(MeaningOfLife())
end.
Example:
$ make
$ ./scriptedmain
Main: The meaning of life is: 42
$ make test
$ ./test
Test: The meaning of life is: 42
Perl
Perl has scripted main. The code inside unless(caller) { ... } only runs when Life.pm is the main program.
#!/usr/bin/env perl
# Life.pm
package Life;
use strict;
use warnings;
sub meaning_of_life {
return 42;
}
unless(caller) {
print "Main: The meaning of life is " . meaning_of_life() . "\n";
}
#!/usr/bin/env perl
# death.pl
use strict;
use warnings;
use Life;
print "Life means " . Life::meaning_of_life . ".\n";
print "Death means invisible scary skeletons.\n";
Phix
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.
without js -- (includefile) string mori = iff(include_file()=1?"main":"an include")
PHP
PHP does not have scripted main, but the feature is easily added with a regular expression.
scriptedmain.php
<?php
function meaning_of_life() {
return 42;
}
function main($args) {
echo "Main: The meaning of life is " . meaning_of_life() . "\n";
}
if (preg_match("/scriptedmain/", $_SERVER["SCRIPT_NAME"])) {
main($argv);
}
?>
test.php
<?php
require_once("scriptedmain.php");
echo "Test: The meaning of life is " . meaning_of_life() . "\n";
?>
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":
#!/usr/bin/picolisp /usr/lib/picolisp/lib.l
(de meaningOfLife ()
42 )
(de lifemain ()
(prinl "Main: The meaning of life is " (meaningOfLife))
(bye) )
and an executable file (chmod +x) "test.l":
#!/usr/bin/picolisp /usr/lib/picolisp/lib.l
(load "life.l")
(prinl "Test: The meaning of life is " (meaningOfLife))
(bye)
Test:
$ ./life.l -lifemain Main: The meaning of life is 42 $ ./test.l Test: The meaning of life is 42
Python
Python has scripted main.
#!/usr/bin/env python
# life.py
def meaning_of_life():
return 42
if __name__ == "__main__":
print("Main: The meaning of life is %s" % meaning_of_life())
#!/usr/bin/env python
# death.py
from life import meaning_of_life
print("Life means %s." % meaning_of_life())
print("Death means invisible scary skeletons.")
R
A way to check if code is running at "top level" is to check length(sys.frames())
. This value will be zero for a file being run with Rscript
, the --file=
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.)
#!/usr/bin/env Rscript
meaningOfLife <- function() {
42
}
main <- function(args) {
cat("Main: The meaning of life is", meaningOfLife(), "\n")
}
if (length(sys.frames()) > 0) {
args <- commandArgs(trailingOnly = FALSE)
main(args)
q("no")
}
test.R
#!/usr/bin/env Rscript
source("scriptedmain.R")
cat("Test: The meaning of life is", meaningOfLife(), "\n")
q("no")
Racket
scriptedmain.rkt:
#!/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)))
test.rkt:
#!/usr/bin/env racket
#lang racket
(module+ main
(require "scriptedmain.rkt")
(printf "Test: The meaning of life is ~a\n" (meaning-of-life)))
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".
class LUE {
has $.answer = 42;
}
multi MAIN ('test') {
say "ok" if LUE.new.answer == 42;
}
multi MAIN ('methods') {
say ~LUE.^methods;
}
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 ···"
Ring
# Project : Modulinos
func meaningoflife()
y = 42
return y
func main()
see "Main: The meaning of life is " + meaningoflife() + nl
Output:
Main: The meaning of life is 42
Ruby
Ruby has scripted main.
# life.rb
def meaning_of_life
42
end
if __FILE__ == $0
puts "Main: The meaning of life is #{meaning_of_life}"
end
# death.rb
require 'life'
puts "Life means #{meaning_of_life}."
puts "Death means invisible scary skeletons."
Rust
Note: this code is deprecated, and does not compile with Rust 1.0.0 and newer.
Makefile:
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
scriptedmain.rs:
#[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));
}
test.rs:
use scriptedmain;
use std;
fn main() {
std::io::println("Test: The meaning of life is " + core::int::to_str(scriptedmain::meaning_of_life(), 10u));
}
Example:
$ make
$ make test
$ ./scriptedmain
Main: The meaning of life is 42
$ ./test
Test: The meaning of life is 42
SAC
Makefile:
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
ScriptedMain.sac:
#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
test.sac:
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);
}
Example:
$ make
$ make test
$ ./scriptedmain
Main: The meaning of life is 42
$ ./test
Test: The meaning of life is 42
Scala
Unix shell script
This code must be stored as a shell script.
#!/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.")
Windows Command Script
This code must be stored as a Windows Command Script e.g. Hailstone.cmd
::#!
@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.")
- Output:
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.
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
#!/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))))
test.scm
#!/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))
Sidef
# Life.sm
func meaning_of_life {
42
}
if (__FILE__ == __MAIN__) {
say "Main: The meaning of life is #{meaning_of_life()}"
}
# test.sf
include Life
say "Test: The meaning of life is #{Life::meaning_of_life()}."
Smalltalk
Note that the ScriptedMain package must be installed in order for test.st to access code from scriptedmain.st.
Example
$ 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
package.xml
<packages>
<package>
<name>ScriptedMain</name>
<filein>scriptedmain.st</filein>
<file>scriptedmain.st</file>
</package>
</packages>
scriptedmain.st
"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.
].
test.st
"exec" "gst" "-f" "$0" "$0" "$@"
"exit"
"
PackageLoader fileInPackage: 'ScriptedMain'.
Transcript show: 'Test: The meaning of life is ', ((ScriptedMain meaningOfLife) printString); cr.
Swift
Swift requires a number of hacks and boilerplate, but it is possible to write a modulino nevertheless.
Example
$ 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
Makefile
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
ScriptedMain.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
Test.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
Tcl
proc main {args} {
puts "Directory: [pwd]"
puts "Program: $::argv0"
puts "Number of args: [llength $args]"
foreach arg $args {puts "Arg: $arg"}
}
if {$::argv0 eq [info script]} {
main {*}$::argv
}
UNIX Shell
Bash has scripted main.
scriptedmain.sh
#!/usr/bin/env sh
meaning_of_life() {
return 42
}
main() {
meaning_of_life
echo "Main: The meaning of life is $?"
}
if [[ "$BASH_SOURCE" == "$0" ]]
then
main
fi
test.sh
#!/bin/bash
path=$(dirname -- "$0")
source "$path/scriptedmain"
meaning_of_life
echo "Test: The meaning of life is $?"
V (Vlang)
Place 'modulinos_1.v' in a folder named modulinos
module modulinos
pub fn meaning_of_life() int {return 42}
Create another file called modulino_main.v
module main
fn main() {println(modulinos.meaning_of_life())}
- Output:
42
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:
/* 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()
}
and run it to make sure it works OK when run directly:
- Output:
The meaning of life is 42.
Next we create another module which imports the modulino:
/* Modulinos_main.wren */
import "./Modulinos" for MeaningOfLife
var main = Fn.new {
System.print("Who says the meaning of life is %(MeaningOfLife.call())?")
}
main.call()
and run this to make sure the modulino's main() function doesn't run:
- Output:
Who says the meaning of life is 42?
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:
SAVE "MYPROG" LINE 500: REM For a program with main code starting at line 500