Assertions
You are encouraged to solve this task according to the task description, using any language you may know.
Show an assertion in your language by asserting that an integer variable is equal to 42.
[edit] Ada
Using pragma Assert:
pragma Assert (A = 42, "Oops!");
The behavior of pragma is controlled by pragma Assertion_Policy. Another way is to use the predefined package Ada.Assertions:
with Ada.Assertions; use Ada.Assertions;
...
Assert (A = 42, "Oops!");
The procedure Assert propagates Assertion_Error when condition is false.
[edit] ALGOL 68
The "Revised Report on the Algorithmic Language - ALGOL 68" suggest that ASSERT may be made available by a particular implementation, quote: "Pragmats may ... convey to the implementation some piece of information affecting some aspect of the meaning of the program which is not defined by this Report,..."
Example given[1]:
INT a, b; read((a, b)) PR ASSERT a >= 0 & b > 0 PR;
This works with neither ELLA ALGOL 68 nor ALGOL 68G.
The standard alternative would be to implement the assertions as an exception as per the Exceptions sample code.
In ELLA ALGOL 68 the ASSERT is implemented as an operator in the environment prelude:
OP ASSERT = (VECTOR [] CHAR assertion,BOOL valid) VOID:
IF NOT valid
THEN type line on terminal(assertion);
terminal error( 661 {invalid assertion } )
FI;
And can be "USEd" as follows:
PROGRAM assertions CONTEXT VOID
USE standard,environment
BEGIN
INT a := 43;
"Oops!" ASSERT ( a = 42 )
END
FINISH
[edit] AutoHotkey
[edit] Exceptions
a := 42
Assert(a > 10)
Assert(a < 42) ; throws exception
Assert(bool){
If !bool
throw Exception("Expression false", -1)
}
[edit] Legacy versions
if (a != 42)
{
OutputDebug, "a != 42" ; sends output to a debugger if connected
ListVars ; lists values of local and global variables
Pause ; pauses the script, use ExitApp to exit instead
}
[edit] BBC BASIC
PROCassert(a% = 42)
END
DEF PROCassert(bool%)
IF NOT bool% THEN ERROR 100, "Assertion failed"
ENDPROC
[edit] Brat
squish import :assert :assertions
assert_equal 42 42
assert_equal 13 42 #Raises an exception
[edit] C
#include <assert.h>
int main(){
int a;
/* ...input or change a here */
assert(a == 42); /* aborts program when a is not 42, unless the NDEBUG macro was defined */
return 0;
}
To turn off assertions, simply define the NDEBUG macro before where <assert.h> is included.
There is no mechanism to add a custom "message" with your assertion, like in other languages. However, there is a "trick" to do this, by simply logical-AND-ing your condition with a string constant message, like in the following. Since a string constant is guaranteed to be non-NULL (and hence evaluated as True), and since AND-ing with True is an identity operation for a boolean, it will not alter the behavior of the assertion, but it will get captured in the debug message that is printed:
assert(a == 42 && "Error message");
This trick only works with messages written directly in the source code (i.e. cannot be a variable or be computed), however, since the assertion message is captured by the macro at compile-time.
[edit] C#
using System.Diagnostics;
Debug.Assert(a == 42);
[edit] C++
#include <cassert> // assert.h also works
int main()
{
int a;
// ... input or change a here
assert(a == 42); // Aborts program if a is not 42, unless the NDEBUG macro was defined
// when including <cassert>, in which case it has no effect
}
Note that assert does not get a std:: prefix because it's a macro.
[edit] Clojure
(let [i 42]
(assert (= i 42)))
[edit] Common Lisp
(let ((x 42))
(assert (and (integerp x) (= 42 x)) (x)))
[edit] Component Pascal
Works with BlackBox Component Builder
MODULE Assertions;
VAR
x: INTEGER;
PROCEDURE DoIt*;
BEGIN
x := 41;
ASSERT(x = 42);
END DoIt;
END Assertions.
Assertions.DoIt
Output:
TRAP 0 Assertions.DoIt [0000001DH] Kernel.Call [00001A7CH] .adr INTEGER 1685454913 .kind INTEGER 0 .n INTEGER 0 .p INTEGER 0 .par ARRAY 256 OF INTEGER elements .r REAL 8.70603013185328E+175 .sig POINTER [64760018H] .size INTEGER 2287288 .sp INTEGER 256 .typ POINTER NIL Meta.Item.ParamCallVal [00002B5EH] .adr INTEGER 1685454913 .data ARRAY 256 OF INTEGER elements
[edit] D
import std.string;
void main() {
int a = readln().chomp().atoi();
assert(a == 42, "You did not input 42!");
}
[edit] Dart
Dart supplies a class Expect that works similar to the Assert methods of Junit
main() {
int i=42;
int j=41;
Expect.equals(42,i);
Expect.equals(42,j);
}
[edit] Delphi
Assert(a = 42);
If an assertion fails, EAssertionFailed exception is raised.
The generation of assertion code can be disabled by compiler directive
{$ASSERTIONS OFF}
Here is a simple console demo app which raises and handles assertion exception:
program TestAssert;
{$APPTYPE CONSOLE}
{.$ASSERTIONS OFF} // remove '.' to disable assertions
uses
SysUtils;
var
a: Integer;
begin
try
Assert(a = 42);
except
on E:Exception do
Writeln(E.Classname, ': ', E.Message);
end;
Readln;
end.
[edit] DWScript
Simple assertion, with a custom (optional) message
Assert(a = 42, 'Not 42!');
Other specialized assertions can be used in contracts, for instance this function check that the parameter (passed by reference ofr the purpose of illustration) is 42 when entering the function and when leaving the function
procedure UniversalAnswer(var a : Integer);
require
a = 42;
begin
// code here
ensure
a = 42;
end;
[edit] E
E does not have the specific feature of assertions which may be disabled by a global option. But it does have a utility to throw an exception if a condition is false:
require(a == 42) # default message, "Required condition failed"
require(a == 42, "The Answer is Wrong.") # supplied message
require(a == 42, fn { `Off by ${a - 42}.` }) # computed only on failure
[edit] Eiffel
version 2.4There are many assertion types in Eiffel, one is the following:
File called main.e:
class MAIN
creation main
feature main is
local
test: TEST;
do
create test;
io.read_integer;
test.assert(io.last_integer);
end
end
Another file called test.e:
class TEST
feature assert(val: INTEGER) is
require
val = 42;
do
print("Thanks for the 42!%N");
end
end
[edit] Emacs Lisp
Assertion can be loaded from cl.el:
(require 'cl)
(let ((x 41))
(assert (= x 42) t "the answer is not right"))
[edit] Erlang
Erlang doesn't have an assert statement. However, it is single assignment, and its assignment operator won't complain if you reassign the exact same value to an existing variable but will throw an exception otherwise.
1> N = 42.
42
2> N = 43.
** exception error: no match of right hand side value 43
3> N = 42.
42
4> 44 = N.
** exception error: no match of right hand side value 42
5> 42 = N.
42
As such, the behavior of Erlang's assignment operator is extremely similar to a regular assert in other languages.
[edit] Euphoria
type fourty_two(integer i)
return i = 42
end type
fourty_two i
i = 41 -- type-check failure
[edit] Factor
Throw an exception if the value on the top of the stack is not equal to 42:
USING: kernel ;
42 assert=
[edit] FBSL
One needs to DECLARE the asserter variable at the top of script.
This implementation evaluates the expression given to the function and displays a message if it evaluates to false.
#APPTYPE CONSOLE
DECLARE asserter
FUNCTION Assert(expression)
DIM cmd AS STRING = "DIM asserter AS INTEGER = (" & expression & ")"
EXECLINE(cmd, 1)
IF asserter = 0 THEN PRINT "Assertion: ", expression, " failed"
END FUNCTION
Assert("1<2")
Assert("1>2")
PAUSE
Output
Assertion: 1>2 failed Press any key to continue...
[edit] F#
F# provides an assert function that is only enabled when the program is compiled with DEBUG defined. When an assertion fails, a dialog box is shown with the option to enter the debugger.
let test x =
assert (x = 42)
test 43
[edit] GAP
# See section 7.5 of reference manual
# GAP has assertions levels. An assertion is tested if its level
# is less then the global level.
# Set global level
SetAssertionLevel(10);
a := 1;
Assert(20, a > 1, "a should be greater than one");
# nothing happens
a := 1;
Assert(4, a > 1, "a should be greater than one");
# error
# Show current global level
AssertionLevel();
# 10
[edit] Go
Assertions are a feature consciously omitted from Go. For cases where you want feedback during development, the following code should provide a similar purpose. While it is simply an if statement and a panic, the technique does have some properties typical of assertions. For one, the predicate of an if statement in Go is required to be of boolean type. Specifically, ints are not tacitly tested for zero, pointers are not tested for nil: the expression must be boolean, as the WP article mentions is typical of assertions. Also, it provides a good amount of information should the predicate evaluate to true. First, a value of any type can be passed to the panic, and by default is displayed, followed by a stack trace which includes the location of the panic in the source code—function name, file name, and line number.
package main
func main() {
x := 43
if x != 42 {
panic(42)
}
}
Output:
panic: 42
panic PC=0x2b772d1a1048
runtime.panic+0xa7 /pool/go/src/pkg/runtime/proc.c:1032
runtime.panic(0x40e820, 0x2a)
main.main+0x48 /pool/test.go:8
main.main()
runtime.mainstart+0xf /pool/go/src/pkg/runtime/amd64/asm.s:77
runtime.mainstart()
runtime.goexit /pool/go/src/pkg/runtime/proc.c:148
runtime.goexit()
Also see Monty_Hall_problem#Go for more examples of this assertion idiom.
[edit] Groovy
def checkTheAnswer = {
assert it == 42 : "This: " + it + " is not the answer!"
}
Test program:
println "before 42..."
checkTheAnswer(42)
println "before 'Hello Universe'..."
checkTheAnswer("Hello Universe")
Output:
before 42... before 'Hello Universe'... java.lang.AssertionError: This: Hello Universe is not the answer!. Expression: (it == 42). Values: it = Hello Universe at ConsoleScript80$_run_closure1.doCall(ConsoleScript80:2) at ConsoleScript80.run(ConsoleScript80:8)
[edit] Haskell
import Control.Exception
main = let a = someValue in
assert (a == 42) -- throws AssertionFailed when a is not 42
somethingElse -- what to return when a is 42
[edit] Icon and Unicon
...
runerr(n,( expression ,"Assertion/error - message.")) # Throw (and possibly trap) an error number n if expression succeeds.
...
stop(( expression ,"Assertion/stop - message.")) # Terminate program if expression succeeds.
...
There are no 'assertions', which can be turned on/off by the compiler. We can emulate them by prefixing a stop statement with a check on a global variable:
$define DEBUG 1 # this allows the assertions to go through
procedure check (a)
if DEBUG then stop (42 = a, " is invalid value for 'a'")
write (a)
end
procedure main ()
check (10)
check (42)
check (12)
end
This produces the output:
10 42 is invalid value for 'a'
Changing the define to: $define DEBUG &fail turns off the assertion checking.
[edit] J
assert n = 42
[edit] Java
public static void main(String[] args){
int a;
//...input or change a here
assert a == 42;//throws an AssertionError when a is not 42
assert a == 42 : "Error message"; //throws an AssertionError
//when a is not 42 with "Error message" for the message
//the error message can be any non-void expression
}
Note: assertion checking is disabled by default when you run your program with the java command. You must provide the -ea (short for -enableassertions) flag in order to enable them.
[edit] Julia
#assert() function takes expression as 1st argument, failed-assertion message as optional 2nd argument
julia> assert(x==42,"x is not 42")
ERROR: assertion failed: x is not 42
#@assert macro checks the supplied conditional expression, with the expression returned in the failed-assertion message
julia> @assert x==42
ERROR: assertion failed: :((x==42))
#Julia also has type assertions of the form, x::Type which can be appended to a variable for type-checking at any point
julia> x::String
ERROR: type: typeassert: expected String, got Int32
[edit] Lisaac
? { n = 42 };
[edit] Lua
a = 5
assert (a == 42)
assert (a == 42,'\''..a..'\' is not the answer to life, the universe, and everything')
[edit] Maple
(Taken from Lua, above.)
a := 5:
ASSERT( a = 42 );
ASSERT( a = 42, "a is not the answer to life, the universe, and everything" );
[edit] Mathematica
Assert[var===42]
[edit] MATLAB / Octave
assert(x == 42,'x = %d, not 42.',x);
Sample Output:
x = 3;
assert(x == 42,'Assertion Failed: x = %d, not 42.',x);
??? Assertion Failed: x = 3, not 42.
[edit] Metafont
Metafont has no really an assert built in, but it can easily created:
def assert(expr t) = if not (t): errmessage("assertion failed") fi enddef;
This assert macro uses the errmessage built in to show the "error". The
errmessage gives the error message and asks the user what to do.
Usage example:
n := 41;
assert(n=42);
message "ok";
Output (failed assertion):
This is METAFONT, Version 2.71828 (Web2C 7.5.5)
(./assert.mf
! assertion failed.
<to be read again>
;
l.4 assert(n=42);
?
[edit] Modula-3
ASSERT is a pragma, that creates a run-time error if it returns FALSE.
<*ASSERT a = 42*>
Assertions can be ignored in the compiler by using the -a switch.
[edit] Nimrod
var a = 42
assert(a == 42)
Assertions may be disabled by compiling with --assertions:off.
[edit] Oberon-2
Oxford Oberon-2
MODULE Assertions;
VAR
a: INTEGER;
BEGIN
a := 40;
ASSERT(a = 42);
END Assertions.
Output:
Runtime error: assertion failed (0) on line 6 in module Assertions In procedure Assertions.%main called from MAIN
[edit] Objective-C
For use within an Objective-C method:
NSAssert(a == 42, @"Error message");
If you want to use formatting arguments, you need to use the assertion macro corresponding to your number of formatting arguments:
NSAssert1(a == 42, @"a is not 42, a is actually %d", a); # has 1 formatting arg, so use NSAssert"1"
Within a regular C function you should use NSCAssert or NSCAssertN instead.
To turn off assertions, define the NS_BLOCK_ASSERTIONS macro.
[edit] OCaml
let a = get_some_value () in
assert (a = 42); (* throws Assert_failure when a is not 42 *)
(* evaluate stuff to return here when a is 42 *)
It is possible to compile with the parameter -noassert then the compiler won't compile the assertion checks.
[edit] Oz
Oz does not have an assert statement. But if different values are assigned to the same dataflow variable, an exception will be thrown (similar to Erlang).
declare
proc {PrintNumber N}
N=42 %% assert
{Show N}
end
in
{PrintNumber 42} %% ok
{PrintNumber 11} %% throws
Output:
%***************************** failure ************************** %** %** Tell: 11 = 42 %** %** Call Stack: %** procedure 'PrintNumber' in file "Oz<8>", line 3, column 0, PC = 18600220 %**--------------------------------------------------------------
[edit] PARI/GP
PARI can use any of the usual C methods for making assertions. GP has no built-in assertions.
#include <assert.h>
void
test()
{
int a;
// ... input or change a here
assert(a == 42); // Aborts program if a is not 42, unless the NDEBUG macro was defined
}
[edit] Pascal
See Delphi
[edit] Perl
While not exactly an assertion, a common Perl idiom is to use ... or die ... to throw an exception when a certain statement is false.
open my $fh, '<', 'file' or die "Cannot open file: $!\n"; # $! contains the error message from the last error
Note: the above "or die" idiom is not needed when the "autodie" pragma is in use:
use autodie;
open my $fh, '<', 'file'; # automatically throws an exception on failure
Another example:
my $a = 5;
#...input or change $a here
$a == 42 or die "Error message\n";
# or, alternatively:
die "Error message\n" unless $a == 42;
# or:
die "Error message\n" if not $a == 42;
# or just:
die "Error message\n" if $a != 42;
Some third-party modules provide other ways of using assertions in Perl:
use Carp::Assert;
assert($a == 42);
There is also a number of ways to test assertions in test suites, for example:
is $a, 42;
ok $a == 42;
cmp_ok $a, '==', 42, 'The answer should be 42';
# etc.
[edit] Perl 6
my $a = (1..100).pick;
# with a (non-hygienic) macro
macro assert ($x) { "$x or die 'assertion failed: $x'" }
assert('$a == 42');
# but usually we just say
$a == 42 or die "$x ain't 42";
[edit] PHP
<?php
$a = 5
#...input or change $a here
assert($a == 42) # when $a is not 42, take appropriate actions,
# which is set by assert_options()
?>
[edit] PicoLisp
The 'assert' function, in combination with the tilde read macro, generates code only in debug mode:
...
~(assert (= N 42)) # Exists only in debug mode
...
Other possibilities are either to break into an error handler:
(let N 41
(unless (= N 42) (quit "Incorrect N" N)) ) # 'quit' throws an error
41 -- Incorrect N
?
or to stop at a debug break point, allowing to continue with the program:
(let N 41
(unless (= N 42) (! setq N 42)) ) # '!' is a breakpoint
(setq N 42) # Manually fix the value
! # Hit ENTER to leave the breakpoint
-> 42
[edit] PL/I
/* PL/I does not have an assert function as such, */
/* but it is something that can be implemented in */
/* any of several ways. A straight-forward way */
/* raises a user-defined interrupt. */
on condition (assert_failure) snap
put skip list ('Assert failure');
....
if a ^= b then signal condition(assert_failure);
/* Another way is to use the preprocessor, thus: */
%assert: procedure (a, b) returns (character);
return ('if ' || a || '^=' || b ||
' then signal condition(assert_failure);');
%end assert;
%activate assert;
assert(a, 42);
[edit] Prolog
test(A):-
assertion(A==42).
[edit] PureBasic
PureBasic does not have a native function for assertion, but allows for the definition of one.
The Macro below will only be included in the code if is compiled in debug mode, if so it will test the condition and if it fails it will inform with the message defined by the programmer, the line where it happened and in which source code file.
Macro Assert(TEST,MSG="Assert: ")
CompilerIf #PB_Compiler_Debugger
If Not (TEST)
Debug MSG+" Line="+Str(#PB_Compiler_Line)+" in "+#PB_Compiler_File
CallDebugger
EndIf
CompilerEndIf
EndMacro
A implementation as defined above could be;
A=42
Assert(A=42,"Assert that A=42")
A=42-1
Assert(A=42)
Where the second test would fail resulting in a message to the programmer with cause (if given by programmer), code line & file.
[edit] Python
a = 5
#...input or change a here
assert a == 42 # throws an AssertionError when a is not 42
assert a == 42, "Error message" # throws an AssertionError
# when a is not 42 with "Error message" for the message
# the error message can be any expression
It is possible to turn off assertions by running Python with the -O (optimizations) flag.
[edit] R
stopifnot(a==42)
[edit] Racket
Racket has higher-order assertions known as contracts that can protect any values including functions and objects. Contracts are typically applied on the imports or exports of a module.
#lang racket
(define/contract x
(=/c 42) ; make sure x = 42
42)
(define/contract f
(-> number? (or/c 'yes 'no)) ; function contract
(lambda (x)
(if (= 42 x) 'yes 'no)))
(f 42) ; succeeds
(f "foo") ; contract error!
If typical assertion checking (i.e. error unless some boolean condition holds) is needed, that is also possible:
#lang racket
(define x 80)
(unless (= x 42)
(error "a is not 42")) ; will error
[edit] REXX
/* REXX ***************************************************************
* There's no assert feature in Rexx. That's how I'd implement it
* 10.08.2012 Walter Pachl
**********************************************************************/
x.=42
x.2=11
Do i=1 By 1
Call assert x.i,42
End
Exit
assert:
Parse Arg assert_have,assert_should_have
If assert_have\==assert_should_have Then Do
Say 'Assertion fails in line' sigl
Say 'expected:' assert_should_have
Say ' found:' assert_have
Say sourceline(sigl)
Say 'Look around'
Trace ?R
Nop
Signal Syntax
End
Return
Syntax: Say 'program terminated'
Output:
Assertion fails in line 8
expected: 42
found: 11
Call assert x.i,42
Look around
Here I enter Say i
2
and then I press just enter
program terminated
[edit] RLaB
RLaB does not have a special function to deal with assertions. The following workaround will do the trick:
// test if 'a' is 42, and if not stop the execution of the code and print
// some error message
if (a != 42)
{
stop("a is not 42 as expected, therefore I stop until this issue is resolved!");
}
[edit] Ruby
This uses test/unit from the standard library.
require "test/unit/assertions"Output:
include Test::Unit::Assertions
n = 5
begin
assert_equal(42, n)
rescue Exception => e
# Ruby 1.8: e is a Test::Unit::AssertionFailedError
# Ruby 1.9: e is a MiniTest::Assertion
puts e
end
<42> expected but was <5>.
[edit] Sather
class MAIN is
main is
i ::= 41;
assert i = 42; -- fatal
-- ...
end;
end;
(The current GNU Sather compiler v1.2.3 I am using to test the code seems to ignore the assertion and no fatal error is raised, despite Sather should, see e.g. here).
[edit] Scala
These two are the same thing, and are tagged @elidable(ASSERTION):
assert(a == 42)
assert(a == 42, "a isn't equal to 42")
assume(a == 42)
assume(a == 42, "a isn't equal to 42")
The next one does the same thing as above, but it is not tagged. Often used as a pre-condition checker on class constructors.
require(a == 42)
require(a == 42, "a isn't equal to 42")
This one checks a value and returns it for further use (here shown being printed). It
uses assert, which, as explained, gets tagged.
println(a.ensuring(a == 42))
println(a.ensuring(a == 42, "a isn't equal to 42"))
println(a.ensuring(_ == 42))
println(a.ensuring(_ == 42, "a isn't equal to 42"))
[edit] Scheme
(let ((x 42))
(assert (and (integer? x) (= x 42))))
[edit] Slate
load: 'src/lib/assert.slate'.
define: #n -> 7.
assert: n = 42 &description: 'That is not the Answer.'.
raises an AssertionFailed condition (an Error).
[edit] Smalltalk
foo := 41.
...
self assert: (foo == 42).
In TestCase and subclasses, a number of check methods are inherited; among them:
self assert: (... somethingMustEvaluateToTrue.. )
self should:[ some code ] raise: someException "ensures that an exception is raised
Object also implements assert:; these are evaluated dynamically, but can be disabled via a flag setting. Also the compiler can be instructed to ignore them for production code (which is not normally done; disabled instead by default):
self assert: (... somethingMustEvaluateToTrue.. ) "implemented in Object"
the implementation in Object raises an AssertionFailedError exception, which usually opens a debugger when in the IDE, but can be caught in deployed apps.
[edit] SPARK
Works with SPARK GPL 2010
Assertions are analysed statically, before compilation or execution. They can appear in various places:
- inline in the code, either
-# check X = 42;
- or
-# assert X = 42;
- as a precondition on an operation:
procedure P (X : in out Integer);
--# derives X from *;
--# pre X = 42;
- or as a postcondition on an operation:
procedure P (X : in out Integer);
--# derives X from *;
--# post X = 42;
Example:
X := 7;
--# check X = 42;
produces the following output:
H1: true .
->
C1: false .
which is an unprovable theorem that tells you that there is a guaranteed failure.
[edit] Tcl
package require control
set x 5
control::assert {$x == 42}
Produces the output:
assertion failed: $x == 42
[edit] Vala
int a = 42;
int b = 33;
assert (a == 42);
assert (b == 42); // will break the program with "assertion failed" error
[edit] VBScript
[edit] Definition
sub Assert( boolExpr, strOnFail )
if not boolExpr then
Err.Raise vbObjectError + 99999, , strOnFail
end if
end sub
[edit] Invocation
dim i
i = 43
Assert i=42, "There's got to be more to life than this!"
[edit] Output
>cscript "C:\foo\assert.vbs"
C:\foo\assert.vbs(3, 3) (null): There's got to be more to life than this!
[edit] Visual Basic
VB's Assert only fires when run from within the IDE. When compiled, all Debug lines are ignored.
Debug.Assert i = 42
[edit] XPL0
XPL0 does not have an assert command. The equivalent is usually synthesized something like this.
proc Fatal(Str); \Display error message and terminate program
char Str;
[\return; uncomment this if "assertions" are to be disabled
SetVid(3); \set normal text display if program uses graphics
Text(0, Str); \display error message
ChOut(0, 7); \sound the bell
exit 1; \terminate the program; pass optional error code to DOS
];
if X#42 then Fatal("X#42");
- Programming Tasks
- Basic language learning
- Ada
- ALGOL 68
- AutoHotkey
- BBC BASIC
- Brat
- C
- C sharp
- C++
- Clojure
- Common Lisp
- Component Pascal
- D
- Dart
- Delphi
- DWScript
- E
- Eiffel
- Emacs Lisp
- Erlang
- Euphoria
- Factor
- FBSL
- F Sharp
- GAP
- Go
- Groovy
- Haskell
- Icon
- Unicon
- J
- Java
- Julia
- Lisaac
- Lua
- Maple
- Mathematica
- MATLAB
- Octave
- Metafont
- Modula-3
- Nimrod
- Oberon-2
- Objective-C
- OCaml
- Oz
- PARI/GP
- Pascal
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- Prolog
- PureBasic
- Python
- R
- Racket
- REXX
- RLaB
- Ruby
- Sather
- Scala
- Scheme
- Slate
- Smalltalk
- SPARK
- Tcl
- Tcllib
- Gnuplot/Omit
- NSIS/Omit
- Vala
- VBScript
- Visual Basic
- XPL0