Modulinos: Difference between revisions

 

Sometimes getting the [[ScriptName]] is required in order to determine when to run main().

 

: ''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.''

 

=={{header|11l}}==

 

F meaning_of_life()

 

:start:

 

 

print(‘Life means ’life:meaning_of_life()‘.’)

 

=={{header|AppleScript}}==

AppleScript's equivalent of a main() function is a <tt>run</tt> handler, which can be either implicit or explicit:

 

or

display dialog "Hello"

 

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:

 

if ((path to me) = (path to current application)) then

display dialog "I'm running in my own application."

display dialog "I'm being run from another script or application."

end if

 

=={{header|Arturo}}==

===Library===

 

meaningOfLife: function [][

 

if standalone? ->

 

{{out}}

===Main===

 

print ~"Life means |meaningOfLife|."

 

{{out}}

Example

 

./scriptedmain

Main: The meaning of life is 42

./test

 

Makefile

 

./scriptedmain

./test

-rm test

-rm scriptedmain.exe

 

scriptedmain.h

 

 

scriptedmain.c

 

 

int meaning_of_life() {

}

 

 

test.c

 

#include <stdio.h>

 

printf("Test: The meaning of life is %d\n", meaning_of_life());

return 0;

 

=={{header|C++}}==

Example

 

./scriptedmain

Main: The meaning of life is 42

./test

 

Makefile

 

./scriptedmain

./test

-rm test

-rm scriptedmain.exe

 

scriptedmain.h

 

 

scriptedmain.cpp

 

 

using namespace std;

}

 

 

test.cpp

 

#include <iostream>

 

cout << "Test: The meaning of life is " << meaning_of_life() << endl;

return 0;

 

=={{header|Clojure}}==

 

scriptedmain.clj:

":";exit

 

 

