Comparison of programming languages (basic instructions)

Short description: None

Programming language comparisons

* General comparison
* Assignment
* Basic syntax
* Basic instructions
* Comments
* Control flow
* Foreach loops
* While loops
* For loops
* Do-while
* Exception handling
* Enumerated types
* Generators
* Anonymous functions
* Conditional expressions
* Functional instructions
* Arrays
* Associative arrays
* Scope
* String operations
* String functions
* Higher-order functions
* Type systems
* List comprehension
* Object-oriented programming
* Object-oriented constructors
* Operators

* Evaluation strategy
* List of "Hello World" programs

* Languages with dependent types
* Comparison of type systems

* * *

Comparison of individual languages

* ALGOL 58's influence on ALGOL 60
* ALGOL 60: Comparisons with other languages
* Comparison of ALGOL 68 and C++
* ALGOL 68: Comparisons with other languages
* Compatibility of C and C++
* Comparison of Pascal and Borland Delphi
* Comparison of Object Pascal and C
* Comparison of Pascal and C
* Comparison of Java and C++
* Comparison of C# and Java
* Comparison of C# and Visual Basic .NET
* Comparison of Visual Basic and Visual Basic .NET

* v
* t
* e

This article compares a large number of programming languages by tabulating their data types, their expression, statement, and declaration syntax, and some common operating-system interfaces.

## Contents

* 1 Conventions of this article
* 2 Type identifiers
* 2.1 Integers
* 2.2 Floating point
* 2.3 Complex numbers
* 2.4 Other variable types
* 3 Derived types
* 3.1 Array
* 3.2 Other types
* 4 Variable and constant declarations
* 5 Control flow
* 5.1 Conditional statements
* 5.2 Loop statements
* 5.3 Exceptions
* 5.4 Other control flow statements
* 6 Functions
* 7 Type conversions
* 8 Standard stream I/O
* 9 Reading command-line arguments
* 10 Execution of commands
* 11 References

## Conventions of this article

Generally, var, var, or var is how variable names or other non-literal values to be interpreted by the reader are represented. The rest is literal code. Guillemets (`«` and `»`) enclose optional sections. indicates a necessary (whitespace) indentation.

The tables are not sorted lexicographically ascending by programming language name by default, and that some languages have entries in some tables but not others.

## Type identifiers

### Integers

| 8 bit (byte)  | 16 bit (short integer)  | 32 bit  | 64 bit (long integer)  | Word size  | Arbitrarily precise (bignum)

|
|
|
|
|
|

Signed  | Unsigned  | Signed  | Unsigned  | Signed  | Unsigned  | Signed  | Unsigned  | Signed  | Unsigned
Ada[1] | `range -2**7 .. 2**7 - 1`[j] | `range 0 .. 2**8 - 1`[j] or `mod 2**8`[k] | `range -2**15 .. 2**15 - 1`[j] | `range 0 .. 2**16 - 1`[j] or `mod 2**16`[k] | `range -2**31 .. 2**31 - 1`[j] | `range 0 .. 2**32 - 1`[j] or `mod 2**32`[k] | `range -2**63 .. 2**63 - 1`[j] | `mod 2**64`[k] | `Integer`[j] | `range 0 .. 2**Integer'Size - 1`[j] or `mod Integer'Size`[k] | N/A
ALGOL 68 (variable-width)  | `short short int`[c] | N/A  | `short int`[c] | N/A  | `int`[c] | N/A  | `long int`[c] | N/A  | `int`[c] | N/A  | `long long int`[a][g]
`bytes` and `bits`
C (C99 fixed-width)  | `int8_t` | `uint8_t` | `int16_t` | `uint16_t` | `int32_t` | `uint32_t` | `int64_t` | `uint64_t` | `intptr_t`[c] | `size_t`[c] | N/A
C++ (C++11 fixed-width)
C (C99 variable-width)  | `signed char` | `unsigned char` | `short`[c] | `unsigned short`[c] | `long`[c] | `unsigned long`[c] | `long long`[c] | `unsigned long long`[c] | `int`[c] | `unsigned int`[c]
C++ (C++11 variable-width)
Objective-C (Cocoa)  | `signed char` or `int8_t` | `unsigned char` or `uint8_t` | `short` or `int16_t` | `unsigned short` or `uint16_t` | `int` or `int32_t` | `unsigned int` or `uint32_t` | `long long` or `int64_t` | `unsigned long long` or `uint64_t` | `NSInteger` or `long` | `NSUInteger` or `unsigned long`
C# | `sbyte` | `byte` | `short` | `ushort` | `int` | `uint` | `long` | `ulong` | `IntPtr` | `UIntPtr` | `System.Numerics.BigInteger`
(.NET 4.0)
Java | `byte` | N/A  | `char`[b] | N/A  | N/A  | N/A  | N/A  | `java.math.BigInteger`
Go | `int8` | `uint8` or `byte` | `int16` | `uint16` | `int32` | `uint32` | `int64` | `uint64` | `int` | `uint` | `big.Int`
Rust | `i8` | `u8` | `i16` | `u16` | `i32` | `u32` | `i64` | `u64` | `isize` | `usize` | N/A
Swift | `Int8` | `UInt8` | `Int16` | `UInt16` | `Int32` | `UInt32` | `Int64` | `UInt64` | `Int` | `UInt`
D | `byte` | `ubyte` | `short` | `ushort` | `int` | `uint` | `long` | `ulong` | N/A  | N/A  | `BigInt`
Common Lisp[2] | `(signed-byte 8)` | `(unsigned-byte 8)` | `(signed-byte 16)` | `(unsigned-byte 16)` | `(signed-byte 32)` | `(unsigned-byte 32)` | `(signed-byte 64)` | `(unsigned-byte 64)` |  |  | `bignum`
Scheme |  |  |  |  |  |  |  |  |  |  |
ISLISP[3] |  |  |  |  |  |  |  |  |  |  | `bignum`
Pascal (FPC)  | `shortint` | `byte` | `smallint` | `word` | `longint` | `longword` | `int64` | `qword` | `integer` | `cardinal` | N/A
Visual Basic | N/A  | `Byte` | `Integer` | N/A  | `Long` | N/A  | N/A  | N/A  | N/A
Visual Basic .NET | `SByte` | `Short` | `UShort` | `Integer` | `UInteger` | `Long` | `ULong` | `System.Numerics.BigInteger`
(.NET 4.0)
FreeBasic  | `Byte` or `Integer<8>` | `UByte` or `UInteger<8>` | `Short` or `Integer<16>` | `UShort` or `UInteger<16>` | `Long` or `Integer<32>` | `ULong` or `UInteger<32>` | `LongInt` or `Integer<64>` | `ULongInt` or `UInteger<64>` | `Integer` | `UInteger` | N/A
Python 2.x  | N/A  | N/A  | N/A  | N/A  | `int` | N/A  | `long`
Python 3.x  | N/A  | N/A  | N/A  | N/A  | N/A  | `int`
S-Lang  | N/A  | N/A  | N/A  | N/A  | N/A  | N/A
Fortran | `INTEGER(KIND = n)`[f] | N/A  | `INTEGER(KIND = n)`[f] | N/A  | `INTEGER(KIND = n)`[f] | N/A  | `INTEGER(KIND = n)`[f] | N/A  |  |  |
PHP | N/A  | N/A  | `int`[m] | N/A  | `int`[m] | N/A  | N/A  | [e]
Perl 5  | N/A[d] | N/A[d] | N/A[d] | N/A[d] | N/A[d] | `Math::BigInt`
Raku | `int8` | `uint8` | `int16` | `uint16` | `int32` | `uint32` | `int64` | `uint64` | `Int` | N/A
Ruby | N/A  | N/A  | N/A  | N/A  | `Fixnum` | N/A  | `Bignum`
Erlang[n] | N/A  | N/A  | N/A  | N/A  | `integer()` | N/A  | `integer()`[o]
Scala | `Byte` | N/A  | `Short` | `Char`[l] | `Int` | N/A  | `Long` | N/A  | N/A  | N/A  | `scala.math.BigInt`
Seed7 | N/A  | N/A  | N/A  | N/A  | N/A  | N/A  | `integer` | N/A  | N/A  | N/A  | `bigInteger`
Smalltalk | N/A  | N/A  | N/A  | N/A  | `SmallInteger`[i] | N/A  | `LargeInteger`[i]
Windows PowerShell  | N/A  | N/A  | N/A  | N/A  | N/A  | N/A
OCaml | N/A  | N/A  | `int32` | N/A  | `int64` | N/A  | `int` or `nativeint` |  | `open Big_int;;` or `big_int`
F# | `sbyte` | `byte` | `int16` | `uint16` | `int32` or `int` | `uint32` | `uint64` | `nativeint` | `unativeint` | `bigint`
Standard ML | N/A  | `Word8.word` | N/A  | `Int32.int` | `Word32.word` | `Int64.int` | `Word64.word` | `int` | `word` | `LargeInt.int` or
`IntInf.int`
Haskell (GHC)  | `«import Int»` or `Int8` | `«import Word»` or `Word8` | `«import Int»` or `Int16` | `«import Word»` or `Word16` | `«import Int»` or `Int32` | `«import Word»` or `Word32` | `«import Int»` or `Int64` | `«import Word»` or `Word64` | `Int` | `«import Word»` or `Word` | `Integer`
Eiffel | `INTEGER_8` | `NATURAL_8` | `INTEGER_16` | `NATURAL_16` | `INTEGER_32` | `NATURAL_32` | `INTEGER_64` | `NATURAL_64` | `INTEGER` | `NATURAL` | N/A
COBOL[h] | `BINARY-CHAR «SIGNED»` | `BINARY-CHAR UNSIGNED` | `BINARY-SHORT «SIGNED»` | `BINARY-SHORT UNSIGNED` | `BINARY-LONG «SIGNED»` | `BINARY-LONG UNSIGNED` | `BINARY-DOUBLE «SIGNED»` | `BINARY-DOUBLE UNSIGNED` | N/A  | N/A  | N/A
Mathematica | N/A  | N/A  | N/A  | N/A  | N/A  | `Integer`
Wolfram Language | N/A  | N/A  | N/A  | N/A  | N/A  | `Integer`

* ^a The standard constants `int shorts` and `int lengths` can be used to determine how many `short`s and `long`s can be usefully prefixed to `short int` and `long int`. The actual sizes of `short int`, `int`, and `long int` are available as the constants `short max int`, `max int`, and `long max int` etc.
* ^b Commonly used for characters.
* ^c The ALGOL 68, C and C++ languages do not specify the exact width of the integer types `short`, `int`, `long`, and (C99, C++11) `long long`, so they are implementation-dependent. In C and C++ `short`, `long`, and `long long` types are required to be at least 16, 32, and 64 bits wide, respectively, but can be more. The `int` type is required to be at least as wide as `short` and at most as wide as `long`, and is typically the width of the word size on the processor of the machine (i.e. on a 32-bit machine it is often 32 bits wide; on 64-bit machines it is sometimes 64 bits wide). C99 and C++11 also define the `[u]intN_t` exact-width types in the stdint.h header. See C syntax for more information. In addition the types `size_t` and `ptrdiff_t` are defined in relation to the address size to hold unsigned and signed integers sufficiently large to handle array indices and the difference between pointers.
* ^d Perl 5 does not have distinct types. Integers, floating point numbers, strings, etc. are all considered "scalars".
* ^e PHP has two arbitrary-precision libraries. The BCMath library just uses strings as datatype. The GMP library uses an internal "resource" type.
* ^f The value of `n` is provided by the `SELECTED_INT_KIND`[4] intrinsic function.
* ^g ALGOL 68G's runtime option `--precision "number"` can set precision for `long long int`s to the required "number" significant digits. The standard constants `long long int width` and `long long max int` can be used to determine actual precision.
* ^h COBOL allows the specification of a required precision and will automatically select an available type capable of representing the specified precision. "`PIC S9999`", for example, would require a signed variable of four decimal digits precision. If specified as a binary field, this would select a 16-bit signed type on most platforms.
* ^i Smalltalk automatically chooses an appropriate representation for integral numbers. Typically, two representations are present, one for integers fitting the native word size minus any tag bit (SmallInteger) and one supporting arbitrary sized integers (LargeInteger). Arithmetic operations support polymorphic arguments and return the result in the most appropriate compact representation.
* ^j Ada range types are checked for boundary violations at run-time (as well as at compile-time for static expressions). Run-time boundary violations raise a "constraint error" exception. Ranges are not restricted to powers of two. Commonly predefined Integer subtypes are: Positive (`range 1 .. Integer'Last`) and Natural (`range 0 .. Integer'Last`). `Short_Short_Integer` (8 bits), `Short_Integer` (16 bits) and `Long_Integer` (64 bits) are also commonly predefined, but not required by the Ada standard. Runtime checks can be disabled if performance is more important than integrity checks.
* ^k Ada modulo types implement modulo arithmetic in all operations, i.e. no range violations are possible. Modulos are not restricted to powers of two.
* ^l Commonly used for characters like Java's char.
* ^m `int` in PHP has the same width as `long` type in C has on that system.[c]
* ^n Erlang is dynamically typed. The type identifiers are usually used to specify types of record fields and the argument and return types of functions.[5]
* ^o When it exceeds one word.[6]

