Modulinos: Difference between revisions

=={{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|FreeBASIC}}==

{{trans|Ring}}

Function meaningoflife() As Byte

Dim As Byte y = 42

main()

Sleep

{{out}}

<pre>

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)"

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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.

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

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