(when (.contains (first *command-line-args*) *source-path*)

 

test.clj:

":";exit

 

 

(when (.contains (first *command-line-args*) *source-path*)

 

=={{header|CoffeeScript}}==

scriptedmain.coffee:

 

meaningOfLife = () -> 42

console.log "Main: The meaning of life is " + meaningOfLife()

 

 

test.coffee:

 

sm = require "./scriptedmain"

 

 

=={{header|Common Lisp}}==

~/.clisprc.lisp

 

(set-dispatch-macro-character #\# #\!

(lambda (stream character n)

(declare (ignore character n))

(read-line stream nil nil t)

 

scriptedmain.lisp

 

#|

exec clisp -q -q $0 $0 ${1+"$@"}

args

:test #'(lambda (x y) (search x y :test #'equalp)))

 

test.lisp

 

#|

exec clisp -q -q $0 $0 ${1+"$@"}

 

(load "scriptedmain.lisp")

 

=={{header|D}}==

scriptedmain.d:

 

 

module scriptedmain;

writeln("Main: The meaning of life is ", meaningOfLife());

}

 

test.d:

 

 

import scriptedmain;

writeln("Test: The meaning of life is ", meaningOfLife());

}

 

Example:

 

Main: The meaning of life is 42

$ ./test.d

$ dmd test.d scriptedmain.d -version=test

$ ./test

 

=={{header|Dart}}==

scriptedmain.dart:

 

#library("scriptedmain");

main() {

print("Main: The meaning of life is ${meaningOfLife()}");

 

test.dart:

 

#import("scriptedmain.dart", prefix: "scriptedmain");

main() {

print("Test: The meaning of life is ${scriptedmain.meaningOfLife()}");

 

Example:

Main: The meaning of life is 42

$ ./test.dart

 

=={{header|Emacs Lisp}}==

scriptedmain.el

 

 

;;; Shebang from John Swaby

 

(defun main ()

 

test.el

 

 

;;; Shebang from John Swaby

(setq load-path (cons default-directory load-path))

(load "scriptedmain.el" nil t)

 

=={{header|Erlang}}==

 

Makefile:

 

t: scriptedmain.beam test.beam

 

clean:

 

scriptedmain.erl:

-export([meaning_of_life/0, start/0]).

 

start() ->

io:format("Main: The meaning of life is ~w~n", [meaning_of_life()]),

 

test.erl:

-export([start/0]).

-import(scriptedmain, [meaning_of_life/0]).

start() ->

io:format("Test: The meaning of life is ~w~n", [meaning_of_life()]),

 

=={{header|F Sharp|F#}}==

Example:

 

fsharpc --out:scriptedmain.exe ScriptedMain.fs

fsharpc --out:test.exe ScriptedMain.fs Test.fs

Main: The meaning of life is 42

$ mono test.exe

 

Makefile:

 

 

scriptedmain.exe: ScriptedMain.fs

 

clean:

 

ScriptedMain.fs:

 

 

module ScriptedMain =

 

let main =

 

Test.fs:

 

open ScriptedMain

 

let main =

 

=={{header|Factor}}==

Example:

 

Main: The meaning of life is 42

$ ./test.factor

 

~/.factor-rc:

 

 

USING: kernel vocabs.loader parser sequences lexer vocabs.parser ;

: include-vocab ( vocab -- ) dup ".factor" append parse-file append use-vocab ;

 

 

scriptedmain.factor:

 

 

USING: io math.parser ;

: main ( -- ) meaning-of-life "Main: The meaning of life is " write number>string print ;

 

 

test.factor:

 

 

INCLUDING: scriptedmain ;

: main ( -- ) meaning-of-life "Test: The meaning of life is " write number>string print ;

 

 

=={{header|Forth}}==

Given this awful running reference:

 

 

: go ( -- )

 

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}}

 

 

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.

{{works with|gforth}}

 

 

42 constant Douglas-Adams

 

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}}

 

 

42 constant Douglas-Adams

[THEN]

 

 

=={{header|Go}}==

 

First create these two files in the 'modulino' directory:

package main

 

func libMain() {

fmt.Println("The meaning of life is", MeaningOfLife())

 

package main

func main() {

libMain()

 

To emulate a modulino:

 

Now create this file in the 'mol' directory:

package main

 

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:

{{out}}

Example:

 

Main: The meaning of life is 42

$ ./Test.groovy

 

ScriptedMain.groovy:

 

 

class ScriptedMain {

println "Main: The meaning of life is " + meaningOfLife

}

 

Test.groovy:

 

 

 

=={{header|Haskell}}==

Haskell has scripted main, but getting scripted main to work with compiled scripts is tricky.

 

Main: The meaning of life is 42

$ runhaskell test.hs

$ ghc -fforce-recomp -o test -main-is Test test.hs scriptedmain.hs

$ ./test

 

scriptedmain.hs

 

 

-- Compile:

 

main :: IO ()

 

test.hs

 

 

-- Compile:

 

main :: IO ()

 

=={{header|Io}}==

ScriptedMain.io:

 

 

ScriptedMain := Object clone

if( isLaunchScript,

"Main: The meaning of life is #{ScriptedMain meaningOfLife}" interpolate println

 

test.io:

 

 

 

Main: The meaning of life is 42

$ ./test.io

 

=={{header|J}}==

modulinos.ijs:

 

meaningOfLife =: 42

)

 

test.j:

 

 

load 'modulinos.ijs'

echo 'Test: The meaning of life is ',": meaningOfLife

 

 

Example:

 

Main: The meaning of life is 42

$ ./test.j

 

=={{header|Java}}==

ScriptedMain.java

 

public static int meaningOfLife() {

return 42;

System.out.println("Main: The meaning of life is " + meaningOfLife());

}

 

Test.java

 

public static void main(String[] args) {

System.out.println("Test: The meaning of life is " + ScriptedMain.meaningOfLife());

}

 

=={{header|JavaScript}}==

 

scriptedmain.js

 

function meaningOfLife() { return 42; }

}

 

 

test.js

 

var sm = require("./scriptedmain");

 

 

=={{header|Julia}}==

<br />

In module file Divisors.jl:

 

using Primes

Divisors.interactiveDivisors()

end

In a user file getdivisors.jl:

 

using .Divisors

n = 708245926330

println("The proper divisors of $n are ", properdivisors(n))

 

=={{header|LLVM}}==

LLVM can have scripted main a la C, using the weak attribute.

 

llvm-as scriptedmain.ll

llc scriptedmain.bc

gcc -o test test.s scriptedmain.s

./test

 

Makefile

 

EXECUTABLE_TEST=test

 

-rm test.bc

-rm scriptedmain.s

 

scriptedmain.ll

 

 

declare i32 @printf(i8* noalias nocapture, ...)

 

ret i32 0

 

test.ll

 

 

declare i32 @printf(i8* noalias nocapture, ...)

 

ret i32 0

 

=={{header|Lua}}==

scriptedmain.lua

 

 

function meaningoflife()

else

module(..., package.seeall)

 

test.lua

 

sm = require("scriptedmain")

 

=={{header|Make}}==

 

Example

The meaning of life is 42

(Main)

$ make -f test.mf

The meaning of life is 42

 

scriptedmain.mf

 

meaning-of-life:

scriptedmain: meaning-of-life

@echo "(Main)"

 

test.mf

 

test:

@make -f scriptedmain.mf meaning-of-life

@echo "(Test)"

 

 

scriptedmain.ma

 

MeaningOfLife[] = 42

If[StringMatchQ[Program, ".*scriptedmain.*"],

Print["Main: The meaning of life is " <> ToString[MeaningOfLife[]]]

 

test.ma:

 

Get["scriptedmain.ma"]

 

 

Example:

Main: The meaning of life is 42

$ ./test.ma

 

In Mac and Windows, the output will be surrounded by spurious quotes.

=={{header|Mozart/Oz}}==

Makefile:

 

run: scriptedmain test

-rm *.ozf

-rm *.exe

 

scriptedmain.oz:

export

meaningOfLife: MeaningOfLife

end

end

 

test.oz:

import

ScriptedMain

end

end

 

=={{header|newLISP}}==

scriptedmain.lsp

 

 

(context 'SM)

(if (find "scriptedmain" (main-args 1)) (main))

 

 

test.lsp

 

 

(load "scriptedmain.lsp")

(println (format "Test: The meaning of life is %d" (SM:meaning-of-life)))

 

=={{header|Objective-C}}==

scriptedmain.h:

 

 

@interface ScriptedMain: Object {}

+ (int)meaningOfLife;

 

 

scriptedmain.m:

 

#import <Foundation/Foundation.h>

 

 

return 0;

 

test.m:

 

#import <Foundation/Foundation.h>

 

 

return 0;

 

$ gcc -o test -lobjc -framework foundation test.m scriptedmain.m

$ ./scriptedmain

Main: The meaning of life is 42

$ ./test

 

=={{header|OCaml}}==

scriptedmain.ml

 

 

let main () =

let () =

if not !Sys.interactive then

 

Invoked as a script:

 

 

Loaded into an ocaml toplevel/utop:

 

...

# #use "scriptedmain.ml";;

# 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.

meaningoflife.m

 

 

function y = meaningoflife()

endfunction

 

 

test.m

 

 

 

=={{header|Pascal}}==

Makefile:

 

 

scriptedmain: scriptedmain.pas

-rm scriptedmain

-rm *.o

 

scriptedmain.pas:

 

program ScriptedMain;

{$ELSE}

writeln(MeaningOfLife())

{$ENDIF}

 

test.pas:

 

uses

ScriptedMain;

write('Test: The meaning of life is: ');

writeln(MeaningOfLife())

 

Example:

 

$ ./scriptedmain

Main: The meaning of life is: 42

$ make test

$ ./test

 

=={{header|Perl}}==

Perl has scripted main. The code inside <tt>unless(caller) { ... }</tt> only runs when <tt>Life.pm</tt> is the main program.

 

 

# Life.pm

unless(caller) {

print "Main: The meaning of life is " . meaning_of_life() . "\n";

 

 

# death.pl

 

print "Life means " . Life::meaning_of_life . ".\n";

 

=={{header|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.

 

=={{header|PHP}}==

scriptedmain.php

 

function meaning_of_life() {

return 42;

main($argv);

}

 

test.php

 

require_once("scriptedmain.php");

echo "Test: The meaning of life is " . meaning_of_life() . "\n";

 

=={{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":

 

(de meaningOfLife ()

(de lifemain ()

(prinl "Main: The meaning of life is " (meaningOfLife))

and an executable file (chmod +x) "test.l":

 

(load "life.l")

 

(prinl "Test: The meaning of life is " (meaningOfLife))

Test:

<pre>$ ./life.l -lifemain

Python has scripted main.

 

 

# life.py

 

if __name__ == "__main__":

 

 

# death.py

 

print("Life means %s." % meaning_of_life())

 

=={{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.)

 

 

meaningOfLife <- function() {

main(args)

q("no")

 

test.R

 

 

source("scriptedmain.R")

cat("Test: The meaning of life is", meaningOfLife(), "\n")

 

 

=={{header|Racket}}==

scriptedmain.rkt:

#lang racket

 

(define (meaning-of-life) 42)

 

 

test.rkt:

#lang racket

 

(module+ main

(require "scriptedmain.rkt")

 

=={{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".

has $.answer = 42;

}

multi MAIN ('methods') {

say ~LUE.^methods;

 

=={{header|REXX}}==

parse source . howInvoked @fn /*query REXX how this pgm got invoked. */

 

/*────────────────────────────── The main code follows here ... ────────────────────────*/

say

 

=={{header|Ring}}==

# Project : Modulinos

 

func main()

see "Main: The meaning of life is " + meaningoflife() + nl

Output:

<pre>

Ruby has scripted main.

 

 

def meaning_of_life

if __FILE__ == $0

puts "Main: The meaning of life is #{meaning_of_life}"

 

 

require 'life'

 

puts "Life means #{meaning_of_life}."

 

=={{header|Rust}}==

 

Makefile:

 

scriptedmain: scriptedmain.rs

-rm -rf *.dylib

-rm scriptedmain

 

scriptedmain.rs:

 

use std;

fn main() {

std::io::println("Main: The meaning of life is " + core::int::to_str(meaning_of_life(), 10u));

 

test.rs:

use std;

 

fn main() {

std::io::println("Test: The meaning of life is " + core::int::to_str(scriptedmain::meaning_of_life(), 10u));

 

Example:

$ make test

$ ./scriptedmain

Main: The meaning of life is 42

$ ./test

 

=={{header|SAC}}==

Makefile:

 

scriptedmain: ScriptedMain.sac

-rm libScriptedMainMod.a

-rm scriptedmain

 

ScriptedMain.sac:

module ScriptedMain;

#endif

return(0);

}

 

test.sac:

use Array: all;

use ScriptedMain: all;

printf("Test: The meaning of life is %d\n", meaning_of_life());

return(0);

 

Example:

$ make test

$ ./scriptedmain

Main: The meaning of life is 42

$ ./test

 

=={{header|Scala}}==

===Unix shell script===

This code must be stored as a shell script.

exec scala "$0" "$@"

!#

println(s"Use the routine to show that the hailstone sequence for the number: $nr.")

println(collatz.toList)

 

===Windows Command Script===

This code must be stored as a Windows Command Script e.g. Hailstone.cmd

@echo off

call scala %0 %*

println(collatz.toList)

println(s"It has ${collatz.length} elements.")

{{out}}

<pre>C:\>Hailstone.cmd 42

scriptedmain.scm

 

#|

exec csi -ss $0 ${1+"$@"}

 

(if (equal? (car (program)) 'compiled)

 

test.scm

 

#|

exec csi -ss $0 ${1+"$@"}

(load "scriptedmain.scm")

(display (format "Test: The meaning of life is ~a\n" (meaning-of-life)))

 

=={{header|Sidef}}==

 

func meaning_of_life {

if (__FILE__ == __MAIN__) {

say "Main: The meaning of life is #{meaning_of_life()}"

 

 

include Life

 

 

=={{header|Smalltalk}}==

Example

 

 

$ ./scriptedmain.st

 

$ ./test.st

 

package.xml

 

<package>

<name>ScriptedMain</name>

<file>scriptedmain.st</file>

</package>

 

scriptedmain.st

 

"exit"

 

(((Smalltalk getArgc) > 0) and: [ ((Smalltalk getArgv: 1) endsWith: 'scriptedmain.st') ]) ifTrue: [

main value.

 

test.st

 

"exit"

 

PackageLoader fileInPackage: 'ScriptedMain'.

 

 

=={{header|Swift}}==

Example

 

mkdir -p bin/

swiftc -D SCRIPTEDMAIN -o bin/ScriptedMain ScriptedMain.swift

Main: The meaning of life is 42

bin/Test

 

Makefile

 

bin/ScriptedMain

bin/Test

-rm *.swiftdoc

-rm *.dylib

 

ScriptedMain.swift

 

 

public class ScriptedMain {

}

#endif

 

Test.swift

 

import ScriptedMain

 

}

#endif

 

=={{header|Tcl}}==

puts "Directory: [pwd]"

puts "Program: $::argv0"

if {$::argv0 eq [info script]} {

main {*}$::argv

 

=={{header|UNIX Shell}}==

scriptedmain.sh

 

 

meaning_of_life() {

then

main

 

test.sh

 

 

path=$(dirname -- "$0")

meaning_of_life

echo "Test: The meaning of life is $?"

 

=={{header|Wren}}==

 

First we create a module for our modulino:

 

var MeaningOfLife = Fn.new { 42 }

// Check if it's being used as a library or not.

import "os" for Process

main.call()

 

and run it to make sure it works OK when run directly:

 

Next we create another module which imports the modulino:

 

 

var main = Fn.new {

}

 

 

and run this to make sure the modulino's ''main()'' function doesn't run:

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:

 

 

{{omit from|Ada}}