### Floating point

| Single precision  | Double precision  | Other precision  | Processor dependent

|
|
|
|

Ada[1] | `Float` | `Long_Float` | N/A
ALGOL 68 | `real`[a] | `long real`[a] | `short real`, `long long real`, etc.[d]
C | `float`[b] | `double` | `long double`[f]
C++ (STL)
Objective-C (Cocoa)  | `CGFloat`
C# | `float` | N/A
Java
Go | `float32` | `float64`
Rust | `f32` | `f64`
Swift | `Float` or `Float32` | `Double` or `Float64` | `Float80`[g] | `CGFloat`
D | `float` | `double` |  | `real`
Common Lisp | `single-float` | `double-float` | `float, short-float, long-float`
Scheme |  |  |
ISLISP |  |  |
Pascal (FPC)  | `single` | `double` |  | `real`
Visual Basic | `Single` | `Double` | N/A
Visual Basic .NET
Xojo
Python | N/A  | `float` |
JavaScript | `Number`[7] | N/A
S-Lang  |  |  |
Fortran | `REAL(KIND = n)`[c] |
PHP |  | `float` |
Perl |  |  |
Raku | `num32` | `num64` |  | `Num`
Ruby | N/A  | `Float` | N/A
Scala | `Float` | `Double`
Seed7 | N/A  | `float`
Smalltalk | `Float` | `Double`
Windows PowerShell  |  |  |
OCaml | N/A  | `float` | N/A
F# | `float32`
Standard ML | N/A  |  | `real`
Haskell (GHC)  | `Float` | `Double` |
Eiffel | `REAL_32` | `REAL_64` |
COBOL | `FLOAT-BINARY-7`[e] | `FLOAT-BINARY-34`[e] | `FLOAT-SHORT`, `FLOAT-LONG`, `FLOAT-EXTENDED`
Mathematica | N/A  | N/A  |  | `Real`

* ^a The standard constants `real shorts` and `real lengths` can be used to determine how many `short`s and `long`s can be usefully prefixed to `short real` and `long real`. The actual sizes of `short real`, `real`, and `long real` are available as the constants `short max real`, `max real` and `long max real` etc. With the constants `short small real`, `small real` and `long small real` available for each type's machine epsilon.
* ^b declarations of single precision often are not honored
* ^c The value of `n` is provided by the `SELECTED_REAL_KIND`[8] intrinsic function.
* ^d ALGOL 68G's runtime option `--precision "number"` can set precision for `long long real`s to the required "number" significant digits. The standard constants `long long real width` and `long long max real` can be used to determine actual precision.
* ^e These IEEE floating-point types will be introduced in the next COBOL standard.
* ^f Same size as `double` on many implementations.
* ^g Swift supports 80-bit extended precision floating point type, equivalent to `long double` in C languages.

### Complex numbers

| Integer  | Single precision  | Double precision  | Half and Quadruple precision etc.

|
|
|
|

Ada[1] | N/A  | `Complex`[b] | `Complex`[b] | `Complex`[b]
ALGOL 68 | N/A  | `compl` | `long compl` etc.  | `short compl` etc. and `long long compl` etc.
C (C99)[9] | N/A  | `float complex` | `double complex` | N/A
C++ (STL)  | N/A  | `std::complex<float>` | `std::complex<double>`
C# | N/A  | N/A  | `System.Numerics.Complex`
(.NET 4.0)
Java | N/A  | N/A  | N/A
Go | N/A  | `complex64` | `complex128`
D | N/A  | `cfloat` | `cdouble`
Objective-C | N/A  | N/A  | N/A
Common Lisp | (complex integer)  | (complex single-float)  | (complex double-float)  | complex
Scheme |  |  |  | N/A
Pascal | N/A  | N/A  |
Visual Basic | N/A  | N/A  |
Visual Basic .NET | N/A  | N/A  | `System.Numerics.Complex`
(.NET 4.0)
Perl |  |  | `Math::Complex` |
Raku |  | `complex64` | `complex128` | `Complex`
Python |  |  | `complex` | N/A
JavaScript | N/A  | N/A  |
S-Lang  | N/A  | N/A  |
Fortran |  | `COMPLEX(KIND = n)`[a]
Ruby | `Complex` | N/A  | `Complex`
Scala | N/A  | N/A  | N/A
Seed7 | N/A  | N/A  | `complex`
Smalltalk | `Complex` | `Complex` | `Complex`
Windows PowerShell  | N/A  | N/A  |
OCaml | N/A  | N/A  | `Complex.t`
F# |  |  | `System.Numerics.Complex`
(.NET 4.0)
Standard ML | N/A  | N/A  | N/A
Haskell (GHC)  | N/A
Eiffel | N/A  | N/A  | N/A
COBOL | N/A  | N/A  | N/A
Mathematica | `Complex` | N/A  | N/A  | `Complex`

* ^a The value of `n` is provided by the `SELECTED_REAL_KIND`[8] intrinsic function.
* ^b Generic type which can be instantiated with any base floating point type.

### Other variable types

| Text  | Boolean  | Enumeration | Object/Universal

|
|
|
|

Character | String[a]
Ada[1] | `Character` | `String`, `Bounded_String`, `Unbounded_String` | `Boolean` | `(item1, item2, ...)` | `tagged null record`
ALGOL 68 | `char` | `string`, `bytes` | `bool`, `bits` | N/A - User defined | N/A
C (C99)  | `char`, `wchar_t` | N/A  | `bool`[b] | `enum «name» { item1, item2, ... };` | `void *`
C++ (STL)  | `«std::»string`
Objective-C | `unichar` | `NSString *` | `BOOL` | `id`
C# | `char` | `string` | `bool` | `enum name { item1« = value», item2« = value», ... }` | object
Java | `String` | `boolean` | `enum name { item1, item2, ... }` | `Object`
Go | `byte`, `rune` | `string` | `bool` | `const (
item1 = iota
item2
...
)` | `interface{}`
Rust | `char` | `String` | `bool` | `enum name { item1« = value», item2« = value», ... }` | `std::any::Any`
Swift | `Character` | `String` | `Bool` | `enum name { case item1, item2, ... }` | `Any`
D | `char` | `string` | `bool` | `enum name { item1, item2, ... }` | `std.variant.Variant`
Common Lisp | `character` | `string` | `boolean` | `(member item1 item2 ...)` | `t`
Scheme |  |  |  |  |
ISLISP |  |  |  |  |
Pascal (ISO)  | `char` | N/A  | `boolean` | `( item1, item2, ... )` | N/A
Object Pascal (Delphi)  | `string` | `variant`
Visual Basic | N/A  | `String` | `Boolean` | `Enum name
item1 «= value»
item2 «= value»
...
End Enum` | `[[Variant type|Variant]]`
Visual Basic .NET | `Char` | `Object`
Xojo | N/A  | `Object` or `Variant`
Python | N/A[d] | `str` | `bool` | `from enum import Enum
class Name(Enum):
item1 = value
item2 = value
...` | `object`
JavaScript | N/A[d] | `String` | `Boolean` |  | `Object`
S-Lang  |  |  |  |  |
Fortran | `CHARACTER(LEN = *)` | `CHARACTER(LEN = :), allocatable` | `LOGICAL(KIND = n)`[f] |  | `CLASS(*)`
PHP | N/A[d] | `string` | `bool` |  | (type declaration omitted)
Perl | N/A[d] |  |  |  | `UNIVERSAL`
Raku | `Char` | `Str` | `Bool` | `enum name<item1 item2 ...>`
`enum name <<:item1(value) :item2(value) ..>>` | `Mu`
Ruby | N/A[d] | `String` | `Object`[c] |  | `Object`
Scala | `Char` | `String` | `Boolean` | `object name extends Enumeration {
val item1, item2, ... = Value
}` | `Any`
Seed7 | `char` | `string` | `boolean` | `const type: name is new enum
item1,
item2,
...
end enum;` |
Windows PowerShell  |  |  |  |  |
OCaml | `char` | `string` | `bool` | N/A[e] | N/A
F# | `type name = item1 = value |item2 = value | ...` | `obj`
Standard ML | N/A[e] | N/A
Haskell (GHC)  | `Char` | `String` | `Bool` | N/A[e] | N/A
Eiffel | `CHARACTER` | `STRING` | `BOOLEAN` | N/A  | `ANY`
COBOL | `PIC X` | `PIC X(string length)` or `PIC X«X...»` | `PIC 1«(number of digits)»` or `PIC 1«1...»` | N/A  | `OBJECT REFERENCE`
Mathematica | N/A[d] | `String` |  |  | N/A

* ^a specifically, strings of arbitrary length and automatically managed.
* ^b This language represents a boolean as an integer where false is represented as a value of zero and true by a non-zero value.
* ^c All values evaluate to either true or false. Everything in `TrueClass` evaluates to true and everything in `FalseClass` evaluates to false.
* ^d This language does not have a separate character type. Characters are represented as strings of length 1.
* ^e Enumerations in this language are algebraic types with only nullary constructors
* ^f The value of `n` is provided by the `SELECTED_INT_KIND`[4] intrinsic function.

## Derived types

### Array

Further information: Comparison of programming languages (array)

| fixed size array  | dynamic size array

|
|

one-dimensional array | multidimensional array | one-dimensional array | multidimensional array
Ada[1] | `array (<first> .. <last>) of <type>`

`array (<discrete_type>) of <type>` | `array (<first1> .. <last1>, <first2> .. <last2>, ...) of <type>`

`array (<discrete_type1>, <discrete_type2>, ...) of <type>` | `array (<discrete_type> range <>) of <type>` | `array (<discrete_type1> range <>, <discrete_type2> range <>, ...) of <type>`
ALGOL 68 | `[first:last]«modename»`
or simply:
`[size]«modename»` | `[first1:last1, first2:last2]«modename»`

`[first1:last1][first2:last2]«modename»`
etc.  | `flex[first:last]«modename»`
or simply:
`flex[size]«modename»` | `flex[first1:last1, first2:last2]«modename»`

`flex[first1:last1]flex[first2:last2]«modename» etc.`
C (C99)  | `type name[size]`[a] | `type name[size1][size2]`[a] | `type *name`
or within a block:
`int n = ...; type name[n]` |
C++ (STL)  | `«std::»array<type, size>`(C++11)  |  | `«std::»vector<type>`
C# | `type[]` | `type[ ...]` | `System.Collections.ArrayList`

`System.Collections.Generic.List<type>` |
Java | `type[]`[b] | `type[][]...`[b] | `ArrayList or ArrayList<type>` |
D | `type[size]` | `type[size1][size2]` | `type[]` |
Go | `[size]type` | `[size1][size2]...type` | `[]type` | `[][]type`
Rust | `[type; size]` | `[[type; size1]; size2]` | `Vec<type>` | `Vec<Vec<type>>`
Swift |  |  | `[type]` or `Array<type>` | `type` or `Array<Array<type>>`
Objective-C | `NSArray` |  | `NSMutableArray` |
JavaScript | N/A  | N/A  | `Array`[d]
Common Lisp | `(simple-array type (dimension))` | `(simple-array type (dimension1 dimension2))` | `(array type (dimension))` | `(array type (dimension1 dimension2))`
Scheme |  |  |  |
ISLISP |  |  |  |
Pascal | `array[first..last] of type`[c] | `array[first1..last1] of array[first2..last2] ... of type`[c]

` array[first1..last1, first2..last2, ...] of type`[c] | N/A  | N/A
Object Pascal (Delphi)  | `array of type` | `array of array ... of type`
Visual Basic | `Dim x(last) As type` | `Dim x(last1, last2,...) As type` |  |
Visual Basic .NET | `type()` | `type( ...)` | `System.Collections.ArrayList`

`System.Collections.Generic.List(Of type)` |
Python |  |  | `list` |
S-Lang  | `x = type[size];` | `x = type[size1, size2, ...];` |  |
Fortran | `type :: name(size)` | `type :: name(size1, size2,...)` | `type, ALLOCATABLE :: name(:)` | `type, ALLOCATABLE :: name(:,:,...)`
PHP |  |  | `array` |
Perl |  |  |  |
Raku |  |  | `Array[type] or Array of type` |
Ruby |  | `x = Array.new(size1){ Array.new(size2) }` | `Array` |
Scala | `Array[type]` | `Array[...[Array[type]]...]` | `ArrayBuffer[type]` |
Seed7 | `array type`

`array [idxType] type` | `array array type`

`array [idxType] array [idxType] type` | `array type`

`array [idxType] type` | `array array type`

`array [idxType] array [idxType] type`
Smalltalk | `Array` |  | `OrderedCollection` |
Windows PowerShell  | `type[]` | `type[ ...]` |  |
OCaml | `type array` | `type array ... array` |  |
F# | `type []`

`type array` | `type [ ...]` | `System.Collections.ArrayList`

`System.Collections.Generic.List<type>` |
Standard ML | `type vector or type array` |  |  |
Haskell (GHC)  | `x = Array.array (0, size-1) list_of_association_pairs` | `x = Array.array ((0, 0,...), (size1-1, size2-1,...)) list_of_association_pairs` |  |
COBOL | `level-number type OCCURS size «TIMES».` | one-dimensional array definition... | `level-number type OCCURS min-size TO max-size «TIMES» DEPENDING «ON» size.`[e] | N/A

* ^a In most expressions (except the `sizeof` and `&` operators), values of array types in C are automatically converted to a pointer of its first argument. See C syntax for further details of syntax and pointer operations.
* ^b The C-like `type x[]` works in Java, however `type[] x` is the preferred form of array declaration.
* ^c Subranges are used to define the bounds of the array.
* ^d JavaScript's array are a special kind of object.
* ^e The `DEPENDING ON` clause in COBOL does not create a true variable length array and will always allocate the maximum size of the array.

### Other types

| Simple composite types  | Algebraic data types | Unions

|
|
|

Records | Tuple expression
Ada[1] | `type name is «abstract» «tagged» «limited» [record
field1 : type;
field2 : type;
...
end record | null record]` | N/A  | Any combination of records, unions, and enumerations (as well as references to those, enabling recursive types).  | `type name (variation : discrete_type) is record
case variation is
when choice_list1 =>
fieldname1 : type;
...
when choice_list2 =>
fieldname2 : type;
...
...
end case;
end record`
ALGOL 68 | `struct (modename «fieldname», ...);` | Required types and operators can be user-defined | `union (modename, ...);`
C (C99)  | `struct «name» {type name;...};` | N/A  | N/A  | `union {type name;...};`
Objective-C
C++ | `struct «name» {type name;...};`[b] | `«std::»tuple<type1..typen>`
C# | `struct name {type name;...}` | `(val1, val2, ... )` |  | N/A
Java | N/A[a] |  |
JavaScript |  | N/A  |
D | `struct name {type name;...}` |  | `std.variant.Algebraic!(type,...)` | `union {type name;...}`
Go | `struct {
«name» type
...
}` |  |  |
Rust | `struct name {name: type, ...}` | `(val1, val2, ... )` | `enum name { Foo(types), ...}` | `union name {name: type, ...}`
Swift | `struct name {
var name «: type»
...
}` | `(«name1:» val1, «name2:» val2, «name3:» val3, ... )` | `enum name { case Foo«(types)» case Bar «(types)» ... }` |
Common Lisp | `(defstruct name slot-name (slot-name initial-value) (slot-name initial-value :type type) ...)` | `(cons val1 val2)`[c] |  |
Scheme | N/A  |  |
ISLISP |  |  |
Pascal | `record
name: type;
...
end` | N/A  | N/A  | `record
case type of
value: (types);
...
end`
Visual Basic |  |  |  |
Visual Basic .NET | `Structure name
Dim name As type
...
End Structure` | `(val1, val2, ... )` |  |
Python | N/A[a] | `«(»val1, val2, val3, ... «)»` |  | N/A
S-Lang  | `struct {name [=value], ...}` |  |  |
Fortran | `TYPE name
type :: name
...
END TYPE` |  |  |
PHP | N/A[a] |  |  |
Perl | N/A[d] |  |  | N/A
Raku | N/A[a] |  |
Ruby | `OpenStruct.new({:name => value})` |  |
Scala | `case class name(«var» name: type, ...)` | `(val1, val2, val3, ... )` | `abstract class name
case class Foo(«parameters») extends name
case class Bar(«parameters») extends name
...`

`abstract class name
case object Foo extends name
case object Bar extends name
...`
or a combination of case classes and case objects  |
Windows PowerShell  |  |  |  |
OCaml | `type name = {«mutable» name : type;...}` | `«(»val1, val2, val3, ... «)»` | `type name = Foo «of type» | Bar «of type» | ...` | N/A

Standard ML | `type name = {name : type,...}` | `(val1, val2, val3, ... )` | `datatype name = Foo «of type» | Bar «of type» | ...`
Haskell | `data Name = Constr {name :: type,...}` | `data Name = Foo «types» | Bar «types» | ...`
COBOL | `level-number name type clauses.
level-number+n name type clauses.
...` | N/A  | N/A  | `name REDEFINES variable type.`

* ^a Only classes are supported.
* ^b `struct`s in C++ are actually classes, but have default public visibility and are also POD objects. C++11 extended this further, to make classes act identically to POD objects in many more cases.
* ^c pair only
* ^d Although Perl doesn't have records, because Perl's type system allows different data types to be in an array, "hashes" (associative arrays) that don't have a variable index would effectively be the same as records.
* ^e Enumerations in this language are algebraic types with only nullary constructors

## Variable and constant declarations

| variable  | constant  | type synonym

|
|
|

Ada[1] | `identifier : type« := initial_value»`[e] | `identifier : constant type := final_value` | `subtype identifier is type`
ALGOL 68 | `modename name« := initial_value»;` | `modename name = value;` | `mode synonym = modename;`
C (C99)  | `type name« = initial_value»;` | `enum{ name = value };` | `typedef type synonym;`
Objective-C
C++ | `const type name = value;`
C# | `type name1« = initial_value», name2« = initial_value», ...;`

`var name = initial_value;` | `const type name = value, name = value, ...;`

`readonly type name = value, name = value, ... ;` | `using synonym = type;`
D | `type name« = initial_value»;`

`auto name = value;` | `const type name = value;`

`immutable type name = value;` | `alias type synonym;`
Java | `type name« = initial_value»;` | `final type name = value;` | N/A
JavaScript | `var name« = initial_value»;` or
`let name« = initial_value»;` (since ECMAScript 2015)  | `const name = value;` (since ECMAScript 2015)
Go | `var name type« = initial_value»`

`name := initial_value` | `const name «type» = value` | `type synonym type`
Rust[f] | `let mut name«: type»« = initial_value»;`
`static mut NAME: type = value;` | `let name«: type»« = initial_value»;`
`const NAME: type = value;`

`static NAME: type = value;` | `type synonym = typename;`
Swift | `var name «: type»« = initial_value»` | `let name «: type» = value` | `typealias synonym = type`
Common Lisp | `(defparameter name initial-value)`

`(defvar name initial-value)` | `(defconstant name value)` | `(deftype synonym () 'type)`
Scheme | `(define name initial_value)` |  |
ISLISP | `(defglobal name initial_value)`

`(defdynamic name initial_value)` | `(defconstant name value)` | N/A
Pascal[a] | `name: type« = initial_value»` | `name = value` | `synonym = type`
Visual Basic | `Dim name «As type»` | See notes to left.

Constants use the same syntax, and:

* use `Const` instead of `Dim`
* have a restriction to only certain primitive types
`Const name1 «As type» = value, name2 «As type» = value, ...`

Visual Basic .NET[10] | The variable declaration syntax of VB.NET is unusually difficult to precisely describe.

Given that there exist the identifier suffixes ("modifiers"):

* `type_character`, available as an alternative to an `As` clause for some primitive data types;
* `nullable_specifier`; and
* `array_specifier`;

and that

* a `modified_identifier` is of the form `identifier«type_character»«nullable_specifier»«array_specifier»`;
* a `modified_identifier_list` is a comma-separated list of two or more occurrences of `modified_identifier`; and
* a `declarator_list` is a comma-separated list of declarators, which can be of the form
* `identifier As object_creation_expression` (object initializer declarator),
* `modified_identifier «As non_array_type«array_rank_specifier»»« = initial_value»` (single declarator), or
* `modified_identifier_list «As «non_array_type««array_rank_specifier»»` (multiple declarator);

valid declaration statements are of the form Script error: No such module "in5".`Dim declarator_list`, where, for the purpose of semantic analysis, to convert the `declarator_list` to a list of only single declarators:

* The `As` clauses of each multiple declarator is distributed over its `modified_identifier_list`
* The `As New type...` of each object initializer declarator is replaced with `As type = New type...`

and for which, for each `identifier`,

* a `type_character` and `As` clause do not both appear;
* if an `As` clause is present,
* an `array_rank_specifier` does not appear both as a modification of the identifier and on the type of the `As` clause;
* an `unmodified_type` can be determined, by the rule that,
* if a `type_character` or `As` clause is present,
* `unmodified_type` is that specified by such construct,
* and that otherwise,
* either `Option Infer` must be on and the `identifier` must have an initializer, in which case `unmodified_type` is that of the initializer, or
* `Option Strict` must be off, in which case `unmodified_type` is `Object`;
* its `final_type` is its `unmodified_type` prepended before its modifiers;
* its `final_type` is a valid type; and
* if an `initial_value` is present,
* either `Option Strict` is on and `initial_value` has a widening conversion to `final_type`, or
* `Option Strict` is off and `initial_value` has a narrowing conversion to `final_type`.

If `Option Explicit` is off, variables do not require explicit declaration; they are declared implicitly when used: `name = initial_value`

| `Imports synonym = type`
Xojo | `Dim name «As type»« = initial_value»` | N/A
Python | `name«: type» = initial_value` | N/A  | `synonym = type`[b]
CoffeeScript | `name = initial_value`
S-Lang  | `name = initial_value;` |  | `typedef struct {...} typename`
Fortran | type name  | `type, PARAMETER :: name = value` |
PHP | `$name = initial_value;` | `define("name", value);
const name = value (5.3+)` | N/A
Perl | `«my» $name« = initial_value»;`[c] | `use constant name => value;`
Raku | `«my «type»» $name« = initial_value»;`[c] | `«my «type»» constant name = value;` | `::synonym ::= type`
Ruby | `name = initial_value` | `Name = value` | `synonym = type`[b]
Scala | `var name«: type» = initial_value` | `val name«: type» = value` | `type synonym = type`
Windows PowerShell  | `«[type]» $name = initial_value` | N/A  | N/A
Bash shell  | `name=initial_value` | N/A  | N/A
OCaml | `let name« : type ref» = ref value`[d] | `let name «: type» = value` | `type synonym = type`
F# | `let mutable name «: type» = value`
Standard ML | `val name «: type ref» = ref value`[d] | `val name «: type» = value`
Haskell |  | `«name::type;» name = value` | `type Synonym = type`
Forth | `VARIABLE name` (in some systems use `value VARIABLE name` instead)  | `value CONSTANT name` |
COBOL | `level-number name type clauses.` | `«0»1 name CONSTANT «AS» value.` | `level-number name type clauses «IS» TYPEDEF.`
Mathematica | `name=initial_value` | N/A  | N/A

* ^a Pascal has declaration blocks. See functions.
* ^b Types are just regular objects, so you can just assign them.
* ^c In Perl, the "my" keyword scopes the variable into the block.
* ^d Technically, this does not declare name to be a mutable variable—in ML, all names can only be bound once; rather, it declares name to point to a "reference" data structure, which is a simple mutable cell. The data structure can then be read and written to using the `!` and `:=` operators, respectively.
* ^e If no initial value is given, an invalid value is automatically assigned (which will trigger a run-time exception if it used before a valid value has been assigned). While this behaviour can be suppressed it is recommended in the interest of predictability. If no invalid value can be found for a type (for example in case of an unconstraint integer type), a valid, yet predictable value is chosen instead.
* ^f In Rust, if no initial value is given to a `let` or `let mut` variable and it is never assigned to later, there is an "unused variable" warning. If no value is provided for a `const` or `static` or `static mut` variable, there is an error. There is a "non-upper-case globals" error for non-uppercase `const` variables. After it is defined, a `static mut` variable can only be assigned to in an `unsafe` block or function.

## Control flow

### Conditional statements

| if  | else if  | select case | conditional expression

|
|
|
|

Ada[1] | `if condition then
statements
«else
statements»
end if` | `if condition1 then
statements
elsif condition2 then
statements
...
«else
statements»
end if` | `case expression is
when value_list1 => statements
when value_list2 => statements
...
«when others => statements»
end case` | `(if condition1 then
expression1
«elsif condition2 then
expression2»
...
else
expressionn

`(case expression is
when value_list1 => expression1
when value_list2 => expression2
...
«when others => expressionn»

Seed7 | `if condition then
statements
«else
statements»
end if` | `if condition1 then
statements
elsif condition2 then
statements
...
«else
statements»
end if` | `case expression of
when set1 : statements
...
«otherwise: statements»
end case` |
Modula-2 | `if condition then
statements
«else
statements»
end` | `if condition1 then
statements
elsif condition2 then
statements
...
«else
statements»
end` | `case expression of
caseLabelList : statements |
...
«else statements»
end` |
ALGOL 68 | `if condition then statements «else statements» fi` | `if condition then statements elif condition then statements fi` | `case switch in statements, statements«,... out statements» esac` | `( condition | valueIfTrue | valueIfFalse )`
ALGOL 68
(brief form)  | `( condition | statements «| statements» )` | `( condition | statements |: condition | statements )` | `( variable | statements,... «| statements» )` |
APL | `:If condition
instructions
«:Else
instructions»
:EndIf` | `:If condition
instructions
:ElseIf condition
instructions
...
«:Else
instructions»
:EndIf` | `:Select expression
:Case case1
instructions
...
«:Else
instructions»
:EndSelect` | `{condition:valueIfTrue ⋄ valueIfFalse}`
C (C99)  | `if (condition) instructions
«else instructions»`
`instructions` can be a single statement or a block in the form of: `{ statements }` | `if (condition) instructions
else if (condition) instructions
...
«else instructions»`

`if (condition) instructions
else { if (condition) instructions }` | `switch (variable) {
case case1: instructions «; break;»
...
«default: instructions»
}` | `condition ? valueIfTrue : valueIfFalse`
Objective-C
C++ (STL)

Java
JavaScript
PHP
C# | `if (condition) instructions
«else instructions»`

`instructions` can be a single statement or a block in the form of: `{ statements }`

| `if (condition) instructions
else if (condition) instructions
...
«else instructions»` | `switch (variable)

case case1:
instructions
«break_or_jump_statement»
...
«default:
instructions
break_or_jump_statement»

All non-empty cases must end with a `break` or `goto case` statement (that is, they are not allowed to fall-through to the next case). The `default` case is not required to come last.

| `condition ? valueIfTrue : valueIfFalse`
Windows PowerShell  | `if (condition) instruction
«else instructions»` | `if (condition) { instructions }
elseif (condition) { instructions }
...
«else { instructions }»` | `switch (variable) { case1{instructions «break;» } ... «default { instructions }»}` |
Go | `if condition {instructions}
«else {instructions}»` | `if condition {instructions}
else if condition {instructions}
...
«else {instructions}»`

`switch {
case condition: instructions
...
«default: instructions»
}` | `switch variable {
case case1: instructions
...
«default: instructions»
}` |
Swift | `if condition {instructions}
«else {instructions}»` | `if condition {instructions}
else if condition {instructions}
...
«else {instructions}»` | `switch variable {
case case1: instructions
...
«default: instructions»
}` |
Perl | `if (condition) {instructions}
«else {instructions}»`

`unless (notcondition) {instructions}
«else {instructions}»` | `if (condition) {instructions}
elsif (condition) {instructions}
...
«else {instructions}»`

`unless (notcondition) {instructions}
elsif (condition) {instructions}
...
«else {instructions}»` | `use feature "switch";
...
given (variable) {
when (case1) { instructions }
...
«default { instructions }»
}` | `condition ? valueIfTrue : valueIfFalse`
Raku | `if condition {instructions}
«else {instructions}»`

`unless notcondition {instructions}` | `if condition {instructions}
elsif condition {instructions}
...
«else {instructions}` | `given variable {
when case1 { instructions }
...
«default { instructions }»
}` | `condition ?? valueIfTrue !! valueIfFalse`
Ruby | `if condition
instructions
«else
instructions»` | `if condition
instructions
elsif condition
instructions
...
«else
instructions»
end` | `case variable
when case1
instructions
...
«else
instructions»
end` | `condition ? valueIfTrue : valueIfFalse`
Scala | `if (condition) {instructions}
«else {instructions}»` | `if (condition) {instructions}
else if (condition) {instructions}
...
«else {instructions}»` | `expression match {
case pattern1 => expression
case pattern2 => expression
...
«case _ => expression»
}`[b] | `if (condition) valueIfTrue else valueIfFalse`
Smalltalk | `condition ifTrue:
trueBlock
«ifFalse:
falseBlock»
end` |  |  | `condition ifTrue: trueBlock ifFalse: falseBlock`
Common Lisp | `(when condition
instructions)`

`(unless condition
instructions)`

`(if condition
(progn instructions)
«(progn instructions)»)` | `(cond (condition1 instructions)
(condition2 instructions)
...
«(t instructions)»)` | `(case expression
(case1 instructions)
(case2 instructions)
...
«(otherwise instructions)»)` | `(if test then else)`

`(cond (test1 value1) (test2 value2) ...))`
Scheme | `(when condition instructions)`

`(if condition (begin instructions) «(begin instructions)»)` | `(cond (condition1 instructions) (condition2 instructions) ... «(else instructions)»)` | `(case (variable) ((case1) instructions) ((case2) instructions) ... «(else instructions)»)` | `(if condition valueIfTrue valueIfFalse)`
ISLISP | `(if condition
(progn instructions)
«(progn instructions)»)` | `(cond (condition1 instructions)
(condition2 instructions)
...
«(t instructions)»)` | `(case expression
(case1 instructions)
(case2 instructions)
...
«(t instructions)»)` | `(if condition valueIfTrue valueIfFalse)`
Pascal | `if condition then begin
instructions
end
«else begin
instructions
end»'`[c] | `if condition then begin
instructions
end
else if condition then begin
instructions
end
...
«else begin
instructions
end»`[c] | `case variable of
case1: instructions
...
«else: instructions»
end`[c]
Visual Basic | `If condition Then
instructions
«Else
instructions»
End If`
Single-line, when `instructions` are `instruction1 : instruction2 : ...`:
`If condition Then instructions «Else instructions»` | `If condition Then
instructions
ElseIf condition Then
instructions
...
«Else
instructions»
End If`
Single-line:
See note about C-like languages; the `Else` clause of a single-line `If` statement can contain another single-line `If` statement.  | `Select« Case» variable
Case case_pattern1
instructions
...
«Case Else
instructions»
End Select` | `IIf(condition, valueIfTrue, valueIfFalse)`
Visual Basic .NET | `If(condition, valueIfTrue, valueIfFalse)`
Xojo
Python[a] | `if condition :
instructions
«else:
instructions»` | `if condition :
instructions
elif condition :
instructions
...
«else:
instructions»` | Python 3.10+:
`match variable:
case case1:
instructions
case case2:
instructions` | Python 2.5+:
`valueIfTrue if condition else valueIfFalse`
S-Lang  | `if (condition) { instructions } «else { instructions }»` | `if (condition) { instructions } else if (condition) { instructions } ... «else { instructions }»` | `switch (variable) { case case1: instructions } { case case2: instructions } ...` |
Fortran | `IF (condition) THEN
instructions
ELSE
instructions
ENDIF` | `IF (condition) THEN
instructions
ELSEIF (condition) THEN
instructions
...
ELSE
instructions
ENDIF` | `SELECT CASE(variable)
CASE (case1)
instructions
...
CASE DEFAULT
instructions
END SELECT` |
Forth | `condition IF instructions « ELSE instructions» THEN` | `condition IF instructions ELSE condition IF instructions THEN THEN` | `value CASE
case OF instructions ENDOF
case OF instructions ENDOF
default instructions
ENDCASE` | `condition IF valueIfTrue ELSE valueIfFalse THEN`
OCaml | `if condition then begin instructions end «else begin instructions end»` | `if condition then begin instructions end else if condition then begin instructions end ... «else begin instructions end»` | `match value with
pattern1 -> expression
| pattern2 -> expression
...
«| _ -> expression»`[b] | `if condition then valueIfTrue else valueIfFalse`
F# | Lightweight syntax mode:

Either on a single line or with indentation as shown below: `if condition then
instructions
«else
instructions»`
Verbose syntax mode:
Same as Standard ML.

| Lightweight syntax mode:
Either on a single line or with indentation as shown below:
`if condition then
instructions
elif condition then
instructions
...
«else
instructions»`
Verbose syntax mode:
Same as Standard ML.
Standard ML | `if condition then «(»instructions «)»
else «(» instructions «)»` | `if condition then «(»instructions «)»
else if condition then «(» instructions «)»
...
else «(» instructions «)»` | `case value of
pattern1 => expression
| pattern2 => expression
...
«| _ => expression»`[b]
Haskell (GHC)  | `if condition then expression else expression`

`when condition (do instructions)`

`unless notcondition (do instructions)` | `result | condition = expression
| condition = expression
| otherwise = expression` | `case value of {
pattern1 -> expression;
pattern2 -> expression;
...
«_ -> expression»
}`[b]
Bash shell  | `if condition-command; then
expression
«else
expression»
fi` | `if condition-command; then
expression
elif condition-command; then
expression
«else
expression»
fi` | `case "$variable" in
"$condition1" )
command...
"$condition2" )
command...
esac` |
CoffeeScript | `if condition then expression «else expression»`

`if condition
expression
«else
expression»`

`expression if condition`

`unless condition
expression
«else
expression»`

`expression unless condition` | `if condition then expression else if condition then expression «else expression»`

`if condition
expression
else if condition
expression
«else
expression»`

`unless condition
expression
else unless condition
expression
«else
expression»` | `switch expression
when condition then expression
else expression`

`switch expression
when condition
expression
«else
expression»` | All conditions are expressions.
COBOL | `IF condition «THEN»
expression
«ELSE
expression».`[d] |  | `EVALUATE expression «ALSO expression...»
WHEN case-or-condition «ALSO case-or-condition...»
expression
...
«WHEN OTHER
expression»
END-EVALUATE` |
Rust | `if condition {
expression
}« else {
expression
}»` | `if condition {
expression
} else if condition {
expression
}« else {
expression
}»` | `match variable {
pattern1 => expression,
pattern2 => expression,
pattern3 => expression,
«_ => expression»
}`[b][e] | All conditions are expressions
| if  | else if  | select case | conditional expression

* ^a A single instruction can be written on the same line following the colon. Multiple instructions are grouped together in a block which starts on a newline (The indentation is required). The conditional expression syntax does not follow this rule.
* ^b This is pattern matching and is similar to select case but not the same. It is usually used to deconstruct algebraic data types.
* ^c In languages of the Pascal family, the semicolon is not part of the statement. It is a separator between statements, not a terminator.
* ^d `END-IF` may be used instead of the period at the end.
* ^e In Rust, the comma (`,`) at the end of a match arm can be omitted after the last match arm, or after any match arm in which the expression is a block (ends in possibly empty matching brackets `{}`).

### Loop statements

| while loop | do while loop | (count-controlled) for loop | foreach

|
|
|
|

Ada[1] | `while condition loop
statements
end loop` | `loop
statements
exit when not condition
end loop` | `for index in «reverse» [first .. last | discrete_type] loop
statements
end loop` | `for item of «reverse» iterator loop
statements
end loop`

`(for [all | some] [in | of] [first .. last | discrete_type | iterator] => predicate)`[b]
ALGOL 68 | `«for index» «from first» «by increment» «to last» «while condition» do statements od` | `for key «to upb list» do «typename val=list[key];» statements od`
`«while condition»
do statements od` | `«while statements; condition»
do statements od` | `«for index» «from first» «by increment» «to last» do statements od`
APL | `:While condition
statements
:EndWhile` | `:Repeat
statements
:Until condition` | `:For var«s» :In list
statements
:EndFor` | `:For var«s» :InEach list
statements
:EndFor`
C (C99)  | `instructions` can be a single statement or a block in the form of: `{ statements }`
`while (condition) instructions` | `do instructions while (condition);` | `for («type» i = first; i <= last; i++) instructions` | N/A
Objective-C | `for (type item in set) instructions`
C++ (STL)  | `«std::»for_each(start, end, function)`
Since C++11:
`for (type item : set) instructions`
C# | `foreach (type item in set) instructions`
Java | `for (type item : set) instructions`
JavaScript | `for (var i = first; i <= last; i++) instructions` | Since EcmaScript 2015:[11]

`for (var item of set) instructions`

PHP | `foreach (range(first, last) as $i) instructions`

`for ($i = first; $i <= last; $i++) instructions` | `foreach (set as item) instructions`

`foreach (set as key => item) instructions`
Windows PowerShell  | `for ($i = first; $i -le last; $i++) instructions` | `foreach (item in set) instructions`
D | `foreach (i; first ... last) instructions` | `foreach («type» item; set) instructions`
Go | `for condition { instructions }` |  | `for i := first; i <= last; i++ { instructions }` | `for key, item := range set { instructions }`
Swift | `while condition { instructions }` | 2.x:
`repeat { instructions } while condition`
1.x:
`do { instructions } while condition` | `for i = first ... last { instructions }`

`for i = first ..< last+1 { instructions }`

`for var i = first; i <= last; i++ { instructions }` | `for item in set { instructions }`
Perl | `while (condition) { instructions }`

`until (notcondition) { instructions }` | `do { instructions } while (condition)`

`do { instructions } until (notcondition)` | `for«each» «$i» (first .. last) { instructions }`

`for ($i = first; $i <= last; $i++) { instructions }` | `for«each» «$item» (set) { instructions }`
Raku | `while condition { instructions }`

`until notcondition { instructions }` | `repeat { instructions } while condition`

`repeat { instructions } until notcondition` | `for first..last -> $i { instructions }`

`loop ($i = first; $i <=last; $i++) { instructions }` | `for set« -> $item» { instructions }`
Ruby | `while condition
instructions
end`

`until notcondition
instructions
end` | `begin
instructions
end while condition`

`begin
instructions
end until notcondition` | `for i in first..last
instructions
end`

`for i in first...last+1
instructions
end`

`first.upto(last) { |i| instructions }` | `for item in set
instructions
end`

`set.each { |item| instructions }`
Bash shell  | `while condition ;do
instructions
done`

`until notcondition ;do
instructions
done` | N/A  | `for ((i = first; i <= last; ++i)) ; do
instructions
done` | `for item in set ;do
instructions
done`
Scala | `while (condition) { instructions }` | `do { instructions } while (condition)` | `for (i <- first to last «by 1») { instructions }`

`first to last «by 1» foreach (i => { instructions })` | `for (item <- set) { instructions }`

`set foreach (item => { instructions })`
Smalltalk | `conditionBlock whileTrue:
loopBlock` | `loopBlock doWhile:
conditionBlock` | `first to: last do:
loopBlock` | `collection do:
loopBlock`
Common Lisp | `(loop
while condition

instructions)`

`(do () (notcondition)
instructions)` | `(loop

instructions
while condition)` | `(loop
for i from first to last «by 1»

instructions)`

`(dotimes (i N)
instructions)`

`(do ((i first (1+ i))) ((>=i last))

instructions)` | `(loop
for item in list

instructions)`

`(loop
for item across vector

instructions)`

`(dolist (item list)
instructions)`

`(mapc function list)`

`(map type function sequence)`
Scheme | `(do () (notcondition) instructions)`

`(let loop () (if condition (begin instructions (loop))))` | `(let loop () (instructions (if condition (loop))))` | `(do ((i first (+ i 1))) ((>= i last)) instructions)`

`(let loop ((i first)) (if (< i last) (begin instructions (loop (+ i 1)))))` | `(for-each (lambda (item) instructions) list)`
ISLISP | `(while condition instructions)` | `(tagbody loop instructions (if condition (go loop))` | `(for ((i first (+ i 1))) ((>= i last)) instructions)` | `(mapc (lambda (item) instructions) list)`
Pascal | `while condition do begin
instructions
end` | `repeat
instructions
until notcondition;` | `for i := first «step 1» to last do begin
instructions
end;`[a] | `for item in set do instructions`
Visual Basic | `Do While condition
instructions
Loop`

`Do Until notcondition
instructions
Loop`

`While condition
instructions
Wend` (Visual Basic .NET uses `End While` instead)  | `Do
instructions
Loop While condition`

`Do
instructions
Loop Until notcondition` | `i` must be declared beforehand.

`For i = first To last «Step 1»
instructions
Next i`

| `For Each item In set
instructions
Next item`
Visual Basic .NET | `For i« As type» = first To last« Step 1»
instructions
Next« i»`[a] | `For Each item« As type» In set
instructions
Next« item»`
Xojo | `While condition
instructions
Wend` | `Do Until notcondition
instructions
Loop`

`Do
instructions
Loop Until notcondition`
Python | `while condition :
instructions
«else:
instructions»` | N/A  | Python 3.x:
`for i in range(first, last+1):
instructions
«else:
instructions»`
Python 2.x:
`for i in xrange(first, last+1):
instructions
«else:
instructions»` | `for item in set:
instructions
«else:
instructions»`
S-Lang  | `while (condition) { instructions } «then optional-block»` | `do { instructions } while (condition) «then optional-block»` | `for (i = first; i <= last; i++) { instructions } «then optional-block»` | `foreach item(set) «using (what)» { instructions } «then optional-block»`
Fortran | `DO WHILE (condition)
instructions
ENDDO` | `DO
instructions
IF (condition) EXIT
ENDDO` | `DO I = first,last
instructions
ENDDO` | N/A
Forth | `BEGIN «instructions» condition WHILE instructions REPEAT` | `BEGIN  instructions condition UNTIL` | `limit start DO instructions LOOP` | N/A
OCaml | `while condition do instructions done` | N/A  | `for i = first to last do instructions done` | `Array.iter (fun item -> instructions) array`

`List.iter (fun item -> instructions) list`
F# | `while condition do
instructions` | N/A  | `for i = first to last do
instructions` | `foritem in set do
instructions`

`Seq.iter (fun item -> instructions) set`
Standard ML | `while condition do ( instructions )` | N/A  | `Array.app (fn item => instructions) array`

`app (fn item => instructions) list`
Haskell (GHC)  | N/A  | `Control.Monad.forM_ [first..last] (\i -> do instructions)` | `Control.Monad.forM_list (\item -> do instructions)`
Eiffel | `from
setup
until
condition
loop
instructions
end`
CoffeeScript | `while condition
expression`

`expression while condition`

`while condition then expression`

`until condition
expression`

`expression until condition`

`until expression then condition` | N/A  | `for i in [first..last]
expression`

`for i in [first..last] then expression`

`expression for i in [first..last]` | `for item in set
expression`

`for item in set then expression`

`expression for item in set`
COBOL | `PERFORM procedure-1 «THROUGH procedure-2» ««WITH» TEST BEFORE» UNTIL condition`[c]

`PERFORM ««WITH» TEST BEFORE» UNTIL condition
expression
END-PERFORM` | `PERFORM procedure-1 «THROUGH procedure-2» «WITH» TEST AFTER UNTIL condition`[c]

`PERFORM «WITH» TEST AFTER UNTIL condition
expression
END-PERFORM` | `PERFORM procedure-1 «THROUGH procedure-2» VARYING i FROM first BY increment UNTIL i > last`[d]

`PERFORM VARYING i FROM first BY increment UNTIL i > last
expression
END-PERFORM`[d] | N/A
Rust | `while condition {
expression
}` | `loop {
expression
if condition {
break;

}` | `for i in first..last+1 {
expression

`for i in first..=last {
expression
}` | `for item in set {
expression
}`[e]

`set.into_iter().for_each(|item| expression);`[e]

* ^a "`step` n" is used to change the loop interval. If "`step`" is omitted, then the loop interval is 1.
* ^b This implements the universal quantifier ("for all" or "∀") as well as the existential quantifier ("there exists" or "∃").
* ^c `THRU` may be used instead of `THROUGH`.
* ^d `«IS» GREATER «THAN»` may be used instead of `>`.
* ^e Type of set expression must implement trait `std::iter::IntoIterator`.

### Exceptions

Further information: Exception handling syntax

| throw  | handler  | assertion

|
|
|

Ada[1] | `raise exception_name «with string_expression»` | `begin
statements
exception
when exception_list1 => statements;
when exception_list2 => statements;
...
«when others => statements;»
end`[b] | `pragma Assert («Check =>» boolean_expression ««Message =>» string_expression»)
[function | procedure | entry] with
Pre => boolean_expression
Post => boolean_expression
any_type with Type_Invariant => boolean_expression`
APL | `«string_expression» ⎕SIGNAL number_expression` | `:Trap number«s»_expression
statements
«:Case number«s»_expression
statements»
...
«:Else number«s»_expression
statements»
:EndTrap` | `«string_expression» ⎕SIGNAL 98/⍨~condition`
C (C99)  | `longjmp(state, exception);` | `switch (setjmp(state)) { case 0: instructions break; case exception: instructions ... }` | `assert(condition);`
C++ | `throw exception;` | `try { instructions } catch «(exception)» { instructions } ...`
C# | `try { instructions } catch «(exception« name»)» { instructions } ... «finally { instructions }»` | `System.Diagnostics.Debug.Assert(condition);`

`System.Diagnostics.Trace.Assert(condition);`
Java | `try { instructions } catch (exception) { instructions } ... «finally { instructions }»` | `assert condition «: description»;`
JavaScript | `try { instructions } catch (exception) { instructions} «finally { instructions }»` | ?
D | `try { instructions } catch (exception) { instructions } ... «finally { instructions }»` | `assert(condition);`
PHP | `try { instructions } catch (exception) { instructions } ... «finally { instructions }»` | `assert(condition);`
S-Lang  | `try { instructions } catch «exception» { instructions } ... «finally { instructions }»` | ?
Windows PowerShell  | `trap «[exception]» { instructions } ... instructions`

`try { instructions } catch «[exception]» { instructions } ... «finally { instructions }»` | `[Debug]::Assert(condition)`
Objective-C | `@throw exception;` | `@try { instructions } @catch (exception) { instructions } ... «@finally { instructions }»` | `NSAssert(condition, description);`
Swift | `throw exception` (2.x)  | `do { try expression ... instructions } catch exception { instructions } ...` (2.x)  | `assert(condition«, description»)`
Perl | `die exception;` | `eval { instructions }; if ($@) { instructions }` | ?
Raku | `try { instructions CATCH { when exception { instructions } ...}}` | ?
Ruby | `raise exception` | `begin
instructions
rescue exception
instructions
...
«else
instructions»
«ensure
instructions»
end` |
Smalltalk | `exception raise` | `instructionBlock on: exception do: handlerBlock` | `assert: conditionBlock`
Common Lisp | `(error "exception")`

`(error
type
arguments)`

`(error (make-condition
type
arguments))` | `(handler-case
(progn instructions)
(exception instructions)
...)`

`(handler-bind
(condition
(lambda
instructions
«invoke-restart restart args»))
...)`[a] | `(assert condition)`

`(assert condition
«(place)
«error»»)`

`(check-type var type)`
Scheme (R6RS)  | `(raise exception)` | `(guard (con (condition instructions) ...) instructions)` | ?
ISLISP | `(error "error-string" objects)`

`(signal-condition condition continuable)` | `(with-handler
handler form*
)` | ?
Pascal | `raise Exception.Create()` | `try Except on E: exception do begin instructions end; end;` | ?
Visual Basic | `Err.Raise ERRORNUMBER` | `With New Try: On Error Resume Next
OneInstruction
.Catch: On Error GoTo 0: Select Case .Number
Case SOME_ERRORNUMBER
instructions
End Select: End With`

'*** Try class ***
Private mstrDescription As String
Private mlngNumber As Long

Public Sub Catch()
mstrDescription = Err.Description
mlngNumber = Err.Number
End Sub

Public Property Get Number() As Long
Number = mlngNumber
End Property

Public Property Get Description() As String
Description = mstrDescription
End Property

[12] | `Debug.Assert condition`
Visual Basic .NET | `Throw exception`

`Error errorcode` | `Try
instructions
Catch« name As exception»« When condition»
instructions
...
«Finally
instructions»
End Try` | `System.Diagnostics.``Debug.Assert(condition)`

`System.Diagnostics.Trace.Assert(condition)`
Xojo | `Raise exception` | `Try
instructions
Catch «exception»
instructions
...
«Finally
instructions»
End Try` | N/A
Python | `raise exception` | `try:
instructions
except «exception»:
instructions
...
«else:
instructions»
«finally:
instructions»` | `assert condition`
Fortran | N/A
Forth | `code THROW` | `xt CATCH ( code or 0 )` | N/A
OCaml | `raise exception` | `try expression with pattern -> expression ...` | `assert condition`
F# | `try expression with pattern -> expression ...`

`try expression finally expression`
Standard ML | `raise exception «arg»` | `expression handle pattern => expression ...` |
Haskell (GHC)  | `throw exception`

`throwError expression` | `catch tryExpression catchExpression`

`catchError tryExpression catchExpression` | `assert condition expression`
COBOL | `RAISE «EXCEPTION» exception` | `USE «AFTER» EXCEPTION OBJECT class-name.`

`USE «AFTER» EO class-name.`

`USE «AFTER» EXCEPTION CONDITION exception-name «FILE file-name».`

`USE «AFTER» EC exception-name «FILE file-name».` | N/A
Rust | No[13] | `assert!(condition)`

* ^a Common Lisp allows `with-simple-restart`, `restart-case` and `restart-bind` to define restarts for use with `invoke-restart`. Unhandled conditions may cause the implementation to show a restarts menu to the user before unwinding the stack.
* ^b Uncaught exceptions are propagated to the innermost dynamically enclosing execution. Exceptions are not propagated across tasks (unless these tasks are currently synchronised in a rendezvous).

### Other control flow statements

| exit block (break)  | continue  | label  | branch (goto)  | return value from generator

|
|
|
|
|

Ada[1] | `exit «loop_name» «when condition»` | N/A  | `label:` | `goto label` | N/A
ALGOL 68 | `value exit;` ...  | `do statements; skip exit; label: statements od` | `label:` ...  | `go to label; ...
goto label; ...
label; ...` | `yield(value)`

(Callback)[14]

APL | `:Leave` | `:Continue` | `label:` | `→label`

`:GoTo label` | N/A
C (C99)  | `break;` | `continue;` | `label:` | `goto label;` | N/A
Objective-C
C++ (STL)

C# | `yield return value;`
Java | `break «label»;` | `continue «label»;` | N/A  |
JavaScript | `yield value«;»`
PHP | `break «levels»;` | `continue «levels»;` | `goto label;` | `yield «key =>» value;`
Perl | `last «label»;` | `next «label»;` |
Raku |
Go | `break «label»` | `continue «label»` | `goto label` |
Swift | `break «label»` | `continue «label»` | N/A  |
Bash shell  | `break «levels»` | `continue «levels»` | N/A  | N/A  | N/A
Common Lisp | `(return)`

`(return-from block)`

`(loop-finish)` |  | `(tagbody tag
...
tag
...)` | `(go tag)` |
Scheme |  |  |  |  |
ISLISP | `(return-from block)` |  | `(tagbody tag
...
tag
...)` | `(go tag)` |
Pascal (ISO)  | N/A  | `label:`[a] | `goto label;` | N/A
Pascal (FPC)  | `break;` | `continue;`
Visual Basic | `Exit block`Alternatively, for methods,
`Return` | N/A  | `label:` | `GoTo label`
Xojo | `Continue block`
Visual Basic .NET | `Yield value`
Python | `break` | `continue` | N/A  | `yield value`
RPG IV  | `LEAVE;` | `ITER;` |  |  |
S-Lang  | `break;` | `continue;` |  |  |
Fortran | `EXIT` | `CYCLE` | `label`[b] | `GOTO label` | N/A
Ruby | `break` | `next` |  |  |
Windows PowerShell  | `break «label»` | `continue` |  |  |
OCaml | N/A  |
F# |
Standard ML |
Haskell (GHC)  |
COBOL | `EXIT PERFORM` or `EXIT PARAGRAPH` or `EXIT SECTION` or `EXIT.` | `EXIT PERFORM CYCLE` | `label «SECTION».` | `GO TO label` | N/A

* ^a Pascal has declaration blocks. See functions.
* ^b label must be a number between 1 and 99999.

## Functions

See reflection for calling and declaring functions by strings.

| calling a function  | basic/void function  | value-returning function  | required main function

|
|
|
|

Ada[1] | `foo «(parameters)»` | `procedure foo «(parameters)» is begin statements end foo` | `function foo «(parameters)» return type is begin statements end foo` | N/A
ALGOL 68 | `foo «(parameters)»;` | `proc foo = «(parameters)» void: ( instructions );` | `proc foo = «(parameters)» rettype: ( instructions ...; retvalue );` | N/A
APL | `«parameters» foo parameters` | `foo←{ statements }` | `foo←{ statements }` | N/A
C (C99)  | `foo(«parameters»)` | `void foo(«parameters») { instructions }` | `type foo(«parameters») { instructions ... return value; }` | `«global declarations»
int main(«int argc, char *argv[]») {
instructions

Objective-C
C++ (STL)
Java | `public static void main(String[] args) { instructions }`

`public static void main(String... args) { instructions }`
D | `int main(«char[][] args») { instructions}`

`int main(«string[] args») { instructions}`

`void main(«char[][] args») { instructions}`

`void main(«string[] args») { instructions}`
C# | Same as above; alternatively, if only one statement:

`void foo(«parameters») => statement;`

| Same as above; alternatively, if simple enough to be an expression:

`void foo(«parameters») => expression;`

| `static void Main(«string[] args») method_body`
May instead return `int`.
(starting with C# 7.1:) May return `Task` or `Task<int>`, and if so, may be `async`.
JavaScript | `function foo(«parameters») { instructions }`

`var foo = function («parameters») { instructions }`

`var foo = new Function ("«parameter»", ..., "«last parameter»" "instructions");` | `function foo(«parameters») { instructions ... return value; }` | N/A
Go | `func foo(«parameters») { instructions }` | `func foo(«parameters») type { instructions ... return value }` | `func main() { instructions }`
Swift | `func foo(«parameters») { instructions }` | `func foo(«parameters») -> type { instructions ... return value }` | N/A
Common Lisp | `(foo «parameters»)` | `(defun foo («parameters»)
instructions)`

`(setf (symbol-function 'symbol)
function)` | `(defun foo («parameters»)
...
value)` | N/A
Scheme | `(define (foo parameters) instructions)`

`(define foo (lambda (parameters) instructions))` | `(define (foo parameters) instructions... return_value)`

`(define foo (lambda (parameters) instructions... return_value))`
ISLISP | `(defun foo («parameters»)
instructions)` | `(defun foo («parameters»)
...
value)`
Pascal | `foo«(parameters)»` | `procedure foo«(parameters)»; «forward;»[a]
«label
label declarations»
«const
constant declarations»
«type
type declarations»
«var
variable declarations»
«local function declarations»
begin
instructions
end;` | `function foo«(parameters)»: type; «forward;»[a]
«label
label declarations»
«const
constant declarations»
«type
type declarations»
«var
variable declarations»
«local function declarations»
begin
instructions;
foo := value
end;` | `program name;
«label
label declarations»
«const
constant declarations»
«type
type declarations»
«var
variable declarations»
«function declarations»
begin
instructions
end.`
Visual Basic | `Foo(«parameters»)` | `Sub Foo«(parameters)»
instructions
End Sub` | `Function Foo«(parameters)»« As type»
instructions
Foo = value
End Function` | `Sub Main()
instructions
End Sub`
Visual Basic .NET | Same as above; alternatively:

`Function Foo«(parameters)»« As type»
instructions
Return value
End Function`
The `As` clause is not required if `Option Strict` is off. A type character may be used instead of the `As` clause.
If control exits the function without a return value having been explicitly specified, the function returns the default value for the return type.

| `Sub Main(««ByVal »args() As String»)
instructions
End Sub`or
`Function Main(««ByVal »args() As String») As Integer
instructions
End Function`
Xojo
Python | `foo(«parameters»)` | `def foo(«parameters»):
instructions` | `def foo(«parameters»):
instructions
return value` | N/A
S-Lang  | `foo(«parameters» «;qualifiers»)` | `define foo («parameters») { instructions }` | `define foo («parameters») { instructions ... return value; }` | `public define slsh_main () { instructions }`
Fortran | `foo («arguments»)
CALL sub_foo («arguments»)`[c] | `SUBROUTINE sub_foo («arguments»)
instructions
END SUBROUTINE`[c] | `type FUNCTION foo («arguments»)
instructions
...
foo = value
END FUNCTION`[c] | `PROGRAM main
instructions
END PROGRAM`
Forth | `«parameters» FOO` | `: FOO « stack effect comment: ( before -- ) »
instructions
;` | `: FOO « stack effect comment: ( before -- after ) »
instructions
;` | N/A
PHP | `foo(«parameters»)` | `function foo(«parameters») { instructions }` | `function foo(«parameters») { instructions ... return value; }` | N/A
Perl | `foo(«parameters»)`

`&foo«(parameters)»` | `sub foo { «my (parameters) = @_;» instructions }` | `sub foo { «my (parameters) = @_;» instructions... «return» value; }`
Raku | `foo(«parameters»)`

`&foo«(parameters)»` | `«multi »sub foo(parameters) { instructions }` | `«our «type» »«multi »sub foo(parameters) { instructions ... «return» value; }`
Ruby | `foo«(parameters)»` | `def foo«(parameters)»
instructions
end` | `def foo«(parameters)»
instructions
«return» value
end`
Rust | `foo(«parameters»)` | `fn foo(«parameters») { instructions }` | `fn foo(«parameters») -> type { instructions }` | `fn main() { instructions }`
Scala | `foo«(parameters)»` | `def foo«(parameters)»«: Unit =» { instructions }` | `def foo«(parameters)»«: type» = { instructions ... «return» value }` | `def main(args: Array[String]) { instructions }`
Windows PowerShell  | `foo «parameters»` | `function foo { instructions };`

`function foo { «param(parameters)» instructions }` | `function foo «(parameters)» { instructions ... return value };`

`function foo { «param(parameters)» instructions ... return value }` | N/A
Bash shell  | `foo «parameters»` | `function foo {
instructions

`foo () {
instructions
}` | `function foo {
instructions
return «exit_code»

`foo () {
instructions
return «exit_code»

* parameters
* `$n` ($1, $2, $3, ...)
* `$@` (all parameters)
* `$#` (the number of parameters)
* `$0` (this function name)

OCaml | `foo parameters` | `let «rec» foo parameters = instructions` | `let «rec» foo parameters = instructions... return_value`
F# | `[<EntryPoint>] let main args = instructions`
Standard ML | `fun foo parameters = ( instructions )` | `fun foo parameters = ( instructions... return_value )` |
Haskell | `foo parameters = do
instructions` | `foo parameters = return_value`

`foo parameters = do
instructions
return value` | `«main :: IO ()»
main = do instructions`
Eiffel | `foo («parameters»)` | `foo («parameters»)
require
preconditions

instructions
ensure
postconditions
end` | `foo («parameters»): type
require
preconditions

instructions
Result := value
ensure
postconditions
end` | [b]
CoffeeScript | `foo()` | `foo = ->` | `foo = -> value` | N/A
`foo parameters` | `foo = () ->` | `foo = ( parameters ) -> value`
COBOL | `CALL "foo" «USING parameters»
«exception-handling»
«END-CALL»`[d] | `«IDENTIFICATION DIVISION.»
PROGRAM-ID. foo.
«other divisions...»
PROCEDURE DIVISION «USING parameters».
instructions.` | `«IDENTIFICATION DIVISION.»
PROGRAM-ID/FUNCTION-ID. foo.
«other divisions...»
DATA DIVISION.
«other sections...»
LINKAGE SECTION.
«parameter definitions...»
variable-to-return definition
«other sections...»
PROCEDURE DIVISION «USING parameters» RETURNING variable-to-return.
instructions.` | N/A
`«FUNCTION» foo«(«parameters»)»` | N/A

* ^a Pascal requires "`forward;`" for forward declarations.
* ^b Eiffel allows the specification of an application's root class and feature.
* ^c In Fortran, function/subroutine parameters are called arguments (since `PARAMETER` is a language keyword); the `CALL` keyword is required for subroutines.
* ^d Instead of using `"foo"`, a string variable may be used instead containing the same value.

## Type conversions

Where string is a signed decimal number:

| string to integer  | string to long integer  | string to floating point  | integer to string  | floating point to string

|
|
|
|
|

Ada[1] | `Integer'Value (string_expression)` | `Long_Integer'Value (string_expression)` | `Float'Value (string_expression)` | `Integer'Image (integer_expression)` | `Float'Image (float_expression)`
ALGOL 68 with general, and then specific formats  | With prior declarations and association of: `string buf := "12345678.9012e34 "; file proxy; associate(proxy, buf);`
`get(proxy, ivar);` | `get(proxy, livar);` | `get(proxy, rvar);` | `put(proxy, ival);` | `put(proxy, rval);`
`getf(proxy, ($g$, ivar));`

`getf(proxy, ($dddd$, ivar));` | `getf(proxy, ($g$, livar));`

`getf(proxy, ($8d$, livar));` | `getf(proxy, ($g$, rvar));`

`getf(proxy, ($8d.4dE2d$, rvar));` | `putf(proxy, ($g$, ival));`

`putf(proxy, ($4d$, ival));` | `putf(proxy, ($g(width, places, exp)$, rval));`

`putf(proxy, ($8d.4dE2d$, rval));`
APL | `⍎string_expression` | `⍎string_expression` | `⍎string_expression` | `⍕integer_expression` | `⍕float_expression`
C (C99)  | `integer = atoi(string);` | `long = atol(string);` | `float = atof(string);` | `sprintf(string, "%i", integer);` | `sprintf(string, "%f", float);`
Objective-C | `integer = [string intValue];` | `long = [string longLongValue];` | `float = [string doubleValue];` | `string = [NSString stringWithFormat:@"%i", integer];` | `string = [NSString stringWithFormat:@"%f", float];`
C++ (STL)  | `«std::»istringstream(string) >> number;` | `«std::»ostringstream o; o << number; string = o.str();`
C++11 | `integer = «std::»stoi(string);` | `long = «std::»stol(string);` | `float = «std::»stof(string); double = «std::»stod(string);` | `string = «std::»to_string(number);`
C# | `integer = int.Parse(string);` | `long = long.Parse(string);` | `float = float.Parse(string);``double = double.Parse(string);` | `string = number.ToString();`
D | `integer = std.conv.to!int(string)` | `long = std.conv.to!long(string)` | `float = std.conv.to!float(string)`
`double = std.conv.to!double(string)` | `string = std.conv.to!string(number)`
Java | `integer = Integer.parseInt(string);` | `long = Long.parseLong(string);` | `float = Float.parseFloat(string);`
`double = Double.parseDouble(string);` | `string = Integer.toString(integer);`
`string = String.valueOf(integer);` | `string = Float.toString(float);`
`string = Double.toString(double);`
JavaScript[a] | `integer = parseInt(string);` | `float = parseFloat(string);`
`float = new Number (string);`
`float = Number (string);`
`float = +string;` | `string = number.toString ();`
`string = String (number);`
`string = number+"";`
`string = `${number}``
Go | `integer, error = strconv.Atoi(string)
integer, error = strconv.ParseInt(string, 10, 0)` | `long, error = strconv.ParseInt(string, 10, 64)` | `float, error = strconv.ParseFloat(string, 64)` | `string = strconv.Itoa(integer)`
`string = strconv.FormatInt(integer, 10)`
`string = fmt.Sprint(integer)` | `string = strconv.FormatFloat(float)`
`string = fmt.Sprint(float)`
Rust[d] | `string.parse::<i32>()`
`i32::from_str(string)` | `string.parse::<i64>()`
`i64::from_str(string)` | `string.parse::<f64>()`
`f64::from_str(string)` | `integer.to_string()` | `float.to_string()`
Common Lisp | `(setf integer (parse-integer string))` | `(setf float (read-from-string string))` | `(setf string (princ-to-string number))`
Scheme | `(define number (string->number string))` | `(define string (number->string number))`
ISLISP | `(setf integer (convert string <integer>))` | `(setf float (convert string <float>))` | `(setf string (convert number <string>))`
Pascal  | `integer := StrToInt(string);` |  | `float := StrToFloat(string);` | `string := IntToStr(integer);` | `string := FloatToStr(float);`
Visual Basic | `integer = CInt(string)` | `long = CLng(string)` | `float = CSng(string)
double = CDbl(string)` | `string = CStr(number)` |
Visual Basic .NET
(can use both VB syntax above and .NET methods shown right)  | `integer = Integer.Parse(string)` | `long = Long.Parse(string)` | `float = Single.Parse(string)`
`double = Double.Parse(string)` | `string = number.ToString()`
Xojo | `integer = Val(string)` | `long = Val(string)` | `double = Val(string)`
`double = CDbl(string)` | `string = CStr(number)`

`string = Str(number)`
Python | `integer = int(string)` | `long = long(string)` | `float = float(string)` | `string = str(number)`
S-Lang  | `integer = atoi(string);` | `long = atol(string);` | `float = atof(string);` | `string = string(number);`
Fortran | `READ(string,format) number` | `WRITE(string,format) number`
PHP | `integer = intval(string);`

`integer = (int)string;` | `float = floatval(string);`
`float = (float)string;` | `string = "$number";`

`string = strval(number);`

`string = (string)number;`
Perl[b] | `number = 0 + string;` | `string = "number";`
Raku | `number = +string;` | `string = ~number;`
Ruby | `integer = string.to_i`

`integer = Integer(string)` | `float = string.to_f`
`float = Float(string)` | `string = number.to_s`
Scala | `integer = string.toInt` | `long = string.toLong` | `float = string.toFloat``double = string.toDouble` | `string = number.toString`
Smalltalk | `integer := Integer readFrom: string` | `float := Float readFrom: string` | `string := number asString`
Windows PowerShell  | `integer = [int]string` | `long = [long]string` | `float = [float]string` | `string = [string]number;`

`string = "number";`

`string = (number).ToString()`
OCaml | `let integer = int_of_string string` |  | `let float = float_of_string string` | `let string = string_of_int integer` | `let string = string_of_float float`
F# | `let integer = int string` | `let integer = int64 string` | `let float = float string` | `let string = string number`
Standard ML | `val integer = Int.fromString string` |  | `val float = Real.fromString string` | `val string = Int.toString integer` | `val string = Real.toString float`
Haskell (GHC)  | `number = read string` | `string = show number`
COBOL | `MOVE «FUNCTION» NUMVAL(string)[c] TO number` | `MOVE number TO numeric-edited`

* ^a JavaScript only uses floating point numbers so there are some technicalities.[7]
* ^b Perl doesn't have separate types. Strings and numbers are interchangeable.
* ^c `NUMVAL-C` or `NUMVAL-F` may be used instead of `NUMVAL`.
* ^ `str::parse` is available to convert any type that has an implementation of the `std::str::FromStr` trait. Both `str::parse` and `FromStr::from_str` return a `Result` that contains the specified type if there is no error. The turbofish (`::<_>`) on `str::parse` can be omitted if the type can be inferred from context.

## Standard stream I/O

| read from  | write to

|
|

stdin  | stdout  | stderr
Ada[1] | `Get (x)` | `Put (x)` | `Put (Standard_Error, x)`
ALGOL 68 | `readf(($format$, x));`

`getf(stand in, ($format$, x));` | `printf(($format$, x));`

`putf(stand out, ($format$, x));` | `putf(stand error, ($format$, x));`[a]
APL | `x←⎕` | `⎕←x` | `⍞←x`
C (C99)  | `scanf(format, &x);`

`fscanf(stdin, format, &x);`[b] | `printf(format, x);`

`fprintf(stdout, format, x);`[c] | `fprintf(stderr, format, x);`[d]
Objective-C | `data = [[NSFileHandle fileHandleWithStandardInput] readDataToEndOfFile];` | `[[NSFileHandle fileHandleWithStandardOutput] writeData:data];` | `[[NSFileHandle fileHandleWithStandardError] writeData:data];`
C++ | `«std::»cin >> x;`

`«std::»getline(«std::»cin, str);` | `«std::»cout << x;` | `«std::»cerr << x;`

`«std::»clog << x;`
C# | `x = Console.Read();`

`x = Console.ReadLine();` | `Console.Write(«format, »x);`

`Console.WriteLine(«format, »x);` | `Console.Error.Write(«format, »x);`

`Console.Error.WriteLine(«format, »x);`
D | `x = std.stdio.readln()` | `std.stdio.write(x)`

`std.stdio.writeln(x)`

`std.stdio.writef(format, x)`

`std.stdio.writefln(format, x)` | `stderr.write(x)`

`stderr.writeln(x)`

`std.stdio.writef(stderr, format, x)`

`std.stdio.writefln(stderr, format, x)`
Java | `x = System.in.read();`

`x = new Scanner(System.in).nextInt();`

`x = new Scanner(System.in).nextLine();` | `System.out.print(x);`

`System.out.printf(format, x);`

`System.out.println(x);` | `System.err.print(x);`

`System.err.printf(format, x);`

`System.err.println(x);`
Go | `fmt.Scan(&x)`

`fmt.Scanf(format, &x)`

`x = bufio.NewReader(os.Stdin).ReadString('\n')` | `fmt.Println(x)`

`fmt.Printf(format, x)` | `fmt.Fprintln(os.Stderr, x)`

`fmt.Fprintf(os.Stderr, format, x)`
Swift | `x = readLine()` (2.x)  | `print(x)` (2.x)
`println(x)` (1.x)  |
JavaScript
Web Browser implementation |  | `document.write(x)` |
JavaScript
Active Server Pages |  | `Response.Write(x)` |
JavaScript
Windows Script Host | `x = WScript.StdIn.Read(chars)`

`x = WScript.StdIn.ReadLine()` | `WScript.Echo(x)`

`WScript.StdOut.Write(x)`

`WScript.StdOut.WriteLine(x)` | `WScript.StdErr.Write(x)`

`WScript.StdErr.WriteLine(x)`
Common Lisp | `(setf x (read-line))` | `(princ x)`

`(format t format x)` | `(princ x *error-output*)`

``(format *error-output*` format x)`
Scheme (R6RS)  | `(define x (read-line))` | `(display x)`

``(format #t` format x)` | `(display x (current-error-port))`

``(format (current-error-port)` format x)`
ISLISP | `(setf x (read-line))` | ``(format (standard-output)` format x)` | ``(format (error-output)` format x)`
Pascal | `read(x);`

`readln(x);` | `write(x);`

`writeln(x);` | `write(stderr, x);`

`writeln(stderr, x);`
Visual Basic | `Input« prompt,» x` | `Print x`

`? x` | N/A
Visual Basic .NET | `x = Console.Read()`

`x = Console.ReadLine()` | `Console.Write(«format,»x)`

`Console.WriteLine(«format, »x)` | `Console.Error.Write(«format, »x)`

`Console.Error.WriteLine(«format, »x)`
Xojo | `x = StandardInputStream.Read()`

`x = StandardInputStreame.ReadLine()` | `StandardOutputStream.Write(x)`

`StandardOutputStream.WriteLine(x)` | `StdErr.Write(x)`

`StdErr.WriteLine(x)`
Python 2.x  | `x = raw_input(«prompt»)` | `print x`

`sys.stdout.write(x)` | ``print >> sys.stderr,` x`

`sys.stderr.write(x)`
Python 3.x  | `x = input(«prompt»)` | `print(x«, end=""»)` | `print(x«, end=""», file=sys.stderr)`
S-Lang  | `fgets (&x, stdin)` | `fputs (x, stdout)` | `fputs (x, stderr)`
Fortran | `READ(*,format) variable names `

`READ(INPUT_UNIT,format) variable names`[e] | `WRITE(*,format) expressions `

`WRITE(OUTPUT_UNIT,format) expressions`[e] | `WRITE(ERROR_UNIT,format) expressions`[e]
Forth | `buffer length ACCEPT ( # chars read )
KEY ( char )` | `buffer length TYPE
char EMIT` | N/A
PHP | `$x = fgets(STDIN);`

`$x = fscanf(STDIN, format);` | `print x;`

`echo x;`

`printf(format, x);` | `fprintf(STDERR, format, x);`
Perl | `$x = <>;`

`$x = <STDIN>;` | `print x;`

`printf format, x;` | `print STDERR x;`

`printf STDERR format, x;`
Raku | `$x = $*IN.get;` | `x.print`

`x.say` | `x.note`

`$*ERR.print(x)`

`$*ERR.say(x)`
Ruby | `x = gets` | `puts x`

`printf(format, x)` | `$stderr.puts(x)`

`$stderr.printf(format, x)`
Windows PowerShell  | `$x = Read-Host«« -Prompt» text»;`

`$x = [Console]::Read();`

`$x = [Console]::ReadLine()` | `x;`

`Write-Output x;`

`echo x` | `Write-Error x`
OCaml | `let x = read_int ()`

`let str = read_line ()`

`Scanf.scanf format (fun x ... -> ...)` | `print_int x`

`print_endline str`

`Printf.printf format x ...` | `prerr_int x`

`prerr_endline str`

`Printf.eprintf format x ...`
F# | `let x = System.Console.ReadLine()` | `printf format x ...`

`printfn format x ...` | `eprintf format x ...`

`eprintfn format x ...`
Standard ML | `val str = TextIO.inputLIne TextIO.stdIn` | `print str` | ``TextIO.output (TextIO.stdErr,` str)`
Haskell (GHC)  | `x <- readLn`

`str <- getLine` | `print x`

`putStrLn str` | `hPrint stderr x`

`hPutStrLn stderr str`
COBOL | `ACCEPT x` | `DISPLAY x` |

* ^a ALGOL 68 additionally as the "unformatted" transput routines: `read`, `write`, `get`, and `put`.
* ^b `gets(x)` and `fgets(x, length, stdin)` read unformatted text from stdin. Use of gets is not recommended.
* ^c `puts(x)` and `fputs(x, stdout)` write unformatted text to stdout.
* ^d `fputs(x, stderr)` writes unformatted text to stderr
* ^e INPUT_UNIT, OUTPUT_UNIT, ERROR_UNIT are defined in the ISO_FORTRAN_ENV module.[15]

## Reading command-line arguments

| Argument values  | Argument counts  | Program name / Script name

|
|
|

Ada[1] | `Argument (n)` | `Argument_Count` | `Command_Name`
C (C99)  | `argv[n]` | `argc` | first argument
Objective-C
C++
C# | `args[n]` | `args.Length` | `Assembly.GetEntryAssembly().Location;`
Java | `args.length` |
D | first argument
JavaScript
Windows Script Host implementation | `WScript.Arguments(n)` | `WScript.Arguments.length` | `WScript.ScriptName`

`WScript.ScriptFullName`
Go | `os.Args[n]` | `len(os.Args)` | first argument
Rust[a] | `std::env::args().nth(n)`
`std::env::args_os().nth(n)` | `std::env::args().count()`
`std::env::args_os().count()` | `std::env::args().next()`
`std::env::args_os().next()`
Swift | `Process.arguments[n]` or
`Process.unsafeArgv[n]` | `Process.arguments.count` or
`Process.argc` | first argument
Common Lisp | ?  | ?  | ?
Scheme (R6RS)  | `(list-ref (command-line) n)` | `(length (command-line))` | first argument
ISLISP | N/A  | N/A  | N/A
Pascal | `ParamStr(n)` | `ParamCount` | first argument
Visual Basic | `Command`[b] | N/A  | `App.Path`
Visual Basic .NET | `CmdArgs(n)` | `CmdArgs.Length` | `[Assembly].GetEntryAssembly().Location`
Xojo | `System.CommandLine` | (string parsing)  | `Application.ExecutableFile.Name`
Python | `sys.argv[n]` | `len(sys.argv)` | first argument
S-Lang  | `__argv[n]` | `__argc` | first argument
Fortran | `DO i = 1,argc
CALL GET_COMMAND_ARGUMENT (i,argv(i))
ENDDO` | `argc = COMMAND_ARGUMENT_COUNT ()` | `CALL GET_COMMAND_ARGUMENT (0,progname)`
PHP | `$argv[n]` | `$argc` | first argument
Bash shell  | `$n ($1, $2, $3, ...)`
`$@` (all arguments)  | `$#` | `$0`
Perl | `$ARGV[n]` | `scalar(@ARGV)` | `$0`
Raku | `@*ARGS[n]` | `@*ARGS.elems` | `$PROGRAM_NAME`
Ruby | `ARGV[n]` | `ARGV.size` | `$0`
Windows PowerShell  | `$args[n]` | `$args.Length` | `$MyInvocation.MyCommand.Name`
OCaml | `Sys.argv.(n)` | `Array.length Sys.argv` | first argument
F# | `args.[n]` | `args.Length` | `Assembly.GetEntryAssembly().Location`
Standard ML | `List.nth (CommandLine.arguments (), n)` | `length (CommandLine.arguments ())` | `CommandLine.name ()`
Haskell (GHC)  | `do { args <- System.getArgs; return length args !! n`}  | `do { args <- System.getArgs; return length args`}  | `System.getProgName`
COBOL | [c] | N/A

* ^a In Rust, `std::env::args` and `std::env::args_os` return iterators, `std::env::Args` and `std::env::ArgsOs` respectively. `Args` converts each argument to a `String` and it panics if it reaches an argument that cannot be converted to UTF-8. `ArgsOs` returns a non-lossy representation of the raw strings from the operating system (`std::ffi::OsString`), which can be invalid UTF-8.
* ^b In Visual Basic, command-line arguments are not separated. Separating them requires a split function `Split(string)`.
* ^c The COBOL standard includes no means to access command-line arguments, but common compiler extensions to access them include defining parameters for the main program or using `ACCEPT` statements.

## Execution of commands

| Shell command  | Execute program  | Replace current program with new executed program

|
|
|

Ada[1] | Not part of the language standard. Commonly done by compiler provided packages or by interfacing to C or POSIX.[16]
C | `system("command");` |  | `execl(path, args);`

`execv(path, arglist);`
C++ |
Objective-C | `[NSTask launchedTaskWithLaunchPath:(NSString *)path arguments:(NSArray *)arguments];` |
C# |  | `System.Diagnostics.Process.Start(path, argstring);` |
F# |  |
Go |  | `exec.Run(path, argv, envv, dir, exec.DevNull, exec.DevNull, exec.DevNull)` | `os.Exec(path, argv, envv)`
Visual Basic | `Interaction.Shell(command «, WindowStyle» «, isWaitOnReturn»)` |  |
Visual Basic .NET | `Microsoft.VisualBasic.Interaction.Shell(command «, WindowStyle» «, isWaitOnReturn»)` | `System.Diagnostics.Process.Start(path, argstring)` |
Xojo | `Shell.Execute(command «, Parameters»)` | `FolderItem.Launch(parameters, activate)` | N/A
D | `std.process.system("command");` |  | `std.process.execv(path, arglist);`
Java |  | `Runtime.exec(command);`

`new ProcessBuilder(command).start();` |
JavaScript
Windows Script Host implementation | ``WScript.CreateObject ("WScript.Shell").Run(`command «, WindowStyle» «, isWaitOnReturn»);` | `WshShell.Exec(command)` |
Common Lisp | `(uiop:run-program command)` |  |
Scheme | `(system command)` |  |
ISLISP | N/A  | N/A  | N/A
Pascal | `system(command);` |  |
OCaml | `Sys.command command, Unix.open_process_full command env (stdout, stdin, stderr),...` | `Unix.create_process prog args new_stdin new_stdout new_stderr, ...` | `Unix.execv prog args`

`Unix.execve prog args env`
Standard ML | `OS.Process.system command` | `Unix.execute (path, args)` | `Posix.Process.exec (path, args)`
Haskell (GHC)  | `System.system command` | `System.Process.runProcess path args ...` | `Posix.Process.executeFile path True args ...`
Perl | `system(command)`

`$output = `command``

`$output = qx(command)` |  | `exec(path, args)`
Ruby | `system(command)`

`output = `command`` |  | `exec(path, args)`
PHP | `system(command)`

`$output = `command``

`exec(command)`

`passthru(command)` |  |
Python | `os.system(command)`

`subprocess.Popen(command)` | `subprocess.call(["program", "arg1", "arg2", ...])` | `os.execv(path, args)`
S-Lang  | `system(command)` |  |
Fortran | `CALL EXECUTE_COMMAND_LINE (COMMAND «, WAIT» «, EXITSTAT» «, CMDSTAT» «, CMDMSG»)`[a] |  |
Windows PowerShell  | `[Diagnostics.Process]::Start(command)` | `«Invoke-Item »program arg1 arg2 ...` |
Bash shell  | `output=`command``

`output=$(command)` | `program arg1 arg2 ...` |

^a Fortran 2008 or newer.[17]

## References

1. ↑ 1.00 1.01 1.02 1.03 1.04 1.05 1.06 1.07 1.08 1.09 1.10 1.11 1.12 1.13 1.14 1.15 Ada Reference Manual – Language and Standard Libraries; ISO/IEC 8652:201x (E), "Reference Manual". http://www.ada-auth.org/standards/12rm/RM-Final.pdf.
2. ↑ "Common Lisp HyperSpec (TM)". lispworks.com. http://www.lispworks.com/documentation/HyperSpec/Front/index.htm.
3. ↑ "www.islisp.info: Specification". islisp.info. http://www.islisp.info/specification.html.
4. ↑ 4.0 4.1 "selected_int_kind in Fortran Wiki". fortranwiki.org. http://fortranwiki.org/fortran/show/selected_int_kind.
5. ↑ "Erlang — Types and Function Specifications". erlang.org. http://www.erlang.org/doc/reference_manual/typespec.html.
6. ↑ "Erlang — Advanced". erlang.org. http://www.erlang.org/doc/efficiency_guide/advanced.html.
7. ↑ 7.0 7.1 8.5 The Number Type
8. ↑ 8.0 8.1 "selected_real_kind in Fortran Wiki". fortranwiki.org. http://fortranwiki.org/fortran/show/selected_real_kind.
9. ↑ "The GNU C Library: Complex Numbers". gnu.org. https://www.gnu.org/software/libc/manual/html_node/Complex-Numbers.html#Complex-Numbers.
10. ↑ "Grammar vb". 2016-06-17. https://ljw1004.github.io/vbspec/vb.html.
11. ↑ "for...of". mozilla.org. https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Statements/for...of.
12. ↑ "Try-Catch for VB". google.com. https://sites.google.com/site/truetryforvisualbasic/.
13. ↑ Klabnik, Steve; Nichols, Carol. "Error Handling". The Rust Programming Language. https://doc.rust-lang.org/book/ch09-00-error-handling.html.
14. ↑ "Prime decomposition – Rosetta Code". rosettacode.org. http://rosettacode.org/wiki/Prime_decomposition#ALGOL_68.
15. ↑ "iso_fortran_env in Fortran Wiki". fortranwiki.org. http://fortranwiki.org/fortran/show/iso_fortran_env.
16. ↑ "Execute a system command – Rosetta Code". rosettacode.org. http://rosettacode.org/wiki/Execute_a_system_command#Ada.
17. ↑ "EXECUTE_COMMAND_LINE – The GNU Fortran Compiler". gnu.org. https://gcc.gnu.org/onlinedocs/gfortran/EXECUTE_005fCOMMAND_005fLINE.html.

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Comparison of programming languages (basic instructions). Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Comparison_of_programming_languages_(basic_instructions)&oldid=245825"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template