Comparison of programming languages (basic instructions): Difference between revisions

Revision as of 02:17, 9 June 2022

Latest revision as of 08:29, 13 August 2025

(36 intermediate revisions by 10 users not shown)

Line 1:

{{Short description|None}}

{{Refimprove|date=February 2009}}

{{ProgLangCompare}}

Line 7 ⟶ 8:

Generally, ''var'', {{var|var}}, or {{var serif|var}} is how variable names or other non-literal values to be interpreted by the reader are represented. The rest is literal code. [[Guillemet]]s ({{code|«}} and {{code|»}}) enclose optional sections. {{keypress|Tab}} indicates a necessary (whitespace) indentation.

Note that theThe tables are not sorted lexicographically ascending by programming- language name by default<!-- though this would be ideal -->, and that some programming languages have entries in some tables but not others.

{{Clear}}

== Type identifiers ==

=== [[Integer (computer science)|Integer]]s ===

{| class="wikitable sortable"

! rowspan=2|

Line 35 ⟶ 34:

|-

| [[Ada (programming language)|Ada]]<ref name="Ada_RM_2012">Ada Reference Manual – Language and Standard Libraries; ISO/IEC 8652:201x (E), {{cite web |url=http://www.ada-auth.org/standards/12rm/RM-Final.pdf |title=Reference Manual |access-date=2013-07-19 |url-status=dead |archive-url=https://web.archive.org/web/20110427190723/http://www.ada-auth.org/standards/12rm/RM-Final.pdf |archive-date=2011-04-27 }}</ref>

| {{code|range -2**7 .. 2**7 - 1|ada}}{{ref|Ada_range|[j]}}

| {{code|range 0 .. 2**8 - 1|ada}}{{ref|Ada_range|[j]}} or {{code|mod 2**8|ada}}{{ref|Ada_mod|[k]}}

| {{code|range -2**15 .. 2**15 - 1|ada}}{{ref|Ada_range|[j]}}

| {{code|range 0 .. 2**16 - 1|ada}}{{ref|Ada_range|[j]}} or {{code|mod 2**16|ada}}{{ref|Ada_mod|[k]}}

| {{code|range -2**31 .. 2**31 - 1|ada}}{{ref|Ada_range|[j]}}

| {{code|range 0 .. 2**32 - 1|ada}}{{ref|Ada_range|[j]}} or {{code|mod 2**32|ada}}{{ref|Ada_mod|[k]}}

| {{code|range -2**63 .. 2**63 - 1|ada}}{{ref|Ada_range|[j]}}

| {{code|mod 2**64|ada}}{{ref|Ada_mod|[k]}}

| {{<code|>Integer}}</code>{{ref|Ada_range|[j]}}

| <{{code>|range 0 .. 2**Integer'<wbr/>Size - 1</code>|ada}}{{ref|Ada_range|[j]}} or <{{code>|mod Integer'<wbr/>Size</code>|ada}}{{ref|Ada_mod|[k]}}

| {{n/a}}

|-

| rowspan=2| [[ALGOL 68]] (variable-width)

| rowspan=2| {{<code|>short short int}}</code>{{ref|CInt|[c]}}

| rowspan=2 {{n/a}}

| rowspan=2| {{<code|>short int}}</code>{{ref|CInt|[c]}}

| rowspan=2 {{n/a}}

| rowspan=2| {{<code|>int}}</code>{{ref|CInt|[c]}}

| rowspan=2 {{n/a}}

| rowspan=2| {{<code|>long int}}</code>{{ref|CInt|[c]}}

| rowspan=2 {{n/a}}

| {{<code|>int}}</code>{{ref|CInt|[c]}}

| {{n/a}}

| rowspan=2| {{<code|>long long int}}</code>{{ref|a68|[a]}}{{ref|a68g|[g]}}

|-

| colspan=2 align=center|{{<code|>bytes}}</code> and {{<code|>bits}}</code>

|-

| [[C (programming language)|C]] ([[C99]] fixed-width)

| rowspan=2| {{<code|>int8_t}}</code>

| rowspan=2| {{<code|>uint8_t}}</code>

| rowspan=2| {{<code|>int16_t}}</code>

| rowspan=2| {{<code|>uint16_t}}</code>

| rowspan=2| {{<code|>int32_t}}</code>

| rowspan=2| {{<code|>uint32_t}}</code>

| rowspan=2| {{<code|>int64_t}}</code>

| rowspan=2| {{<code|>uint64_t}}</code>

| rowspan=2| {{<code|>intptr_t}}</code>{{ref|CInt|[c]}}

| rowspan=2| {{<code|>size_t}}</code>{{ref|CInt|[c]}}

| rowspan=5 {{n/a}}

|-

Line 78 ⟶ 77:

|-

| [[C (programming language)|C]] ([[C99]] variable-width)

| rowspan=2| {{<code|>signed char}}</code>

| rowspan=2| {{<code|>unsigned char}}</code>

| rowspan=2| {{<code|>short}}</code>{{ref|CInt|[c]}}

| rowspan=2| {{<code|>unsigned short}}</code>{{ref|CInt|[c]}}

| rowspan=2| {{<code|>long}}</code>{{ref|CInt|[c]}}

| rowspan=2| {{<code|>unsigned long}}</code>{{ref|CInt|[c]}}

| rowspan=2| {{<code|>long long}}</code>{{ref|CInt|[c]}}

| rowspan=2| {{<code|>unsigned long long}}</code>{{ref|CInt|[c]}}

| rowspan=2| {{<code|>int}}</code>{{ref|CInt|[c]}}

| rowspan=2| {{<code|>unsigned int}}</code>{{ref|CInt|[c]}}

|-

| [[C++]] ([[C++11]] variable-width)

|-

| [[Objective-C]] ([[Cocoa (API)|Cocoa]])

| {{<code|>signed char}}</code> or {{<code|>int8_t}}</code>

| {{<code|>unsigned char}}</code> or {{<code|>uint8_t}}</code>

| {{<code|>short}}</code> or {{<code|>int16_t}}</code>

| {{<code|>unsigned short}}</code> or {{<code|>uint16_t}}</code>

| {{<code|>int}}</code> or {{<code|>int32_t}}</code>

| {{<code|>unsigned int}}</code> or {{<code|>uint32_t}}</code>

| {{<code|>long long}}</code> or {{<code|>int64_t}}</code>

| {{<code|>unsigned long long}}</code> or {{<code|>uint64_t}}</code>

| {{<code|>NSInteger}}</code> or {{<code|>long}}</code>

| {{<code|>NSUInteger}}</code> or {{<code|>unsigned long}}</code>

|-

| [[C Sharp (programming language)|C#]]

| {{<code|>sbyte}}</code>

| {{<code|>byte}}</code>

| rowspan=2| {{<code|>short}}</code>

| {{<code|>ushort}}</code>

| rowspan=2| {{<code|>int}}</code>

| {{<code|>uint}}</code>

| rowspan=2| {{<code|>long}}</code>

| {{<code|>ulong}}</code>

| {{<code|>IntPtr}}</code>

| {{<code|>UIntPtr}}</code>

| <code>System.Numerics.<wbr/>BigInteger</code><br />(.NET 4.0)

|-

| [[Java (programming language)|Java]]

| {{<code|>byte}}</code>

| {{n/a}}

| {{<code|>char}}</code>{{ref|Java char|[b]}}

| {{n/a}}

| {{n/a}}

Line 127 ⟶ 126:

|-

| [[Go (programming language)|Go]]

| {{<code|>int8}}</code>

| {{<code|>uint8}}</code> or {{<code|>byte}}</code>

| {{<code|>int16}}</code>

| {{<code|>uint16}}</code>

| {{<code|>int32}}</code>

| {{<code|>uint32}}</code>

| {{<code|>int64}}</code>

| {{<code|>uint64}}</code>

| {{<code|>int}}</code>

| {{<code|>uint}}</code>

| {{<code|>big.Int}}</code>

|-

| [[Rust (programming language)|Rust]]

| {{<code|>i8}}</code>

| {{<code|>u8}}</code>

| {{<code|>i16}}</code>

| {{<code|>u16}}</code>

| {{<code|>i32}}</code>

| {{<code|>u32}}</code>

| {{<code|>i64}}</code>

| {{<code|>u64}}</code>

| {{<code|>isize}}</code>

| {{<code|>usize}}</code>

| {{n/a}}

|-

| [[Swift (programming language)|Swift]]

| {{<code|>Int8}}</code>

| {{<code|>UInt8}}</code>

| {{<code|>Int16}}</code>

| {{<code|>UInt16}}</code>

| {{<code|>Int32}}</code>

| {{<code|>UInt32}}</code>

| {{<code|>Int64}}</code>

| {{<code|>UInt64}}</code>

| {{<code|>Int}}</code>

| {{<code|>UInt}}</code>

|-

| [[D (programming language)|D]]

| {{<code|>byte}}</code>

| {{<code|>ubyte}}</code>

| {{<code|>short}}</code>

| {{<code|>ushort}}</code>

| {{<code|>int}}</code>

| {{<code|>uint}}</code>

| {{<code|>long}}</code>

| {{<code|>ulong}}</code>

| {{n/a}}

| {{n/a}}

| {{<code|>BigInt}}</code>

|-

| [[Common Lisp]]<ref name="HyperSpec">{{cite web|url=http://www.lispworks.com/documentation/HyperSpec/Front/index.htm|title=Common Lisp HyperSpec (TM)|work=lispworks.com|access-date=30 January 2017}}</ref>

| {{<code|>(signed-byte 8)}}</code>

| {{<code|>(unsigned-byte 8)}}</code>

| {{<code|>(signed-byte 16)}}</code>

| {{<code|>(unsigned-byte 16)}}</code>

| {{<code|>(signed-byte 32)}}</code>

| {{<code|>(unsigned-byte 32)}}</code>

| {{<code|>(signed-byte 64)}}</code>

| {{<code|>(unsigned-byte 64)}}</code>

|

|

| {{<code|>bignum}}</code>

|-

| [[Scheme (programming language)|Scheme]]

Line 214 ⟶ 213:

|

|

| {{<code|>bignum}}</code>

|-

| [[Pascal (programming language)|Pascal]] ([[Free Pascal|FPC]])

| {{<code|>shortint}}</code>

| {{<code|>byte}}</code>

| {{<code|>smallint}}</code>

| {{<code|>word}}</code>

| {{<code|>longint}}</code>

| {{<code|>longword}}</code>

| {{<code|>int64}}</code>

| {{<code|>qword}}</code>

| {{<code|>integer}}</code>

| {{<code|>cardinal}}</code>

| {{n/a}}

|-

| [[Visual Basic (classic)|Visual Basic]]

| {{n/a}}

| rowspan=2|{{<code|>Byte}}</code>

| {{<code|>Integer}}</code>

| {{n/a}}

| {{<code|>Long}}</code>

| {{n/a}}

| colspan=2 {{n/a}}

Line 241 ⟶ 240:

|-

| [[Visual Basic .NET]]

| {{<code|>SByte}}</code>

| {{<code|>Short}}</code>

| {{<code|>UShort}}</code>

| {{<code|>Integer}}</code>

| {{<code|>UInteger}}</code>

| {{<code|>Long}}</code>

| {{<code|>ULong}}</code>

| <code>System.Numerics<wbr/>.BigInteger</code><br />(.NET 4.0)

|-

| [[FreeBasic]]

| {{<code|>Byte}}</code> or {{<code|><nowiki>Integer<8>}}</nowiki></code>

| {{<code|>UByte}}</code> or {{<code|><nowiki>UInteger<8>}}</nowiki></code>

| {{<code|>Short}}</code> or {{<code|><nowiki>Integer<16>}}</nowiki></code>

| {{<code|>UShort}}</code> or {{<code|><nowiki>UInteger<16>}}</nowiki></code>

| {{<code|>Long}}</code> or {{<code|><nowiki>Integer<32>}}</nowiki></code>

| {{<code|>ULong}}</code> or {{<code|><nowiki>UInteger<32>}}</nowiki></code>

| {{<code|>LongInt}}</code> or {{<code|><nowiki>Integer<64>}}</nowiki></code>

| {{<code|>ULongInt}}</code> or {{<code|><nowiki>UInteger<64>}}</nowiki></code>

| {{<code|>Integer}}</code>

| {{<code|>UInteger}}</code>

| {{n/a}}

|-

Line 268 ⟶ 267:

| colspan=2 {{n/a}}

| colspan=2 {{n/a}}

| {{<code|>int}}</code>

| {{n/a}}

| {{<code|>long}}</code>

|-

| [[Python (programming language)|Python]] 3.x

Line 278 ⟶ 277:

| colspan=2 {{n/a}}

| colspan=2 {{n/a}}

| {{<code|>int}}</code>

|-

| [[S-Lang (programming language)|S-Lang]]

| colspan=2 {{n/a}}

| colspan=2 {{n/a}}

Line 289 ⟶ 288:

|-

| [[Fortran]]

| <{{code>|INTEGER<wbr/>(KIND {{=}} n)</code>|fortran}}{{ref|Kinds|[f]}}

| {{n/a}}

| <{{code>|INTEGER<wbr/>(KIND {{=}} n)</code>|fortran}}{{ref|Kinds|[f]}}

| {{n/a}}

| <{{code>|INTEGER<wbr/>(KIND {{=}} n)</code>|fortran}}{{ref|Kinds|[f]}}

| {{n/a}}

| <{{code>|INTEGER<wbr/>(KIND {{=}} n)</code>|fortran}}{{ref|Kinds|[f]}}

| {{n/a}}

|

Line 304 ⟶ 303:

| colspan=2 {{n/a}}

| colspan=2 {{n/a}}

| {{<code|>int}}</code>{{ref|PHP 32/64 bit long|[m]}}

| {{n/a}}

| {{<code|>int}}</code>{{ref|PHP 32/64 bit long|[m]}}

| {{n/a}}

| colspan=2 {{n/a}}

Line 317 ⟶ 316:

| colspan=2 {{n/a}}{{ref|scalars|[d]}}

| colspan=2 {{n/a}}{{ref|scalars|[d]}}

| {{<code|>Math::BigInt}}</code>

|-

| [[Raku (programming language)|Raku]]

| {{<code|>int8}}</code>

| {{<code|>uint8}}</code>

| {{<code|>int16}}</code>

| {{<code|>uint16}}</code>

| {{<code|>int32}}</code>

| {{<code|>uint32}}</code>

| {{<code|>int64}}</code>

| {{<code|>uint64}}</code>

| {{<code|>Int}}</code>

| colspan=2 {{n/a}}

|-

Line 336 ⟶ 335:

| colspan=2 {{n/a}}

| colspan=2 {{n/a}}

| {{<code|>Fixnum}}</code>

| {{n/a}}

| {{<code|>Bignum}}</code>

|-

| [[Erlang (programming language)|Erlang]]{{ref|Erlang_int|[n]}}

Line 345 ⟶ 344:

| colspan=2 {{n/a}}

| colspan=2 {{n/a}}

| {{<code|>integer()}}</code>

| {{n/a}}

| {{<code|>integer()}}</code>{{ref|Erlang_arb|[o]}}

|-

| [[Scala (programming language)|Scala]]

| {{<code|>Byte}}</code>

| {{n/a}}

| {{<code|>Short}}</code>

| {{<code|>Char}}</code>{{ref|Scala Char|[l]}}

| {{<code|>Int}}</code>

| {{n/a}}

| {{<code|>Long}}</code>

| {{n/a}}

| {{n/a}}

| {{n/a}}

| {{<code|>scala.math.BigInt}}</code>

|-

| [[Seed7]]

Line 369 ⟶ 368:

| {{n/a}}

| {{n/a}}

| {{<code|>integer}}</code>

| {{n/a}}

| {{n/a}}

| {{n/a}}

| {{<code|>bigInteger}}</code>

|-

| [[Smalltalk]]

Line 380 ⟶ 379:

| colspan=2 {{n/a}}

| colspan=2 {{n/a}}

| {{<code|>SmallInteger}}</code>{{ref|Smalltalk|[i]}}

| {{n/a}}

| {{<code|>LargeInteger}}</code>{{ref|Smalltalk|[i]}}

|-

| [[Windows PowerShell]]

Line 395 ⟶ 394:

| colspan=2 {{n/a}}

| colspan=2 {{n/a}}

| {{<code|>int32}}</code>

| {{n/a}}

| rowspan=2| {{<code|>int64}}</code>

| {{n/a}}

| {{<code|>int}}</code> or {{<code|>nativeint}}</code>

|

| {{<code|>open Big_int;;}}</code> or {{<code|>big_int}}</code>

|-

| [[F Sharp (programming language)|F#]]

| {{<code|>sbyte}}</code>

| {{<code|>byte}}</code>

| {{<code|>int16}}</code>

| {{<code|>uint16}}</code>

| {{<code|>int32}}</code> or {{<code|>int}}</code>

| {{<code|>uint32}}</code>

| {{<code|>uint64}}</code>

| {{<code|>nativeint}}</code>

| {{<code|>unativeint}}</code>

| {{<code|>bigint}}</code>

|-

| [[Standard ML]]

| {{n/a}}

| {{<code|>Word8.word}}</code>

| colspan=2 {{n/a}}

| {{<code|>Int32.int}}</code>

| {{<code|>Word32.word}}</code>

| {{<code|>Int64.int}}</code>

| {{<code|>Word64.word}}</code>

| {{<code|>int}}</code>

| {{<code|>word}}</code>

| {{<code|>LargeInt.int}}</code> or<br />{{<code|>IntInf.int}}</code>

|-

| [[Haskell (programming language)|Haskell]] ([[Glasgow Haskell Compiler|GHC]])

| {{<code|>«import Int»}}</code> or {{<code|>Int8}}</code>

| {{<code|>«import Word»}}</code> or {{<code|>Word8}}</code>

| {{<code|>«import Int»}}</code> or {{<code|>Int16}}</code>

| {{<code|>«import Word»}}</code> or {{<code|>Word16}}</code>

| {{<code|>«import Int»}}</code> or {{<code|>Int32}}</code>

| {{<code|>«import Word»}}</code> or {{<code|>Word32}}</code>

| {{<code|>«import Int»}}</code> or {{<code|>Int64}}</code>

| {{<code|>«import Word»}}</code> or {{<code|>Word64}}</code>

| {{<code|>Int}}</code>

| {{<code|>«import Word»}}</code> or {{<code|>Word}}</code>

| {{<code|>Integer}}</code>

|-

| [[Eiffel (programming language)|Eiffel]]

| {{<code|>INTEGER_8}}</code>

| {{<code|>NATURAL_8}}</code>

| {{<code|>INTEGER_16}}</code>

| {{<code|>NATURAL_16}}</code>

| {{<code|>INTEGER_32}}</code>

| {{<code|>NATURAL_32}}</code>

| {{<code|>INTEGER_64}}</code>

| {{<code|>NATURAL_64}}</code>

| {{<code|>INTEGER}}</code>

| {{<code|>NATURAL}}</code>

| {{n/a}}

|-

| [[COBOL]]{{ref|Cobol|[h]}}

| {{<code|>BINARY-CHAR «SIGNED»}}</code>

| {{<code|>BINARY-CHAR UNSIGNED}}</code>

| {{<code|>BINARY-SHORT «SIGNED»}}</code>

| {{<code|>BINARY-SHORT UNSIGNED}}</code>

| {{<code|>BINARY-LONG «SIGNED»}}</code>

| {{<code|>BINARY-LONG UNSIGNED}}</code>

| {{<code|>BINARY-DOUBLE «SIGNED»}}</code>

| {{<code|>BINARY-DOUBLE UNSIGNED}}</code>

| {{n/a}}

| {{n/a}}

Line 472 ⟶ 471:

| colspan=2 {{n/a}}

| colspan=2 {{n/a}}

| {{<code|>Integer}}</code>

|-

| [[Wolfram Language]]

Line 480 ⟶ 479:

| colspan=2 {{n/a}}

| colspan=2 {{n/a}}

| {{<code|>Integer}}</code>

|}

* {{note|a68|a}} The ''standard'' constants {{<code|>int shorts}}</code> and {{<code|>int lengths}}</code> can be used to determine how many {{<code|>short}}</code>s and {{<code|>long}}</code>s can be usefully prefixed to {{<code|>short int}}</code> and {{<code|>long int}}</code>. The actual sizes of {{<code|>short int}}</code>, {{<code|>int}}</code>, and {{<code|>long int}}</code> are available as the constants {{<code|>short max int}}</code>, {{<code|>max int}}</code>, and {{<code|>long max int}}</code> etc.

* {{note|Java char|b}} Commonly used for characters.

* {{note|CInt|c}} The ALGOL 68, C and C++ languages do not specify the exact width of the integer types {{<code|>short}}</code>, {{<code|>int}}</code>, {{<code|>long}}</code>, and ([[C99]], [[C++11]]) {{<code|>long long}}</code>, so they are implementation-dependent. In C and C++ {{<code|>short}}</code>, {{<code|>long}}</code>, and {{<code|>long long}}</code> types are required to be at least 16, 32, and 64 bits wide, respectively, but can be more. The {{<code|>int}}</code> type is required to be at least as wide as {{<code|>short}}</code> and at most as wide as {{<code|>long}}</code>, 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]]{{citation needed|date=December 2011}} also define the {{<code|>[u]intN_t}}</code> exact-width types in the [[stdint.h]] header. See [[C syntax#Integral types]] for more information. In addition the types {{<code|>size_t}}</code> and {{<code|>ptrdiff_t}}</code> 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.

* {{note|scalars|d}} Perl 5 does not have distinct types. Integers, floating point numbers, strings, etc. are all considered "scalars".

* {{note|PHP bignum|e}} PHP has two arbitrary-precision libraries. The BCMath library just uses strings as datatype. The GMP library uses an internal "resource" type.

* {{note|Kinds|f}} The value of {{<code|>n}}</code> is provided by the {{<code|>SELECTED_INT_KIND}}</code><ref name="fortranwiki.org">{{cite web|url=http://fortranwiki.org/fortran/show/selected_int_kind|title=selected_int_kind in Fortran Wiki|work=fortranwiki.org|access-date=30 January 2017}}</ref> intrinsic function.

* {{note|a68g|g}} [[ALGOL 68]]G's runtime option {{<code|>--precision "number"}}</code> can set precision for {{<code|>long long int}}</code>s to the required "number" significant digits. The ''standard'' constants {{<code|>long long int width}}</code> and {{<code|>long long max int}}</code> can be used to determine actual precision.

* {{note|Cobol|h}} [[COBOL]] allows the specification of a required precision and will automatically select an available type capable of representing the specified precision. "{{<code|>PIC S9999}}</code>", 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.

* {{note|Smalltalk|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 ({{mono|SmallInteger}}) and one supporting arbitrary sized integers ({{mono|LargeInteger}}). Arithmetic operations support polymorphic arguments and return the result in the most appropriate compact representation.

* {{note|Ada_range|j}} [[Ada (programming language)|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 (<{{code>|range 1 .. Integer'Last</code>|ada}}) and Natural (<{{code>|range 0 .. Integer'Last</code>|ada}}). {{<code|>Short_Short_Integer}}</code> (8 bits), {{<code|>Short_Integer}}</code> (16 bits) and {{<code|>Long_Integer}}</code> (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.

* {{note|Ada_modAda mod|k}} [[Ada (programming language)|Ada]] modulo types implement modulo arithmetic in all operations, i.e. no range violations are possible. Modulos are not restricted to powers of two.

* {{note|Scala char|l}} Commonly used for characters like Java's char.

* {{note|PHP 32/64 bit long|m}} {{<code|>int}}</code> in PHP has the same width as {{<code|>long}}</code> type in C has on that system.{{ref|CInt|[c]}}

* {{note|Erlang_intErlang int|n}} [[Erlang (programming language)|Erlang]] is dynamically typed. The type identifiers are usually used to specify types of record fields and the argument and return types of functions.<ref>{{cite web|url=http://www.erlang.org/doc/reference_manual/typespec.html|title=Erlang {{--}} Types and Function Specifications|work=erlang.org|access-date=30 January 2017}}</ref>

* {{note|Erlang_arbErlang arb|o}} When it exceeds one word.<ref>{{cite web|url=http://www.erlang.org/doc/efficiency_guide/advanced.html|title=Erlang {{--}} Advanced|work=erlang.org|access-date=30 January 2017}}</ref>

=== [[Floating point]] ===

{| class="wikitable sortable"

!

Line 509 ⟶ 507:

|-

| [[Ada (programming language)|Ada]]<ref name="Ada_RM_2012" />

| {{<code|>Float}}</code>

| {{<code|>Long_Float}}</code>

| {{n/a}}

|-

| [[ALGOL 68]]

| {{<code|>real}}</code>{{ref|a68|[a]}}

| {{<code|>long real}}</code>{{ref|a68|[a]}}

| {{<code|>short real}}</code>, {{<code|>long long real}}</code>, etc.{{ref|a68g|[d]}}

|-

| [[C (programming language)|C]]

| rowspan=3| {{<code|>float}}</code>{{ref|lax floats|[b]}}

| rowspan=5| {{<code|>double}}</code>

| rowspan=3| {{<code|>long double}}</code>{{ref|C-long-double|[f]}}

|-

| [[C++]] (STL)

|-

| [[Objective-C]] ([[Cocoa (API)|Cocoa]])

| {{<code|>CGFloat}}</code>

|-

| [[C Sharp (programming language)|C#]]

| rowspan=2| {{<code|>float}}</code>

| rowspan=43 {{n/a}}

|-

| [[Java (programming language)|Java]]

|-

| [[Go (programming language)|Go]]

| {{<code|>float32}}</code>

| {{<code|>float64}}</code>

|-

| [[Rust (programming language)|Rust]]

| {{<code|>f32}}</code>

| {{<code|>f64}}</code>

| <code>f16, f128</code>

|-

| [[Swift (programming language)|Swift]]

| {{<code|>Float}}</code> or {{<code|>Float32}}</code>

| {{<code|>Double}}</code> or {{<code|>Float64}}</code>

| {{<code|>Float80}}</code>{{ref|Swift-long-double|[g]}}

| {{<code|>CGFloat}}</code>

|-

| [[D (programming language)|D]]

| {{<code|>float}}</code>

| {{<code|>double}}</code>

|

| {{<code|>real}}</code>

|-

| [[Common Lisp]]

| {{<code|>single-float}}</code>

| {{<code|>double-float}}</code>

| {{<code|>float, short-float, long-float}}</code>

|-

| [[Scheme (programming language)|Scheme]]

Line 570 ⟶ 569:

|-

| [[Pascal (programming language)|Pascal]] ([[Free Pascal|FPC]])

| {{<code|>single}}</code>

| {{<code|>double}}</code>

|

| {{<code|>real}}</code>

|-

| [[Visual Basic (classic)|Visual Basic]]

| rowspan=3| {{<code|>Single}}</code>

| rowspan=3| {{<code|>Double}}</code>

| rowspan=3 {{n/a}}

|-

Line 586 ⟶ 585:

| [[Python (programming language)|Python]]

| rowspan=2 {{n/a}}

| {{<code|>float}}</code>

|

|-

| [[JavaScript]]

| {{<code|>Number}}</code><ref name="Javascript numbers">[https://www.mozilla.org/js/language/E262-3.pdf 8.5 The Number Type]</ref>

| {{n/a}}

|-

| [[S-Lang (programming language)|S-Lang]]

| <!-- ''x'' = ''value f''; -->

| <!-- ''x'' = ''value''; -->

Line 604 ⟶ 603:

| [[PHP]]

|

| {{<code|>float}}</code>

|

|-

Line 613 ⟶ 612:

|-

| [[Raku (programming language)|Raku]]

| {{<code|>num32}}</code>

| {{<code|>num64}}</code>

|

| {{<code|>Num}}</code>

|-

| [[Ruby (programming language)|Ruby]]

| {{n/a}}

| {{<code|>Float}}</code>

| rowspan=4 {{n/a}}

|-

| [[Scala (programming language)|Scala]]

| {{<code|>Float}}</code>

| {{<code|>Double}}</code>

|-

| [[Seed7]]

| {{n/a}}

| {{<code|>float}}</code>

|-

| [[Smalltalk]]

| {{<code|>Float}}</code>

| {{<code|>Double}}</code>

|-

| [[Windows PowerShell]]

Line 642 ⟶ 641:

| [[OCaml]]

| {{n/a}}

| rowspan=2| {{<code|>float}}</code>

| rowspan=3 {{n/a}}

|-

| [[F Sharp (programming language)|F#]]

| {{<code|>float32}}</code>

|-

| [[Standard ML]]

| {{n/a}}

|

| {{<code|>real}}</code>

|-

| [[Haskell (programming language)|Haskell]] ([[Glasgow Haskell Compiler|GHC]])

| {{<code|>Float}}</code>

| {{<code|>Double}}</code>

|

|-

| [[Eiffel (programming language)|Eiffel]]

| {{<code|>REAL_32}}</code>

| {{<code|>REAL_64}}</code>

|

|-

| [[COBOL]]

| {{<code|>FLOAT-BINARY-7}}</code>{{ref|Cobol_ieee|[e]}}

| {{<code|>FLOAT-BINARY-34}}</code>{{ref|Cobol_ieee|[e]}}

| {{<code|>FLOAT-SHORT}}</code>, {{<code|>FLOAT-LONG}}</code>, {{<code|>FLOAT-EXTENDED}}</code>

|-

| [[Mathematica]]

Line 672 ⟶ 671:

| {{n/a}}

|

| {{<code|>Real}}</code>

|}

* {{note|a68_real|a}} The ''standard'' constants {{<code|>real shorts}}</code> and {{<code|>real lengths}}</code> can be used to determine how many {{<code|>short}}</code>s and {{<code|>long}}</code>s can be usefully prefixed to {{<code|>short real}}</code> and {{<code|>long real}}</code>. The actual sizes of {{<code|>short real}}</code>, {{<code|>real}}</code>, and {{<code|>long real}}</code> are available as the constants {{<code|>short max real}}</code>, {{<code|>max real}}</code> and {{<code|>long max real}}</code> etc. With the constants {{<code|>short small real}}</code>, {{<code|>small real}}</code> and {{<code|>long small real}}</code> available for each type's [[machine epsilon]].

* {{note|lax floats|b}} declarations of single precision often are not honored

* {{note|real kinds|c}} The value of {{<code|>n}}</code> is provided by the {{<code|>SELECTED_REAL_KIND}}</code><ref name="ReferenceA">{{cite web|url=http://fortranwiki.org/fortran/show/selected_real_kind|title=selected_real_kind in Fortran Wiki|work=fortranwiki.org|access-date=30 January 2017}}</ref> intrinsic function.

* {{note|a68g-real|d}} [[ALGOL 68]]G's runtime option {{<code|>--precision "number"}}</code> can set precision for {{<code|>long long real}}</code>s to the required "number" significant digits. The ''standard'' constants {{<code|>long long real width}}</code> and {{<code|>long long max real}}</code> can be used to determine actual precision.

* {{note|Cobol-ieee|e}} These [[IEEE]] floating-point types will be introduced in the next COBOL standard.

* {{note|C-long-double|f}} Same size as {{<code|>double}}</code> on many implementations.

* {{note|Swift-long-double|g}} Swift supports 80-bit [[Extended precision#Language support|extended precision]] floating point type, equivalent to {{<code|>long double}}</code> in C languages.

=== [[Complex number]]s ===

{| class="wikitable sortable"

!

Line 694 ⟶ 692:

| [[Ada (programming language)|Ada]]<ref name="Ada_RM_2012" />

| {{n/a}}

| {{<code|>Complex}}</code>{{ref|generic type|[b]}}

| {{<code|>Complex}}</code>{{ref|generic type|[b]}}

| {{<code|>Complex}}</code>{{ref|generic type|[b]}}

|-

| [[ALGOL 68]]

| {{n/a}}

| {{<code|>compl}}</code>

| {{<code|>long compl}}</code> etc.

| {{<code|>short compl}}</code> etc. and {{<code|>long long compl}}</code> etc.

|-

| [[C (programming language)|C]] ([[C99]])<ref>{{cite web|url=https://www.gnu.org/software/libc/manual/html_node/Complex-Numbers.html#Complex-Numbers|title=The GNU C Library: Complex Numbers|work=gnu.org|access-date=30 January 2017}}</ref>

| {{n/a}}

| {{<code|>float complex}}</code>

| {{<code|>double complex}}</code>

| rowspan=7 {{n/a}}

|-

| [[C++]] (STL)

| {{n/a}}<!-- No std::complex<int>. See C++ standard section 26.2 paragraph 2 -->

| {{<code|><nowiki>std::complex<float>}}</nowiki></code>

| {{<code|><nowiki>std::complex<double>}}</nowiki></code>

|-

| [[C Sharp (programming language)|C#]]

| {{n/a}}

| {{n/a}}

| {{<code|>System.Numerics.Complex}}</code><br />(.NET 4.0)

|-

| [[Java (programming language)|Java]]

Line 727 ⟶ 725:

| [[Go (programming language)|Go]]

| {{n/a}}

| {{<code|>complex64}}</code>

| {{<code|>complex128}}</code>

|-

| [[D (programming language)|D]]

| {{n/a}}

| {{<code|>cfloat}}</code>

| {{<code|>cdouble}}</code>

|-

| [[Objective-C]]

Line 765 ⟶ 763:

| {{n/a}}

| {{n/a}}

| {{<code|>System.Numerics.Complex}}</code><br />(.NET 4.0)

|-

| [[Perl]]

|

|

| {{<code|>Math::Complex}}</code>

|

|-

| [[Raku (programming language)|Raku]]

|

| {{<code|>complex64}}</code>

| {{<code|>complex128}}</code>

| {{<code|>Complex}}</code>

|-

| [[Python (programming language)|Python]]

|

|

| {{<code|>complex}}</code>

| rowspan=15 {{n/a}}

|-

| [[JavascriptJavaScript]]

| {{n/a}}

| {{n/a}}

|

|-

| [[S-Lang (programming language)|S-Lang]]

| {{n/a}}

| {{n/a}}

Line 800 ⟶ 798:

|-

| [[Ruby (programming language)|Ruby]]

| {{<code|>Complex}}</code>

| {{n/a}}

| {{<code|>Complex}}</code>

|-

| [[Scala (programming language)|Scala]]

Line 812 ⟶ 810:

| {{n/a}}

| {{n/a}}

| {{<code|>complex}}</code>

|-

| [[Smalltalk]]

| {{<code|>Complex}}</code>

| {{<code|>Complex}}</code>

| {{<code|>Complex}}</code>

|-

| [[Windows PowerShell]]

Line 827 ⟶ 825:

| {{n/a}}

| {{n/a}}

| {{<code|>Complex.t}}</code>

|-

| [[F Sharp (programming language)|F#]]

|

|

| {{<code|>System.Numerics.Complex}}</code><br />(.NET 4.0)

|-

| [[Standard ML]]

Line 839 ⟶ 837:

| {{n/a}}

|-

| [[Haskell (programming language)|Haskell]] ([[Glasgow Haskell Compiler|GHC]])

| {{n/a}}

| {{<code|>Complex{{Not a typo|.}}Complex Float}}</code>

| {{<code|>Complex{{Not a typo|.}}Complex Double}}</code>

|-

| [[Eiffel (programming language)|Eiffel]]

Line 855 ⟶ 853:

|-

| [[Mathematica]]

| {{<code|>Complex}}</code>

| {{n/a}}

| {{n/a}}

| {{<code|>Complex}}</code>

|}

* {{note|complex kinds|a}} The value of {{<code|>n}}</code> is provided by the {{<code|>SELECTED_REAL_KIND}}</code><ref name="ReferenceA" /> intrinsic function.

* {{note|generic type|b}} Generic type which can be instantiated with any base floating point type.

=== Other variable types ===

{| class="wikitable sortable"

! rowspan=2|

! colspan=2| Text

! rowspan=2| [[Boolean datatypedata type|Boolean]]

! rowspan=2| [[Enumerated type|Enumeration]]

! rowspan=2| [[Object (computer science)|Object]]/[[Top type|Universal]]

Line 877 ⟶ 874:

|-

| [[Ada (programming language)|Ada]]<ref name="Ada_RM_2012" />

| {{<code|>Character}}</code>

| {{<code|>String}}</code>, {{<code|>Bounded_String}}</code>, {{<code|>Unbounded_String}}</code>

| {{<code|>Boolean}}</code>

| <code>(''item₁'', ''item₂'', ''...'')</code>

| {{<code|>tagged null record}}</code>

|-

| [[ALGOL 68]]

| {{<code|>char}}</code>

| {{<code|>string}}</code>, {{<code|>bytes}}</code>

| {{<code|>bool}}</code>, {{<code|>bits}}</code>

| {{nN/aA|N/A}} - [http://rosettacode.org/wiki/Enumerations#ALGOL_68 User defined]

| {{nN/aA|N/A}}

|-

| [[C (programming language)|C]] ([[C99]])

| rowspan=2| {{<code|>char}}</code>, {{<code|>wchar_t}}</code>

| {{nN/aA|N/A}}

| rowspan=2| {{<code|>bool}}</code>{{ref|int bool|[b]}}

| rowspan=3| <code>enum ''«name»'' { ''item₁'', ''item₂'', ''...'' };</code>

| rowspan=2| <code>[[void type|void]] [[pointer (computer programming)|*]]</code>

|-

| [[C++]] (STL)

| [[C++ string handling|{{<code|>«std::»string}}</code>]]

|-

| [[Objective-C]]

| {{<code|>unichar}}</code>

| {{<code|>NSString *}}</code>

| {{<code|>BOOL}}</code>

| {{<code|>id}}</code>

|-

| [[C Sharp (programming language)|C#]]

| rowspan=2| {{<code|>char}}</code>

| {{<code|>string}}</code>

| {{<code|>bool}}</code>

| <code>enum ''name'' { ''item₁''« = ''value''», ''item₂''« = ''value''», ''...'' }</code>

| object

|-

| [[Java (programming language)|Java]]

| {{<code|>String}}</code>

| {{<code|>boolean}}</code>

| <code>enum ''name'' { ''item₁'', ''item₂'', ''...'' }</code>

| {{<code|>Object}}</code>

|-

| [[Go (programming language)|Go]]

| {{<code|>byte}}</code>, {{<code|>rune}}</code>

| {{<code|>string}}</code>

| {{<code|>bool}}</code>

| <code>const (<br />{{Spaces|3}}''item{{sub|1}}'' = ''iota''<br />{{Spaces|3}}''item{{sub|2}}''<br />{{Spaces|3}}''...''<br />)</code>

| <code>interface{}</code>

|-

| [[Rust (programming language)|Rust]]

| {{<code|>char}}</code>

| {{<code|>String}}</code>

| {{<code|>bool}}</code>

| <code>enum ''name'' { ''item{{sub|1}}''« = ''value''», ''item{{sub|2}}''« = ''value''», ''...'' }</code>

| {{<code|>std::any::Any}}</code>

|-

| [[Swift (programming language)|Swift]]

| {{<code|>Character}}</code>

| {{<code|>String}}</code>

| {{<code|>Bool}}</code>

| <code>enum ''name'' { case ''item₁'', ''item₂'', ''...'' }</code>

| {{<code|>Any}}</code>

|-

| [[D (programming language)|D]]

| {{<code|>char}}</code>

| {{<code|>string}}</code>

| {{<code|>bool}}</code>

| <code>enum ''name'' { ''item₁'', ''item₂'', ''...'' }</code>

| {{<code|>std.variant.Variant}}</code>

|-

| [[Common Lisp]]

| {{<code|>character}}</code>

| {{<code|>string}}</code>

| {{<code|>boolean}}</code>

| <code>(member ''item₁'' ''item₂'' ''...'')</code>

| {{<code|>t}}</code>

|-

| [[Scheme (programming language)|Scheme]]

Line 969 ⟶ 966:

|-

| Pascal (ISO)

| rowspan=2| {{<code|>char}}</code>

| {{nN/aA|N/A}}

| rowspan=2| {{<code|>boolean}}</code>

| rowspan=2| <code>( ''item₁'', ''item₂'', ''...'' )</code>

| {{nN/aA|N/A}}

|-

| [[Object Pascal]] ([[Delphi (software)|Delphi]])

| {{<code|>string}}</code>

| {{<code|>variant}}</code>

|-

| [[Visual Basic (classic)|Visual Basic]]

| {{nN/aA|N/A}}

| rowspan=3| {{<code|>String}}</code>

| rowspan=3| {{<code|>Boolean}}</code>

| rowspan=3| <code>Enum ''name''<br />{{Spaces|3}}''item{{sub|1}}'' «= ''value''»<br />{{Spaces|3}}''item{{sub|2}}'' «= ''value»<br />{{Spaces|3}}...''<br /> End Enum</code>

| {{code|[[Variant type|{{code|Variant]]}}]]

|-

| [[Visual Basic .NET]]

| {{<code|>Char}}</code>

| {{<code|>Object}}</code>

|-

| [[Xojo]]

| {{nN/aA|N/A}}

| {{<code|>Object}}</code> or {{<code|>Variant}}</code>

|-

| [[Python (programming language)|Python]]

| {{nN/aA|N/A}}{{ref|string as char|[d]}}

| {{<code|>str}}</code>

| {{<code|>bool}}</code>

| {{pre|1=

| <code>from enum import Enum<br />class Name(Enum):<br />{{Spaces|3}}''item{{sub|1}}'' = ''value''<br />{{Spaces|3}}''item{{sub|2}}'' = ''value''<br />{{Spaces|3}}''...''</code>

{{codett|2=python|import enum}}

| {{code|object}}

{{codett|2=python|class Name(enum.Enum):}}

''item{{sub|1}}'' = ''value''

''item{{sub|2}}'' = ''value''

''...''

}}

| {{<code|>object}}</code>

|-

| [[JavascriptJavaScript]]

| {{nN/aA|N/A}}{{ref|string as char|[d]}}

| {{<code|>String}}</code>

| {{<code|>Boolean}}</code>

|

| {{<code|>Object}}</code>

|-

| [[S-Lang (programming language)|S-Lang]]

|

|

Line 1,016 ⟶ 1,020:

|-

| [[Fortran]]

| <{{code>|2=fortran|1=CHARACTER(LEN = *)</code>}}

| <{{code>|2=fortran|1=CHARACTER(LEN = :), allocatable</code>}}

| <{{code>|2=fortran|1=LOGICAL(KIND = n)</code>}}{{ref|logical kinds|[f]}}

|

| {{<code|>CLASS(*)}}</code>

|-

| [[PHP]]

| {{nN/aA|N/A}}{{ref|string as char|[d]}}

| {{<code|>string}}</code>

| {{<code|>bool}}</code>

|

| (type declaration omitted)

|-

| [[Perl]]

| {{nN/aA|N/A}}{{ref|string as char|[d]}}

|

|

|

| {{<code|>UNIVERSAL}}</code>

|-

| [[Raku (programming language)|Raku]]

| {{<code|>Char}}</code>

| {{<code|>Str}}</code>

| {{<code|>Bool}}</code>

| <code>enum ''name<item₁ item₂ ...>''</code><br /><code>enum ''name <<:item₁(value) :item₂(value) ..>>''</code>

| {{<code|>Mu}}</code>

|-

| [[Ruby (programming language)|Ruby]]

| {{nN/aA|N/A}}{{ref|string as char|[d]}}

| {{<code|>String}}</code>

| {{<code|>Object}}</code>{{ref|Ruby's bool|[c]}}

|

| {{<code|>Object}}</code>

|-

| [[Scala (programming language)|Scala]]

| {{<code|>Char}}</code>

| {{<code|>String}}</code>

| {{<code|>Boolean}}</code>

| <code>object ''name'' extends Enumeration {<br />{{Spaces|3}}''val item{{sub|1}}, item{{sub|2}}, ... = Value''<br />}</code>

| {{<code|>Any}}</code>

|-

| [[Seed7]]

| {{<code|>char}}</code>

| {{<code|>string}}</code>

| {{<code|>boolean}}</code>

| <code>const type'': name'' is new enum<br />{{Spaces|3}}''item{{sub|1}},''<br />{{Spaces|3}}''item{{sub|2}},''<br />{{Spaces|3}}''...''<br />end enum;</code>

|

|-

Line 1,072 ⟶ 1,076:

|-

| [[OCaml]]

| rowspan=3| {{<code|>char}}</code>

| rowspan=3| {{<code|>string}}</code>

| rowspan=3| {{<code|>bool}}</code>

| {{nN/aA|N/A}}{{ref|enum|[e]}}

| {{nN/aA|N/A}}

|-

| [[F Sharp (programming language)|F#]]

| <code>type ''name'' = ''item₁'' = ''value'' {{pipe}}''item₂'' = ''value'' {{pipe}} ''...''</code>

| {{<code|>obj}}</code>

|-

| [[Standard ML]]

| {{nN/aA|N/A}}{{ref|enum|[e]}}

| {{nN/aA|N/A}}

|-

| [[Haskell (programming language)|Haskell]] ([[Glasgow Haskell Compiler|GHC]])

| {{<code|>Char}}</code>

| {{<code|>String}}</code>

| {{<code|>Bool}}</code>

| {{nN/aA|N/A}}{{ref|enum|[e]}}

| {{nN/aA|N/A}}

|-

| [[Eiffel (programming language)|Eiffel]]

| {{<code|>CHARACTER}}</code>

| {{<code|>STRING}}</code>

| {{<code|>BOOLEAN}}</code>

| {{nN/aA|N/A}}

| {{<code|>ANY}}</code>

|-

| [[COBOL]]

| {{<code|>PIC X}}</code>

| <code>''PIC X(''string length'')''</code> or <code>PIC&nbsp;X«X...»</code>

| <code>''PIC 1«(''number of digits'')»''</code> or <code>PIC&nbsp;1«1...»</code>

| {{nN/aA|N/A}}

| {{<code|>OBJECT REFERENCE}}</code>

|-

| [[Mathematica]]

| {{nN/aA|N/A}}{{ref|string as char|[d]}}

| {{<code|>String}}</code>

|

|

| {{nN/aA|N/A}}

|}

* {{note|string|a}} specifically, strings of arbitrary length and automatically managed.

* {{note|int bool|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.

* {{note|Ruby's bool|c}} All values evaluate to either true or false. Everything in ''{{<code|>TrueClass}}</code>'' evaluates to true and everything in ''{{<code|>FalseClass}}</code>'' evaluates to false.

* {{note|string as char|d}}This language does not have a separate character type. Characters are represented as strings of length 1.

* {{note|enum|e}} Enumerations in this language are algebraic types with only nullary constructors

* {{note|logical kinds|f}} The value of ''{{<code|>n}}</code>'' is provided by the {{<code|>SELECTED_INT_KIND}}</code><ref name="fortranwiki.org" /> intrinsic function.

== Derived types ==

=== [[Array data type|Array]] ===

{{furtherFurther|Comparison of programming languages (array)}}

{{further|Comparison of programming languages (array)}}

{| class="wikitable sortable"

|- valign="top"

Line 1,140 ⟶ 1,141:

|- valign="top"

| [[Ada (programming language)|Ada]]<ref name="Ada_RM_2012" />

| <code>array (''<&lt;first> ''..'' <&lt;last>'') of'' <&lt;type>''</code><br />or<br /><code>array (''<&lt;discrete_type>'') of'' <&lt;type>''</code>

| <code>array (''<&lt;first₁> ''..'' <&lt;last₁>'','' <&lt;first₂> ''..'' <&lt;last₂>'', ''...'') of'' <&lt;type>''</code><br />or<br /><code>array (''<&lt;discrete_type₁>'','' <&lt;discrete_type₂>'','' ...'') of'' <&lt;type>''</code>

| <code>array (''<&lt;discrete_type> ''range <>) of'' <&lt;type>''</code>

| <code>array (''<&lt;discrete_type₁> ''range <>,'' <discrete_type₂> ''range <>, ''...'') of'' <&lt;type>''</code>

|- valign="top"

| [[ALGOL 68]]

| <code>[''first'':''last'']<wbr/>«modename»</code><br />or simply:<br /><code>[''size'']<wbr/>«modename»</code>

| <code>[''first₁'':''last₁'','' first₂'':''last₂'']<wbr/>«modename»</code><br />or<br /><code>[''first₁'':''last₁''][''first₂'':''last₂'']<wbr/>«modename»</code><br />etc.

| <code>flex[''first'':''last'']<wbr/>«modename»</code><br />or simply:<br /><code>flex[''size'']<wbr/>«modename»</code>

| <code>flex[''first₁'':''last₁'','' first₂'':''last₂'']<wbr/>«modename»</code><br />or<br /><code>flex[''first₁'':''last₁'']<wbr/>flex[''first₂'':''last₂'']<wbr/>«modename» ''etc.''</code>

|- valign="top"

| [[C (programming language)|C]] ([[C99]])

| <code>''type name''[''size'']</code>{{ref|C's array|[a]}}

| <code>''type name''[''size₁''][''size₂'']</code>{{ref|C's array|[a]}}

| <code>''type'' *''name''</code><br />or within a block:<br /><code>''int n = ...; type name''[''n'']</code>

|

|- valign="top"

Line 1,165 ⟶ 1,166:

| <code>''type''[]</code>

| <code>''type''[{{Not a typo|,,}}''...'']</code>

| <code>System<wbr/>.Collections<wbr/>.ArrayList</code><br />or<br /><code>System<wbr/>.Collections<wbr/>.Generic<wbr/>.List<wbr/><''type''></code>

|

|- valign="top"

Line 1,188 ⟶ 1,189:

| [[Rust (programming language)|Rust]]

| <code>[''type; size'']</code>

| <code><nowiki>[[</nowiki>''type; size₁'']''; size₂'']</code>

| <code>Vec<''type''></code>

| <code>Vec<Vec<''type''>></code>

Line 1,204 ⟶ 1,205:

|

|- valign="top"

| [[JavascriptJavaScript]]

| {{n/a}}

| {{n/a}}

Line 1,210 ⟶ 1,211:

|- valign="top"

| [[Common Lisp]]

| {{code|2=lisp|(simple-array type (dimension))|lisp}}

| {{code|2=lisp|(simple-array type (dimension1 dimension2))|lisp}}

| {{code|2=lisp|(array type (dimension))|lisp}}

| {{code|2=lisp|(array type (dimension1 dimension2))|lisp}}

|- valign="top"

| [[Scheme (programming language)|Scheme]]

Line 1,229 ⟶ 1,230:

| [[Pascal (programming language)|Pascal]]

| rowspan=2|<code>array[''first''..''last''] of ''type''</code>{{ref|subrange|[c]}}

| rowspan=2|<code>array[''first₁''..''last₁''] of array[''first₂''..''last₂'']'' ...'' of ''type''</code>{{ref|subrange|[c]}}<br />or<br /><code> array[''first₁''..''last₁'','' first₂''..''last₂'','' ...''] of ''type''</code>{{ref|subrange|[c]}}

| {{n/a}}

| {{n/a}}

|- valign="top"

| [[Object Pascal]] ([[Delphi (software)|Delphi]])

| <code>array of'' type''</code>

| <code>array of array ''...'' of ''type''</code>

Line 1,246 ⟶ 1,247:

| <code>''type''()</code>

| <code>''type''({{Not a typo|,,}}''...'')</code>

| <code>System<wbr/>.Collections<wbr/>.ArrayList</code><br />or<br /><code>System<wbr/>.Collections<wbr/>.Generic<wbr/>.List<wbr/>(Of ''type'')</code>

|

|- valign="top"

Line 1,255 ⟶ 1,256:

|

|- valign="top"

| [[S-Lang (programming language)|S-Lang]]

| <code>x = ''type''[''size''];</code>

| <code>x = ''type''[''size₁'','' size₂'', ''...''];</code>

Line 1,298 ⟶ 1,299:

|- valign="top"

| [[Seed7]]

| <code>array ''type''</code><br />or<br /><code>array [''idxType''] ''type''</code>

| <code>array array ''type''</code><br />or<br /><code>array [''idxType''] array [''idxType''] ''type''</code>

| <code>array ''type''</code><br />or<br /><code>array [''idxType''] ''type''</code>

| <code>array array ''type''</code><br />or<br /><code>array [''idxType''] array [''idxType''] ''type''</code>

|- valign="top"

| [[Smalltalk]]

Line 1,322 ⟶ 1,323:

|- valign="top"

| [[F Sharp (programming language)|F#]]

| <code>''type'' []</code><br />or<br /><code>''type'' array</code>

| <code>''type'' [{{Not a typo|,,}}''...'']</code>

| <code>System<wbr/>.Collections<wbr/>.ArrayList</code><br />or<br /><code>System<wbr/>.Collections<wbr/>.Generic<wbr/>.List<wbr/><''type''></code>

|

|- valign="top"

Line 1,333 ⟶ 1,334:

|

|- valign="top"

| [[Haskell (programming language)|Haskell]] ([[Glasgow Haskell Compiler|GHC]])

| <code>{{codett|2=haskell|1=x = Array.array (0,}} ''size''-1) ''list_of_association_pairs''</code>

| <code>{{codett|2=haskell|1=x = Array.array ((0, 0,}}''...''), (''size₁''-1, ''size₂''-1,''...'')) ''list_of_association_pairs''</code>

|

|

Line 1,342 ⟶ 1,343:

| <code>''level-number type'' OCCURS ''size'' «TIMES».</code>

| {{em|one-dimensional array definition...}}

| <code>''level-number type'' OCCURS ''min-size'' TO ''max-size'' {{codett|2=cobolfree|1=«TIMES» DEPENDING «ON»}} ''size''.</code>{{ref|COBOL DEPENDING ON clause|[e]}}

| {{n/a}}

|}

* {{note|C's array|a}}In most expressions (except the <code>[[sizeof]]</code> and {{<code|>&}}</code> operators), values of array types in C are automatically converted to a pointer of its first argument. See [[C syntax#Arrays]] for further details of syntax and pointer operations.

* {{note|Java's array|b}} The C-like <code>''type'' x[]</code> works in Java, however <code>''type''[] x</code> is the preferred form of array declaration.

* {{note|subrange|c}} Subranges are used to define the bounds of the array.

* {{note|JavaScript's array|d}} JavaScript's array are a special kind of object. <!-- explain array(size) thing -->

* {{note|COBOL DEPENDING ON clause|e}} The {{<code|>DEPENDING ON}}</code> clause in COBOL does not create a ''true'' variable length array and will always allocate the maximum size of the array.

=== Other types ===

{| class="wikitable sortable"

! rowspan=2|

Line 1,364:

|-

| [[Ada (programming language)|Ada]]<ref name="Ada_RM_2012" />

| <code>type ''name'' is «abstract» «tagged» «limited» ''[''record{{indent|2}}''field{{sub|1}}'' : ''type'';{{indent|2}}''field{{sub|2}}'' : ''type'';{{indent|2}}''...''<br />end record ''{{pipe}}'' null record'']''</code>

| {{nN/aA|N/A}}

| {{Any}} combination of records, unions, and enumerations (as well as references to those, enabling recursive types).

| <code>type ''name'' (''variation'' : ''discrete_type'') is record{{indent|2}}case ''variation'' is{{indent|4}}when ''choice_list{{sub|1}}'' =>{{indent|6}}''fieldname{{sub|1}}'' : ''type'';{{indent|6}}''...''{{indent|4}}when ''choice_list{{sub|2}}'' =>{{indent|6}}''fieldname{{sub|2}}'' : ''type'';{{indent|6}}''...''{{indent|4}}''...''{{indent|2}}end case;<br />end record</code>

|-

| [[ALGOL 68]]

Line 1,376:

| [[C (programming language)|C]] ([[C99]])

| rowspan=2| <code>struct ''«name»'' {''type name'';''...''};</code>

| rowspan=2 {{nN/aA|N/A}}

| rowspan=3 {{nN/aA|N/A}}

| rowspan=3| <code>union {''type name'';''...''};</code>

|-

Line 1,390:

| <code>(''val{{sub|1}}'', ''val{{sub|2}}'', ''...'' )</code>

|

| rowspan=3 {{nN/aA|N/A}}

|-

| [[Java (programming language)|Java]]

| {{nN/aA|N/A}}{{ref|just classes|[a]}}

|

|

|-

| [[JavascriptJavaScript]]

|

| {{nN/aA|N/A}}

|

|-

Line 1,409:

|-

| [[Go (programming language)|Go]]

| <code>struct { {{indent|2}}''«name» type''{{indent|2}}''...''<br />}</code>

|

|

Line 1,421:

|-

| [[Swift (programming language)|Swift]]

| <code>struct ''name'' {''{{indent|2}}''var'' name «'':'' type»{{indent|2}}...<br />''}</code>

| <code>(''«name{{sub|1}}'':''» val{{sub|1}}'', ''«name{{sub|2}}'':''» val{{sub|2}}'', ''«name{{sub|3}}'':''» val{{sub|3}}'', ''...'' )</code>

| <code>enum ''name'' { case ''Foo«''(''types'')» case ''Bar'' «(''types'')» ''...'' }</code>

Line 1,427:

|-

| [[Common Lisp]]

| {{code|2=lisp|(defstruct name slot-name (slot-name initial-value) (slot-name initial-value :type type) ...)|lisp}}

| rowspan=3| <code>(cons ''val{{sub|1}} val{{sub|2}}'')</code>{{ref|pair only|[c]}}

|

Line 1,433:

|-

| [[Scheme (programming language)|Scheme]]

| {{nN/aA|N/A}}

|

|

Line 1,443:

|-

| [[Pascal (programming language)|Pascal]]

| <code>record{{indent|2}}''name'': ''type'';{{indent|2}}''...<br />''end</code>

| {{nN/aA|N/A}}

| {{nN/aA|N/A}}

| <code>record{{indent|2}}case ''type'' of{{indent|2}}''value'': (''types'');{{indent|2}}''...''<br />end</code>

|-

| [[Visual Basic (classic)|Visual Basic]]

Line 1,455:

|-

| [[Visual Basic .NET]]

| <code>Structure ''name''{{indent|2}}Dim ''name'' As ''type''{{indent|2}}''...''<br />End Structure</code>

| <code>(''val{{sub|1}}'', ''val{{sub|2}}'', ''...'' )</code>

|

Line 1,461:

|-

| [[Python (programming language)|Python]]

| {{nN/aA|N/A}}{{ref|just classes|[a]}}

| <code>«(''»val{{sub|1}}'', ''val{{sub|2}}'', ''val{{sub|3}}'', ''...'' «)»</code>

|

| {{nN/aA|N/A}}

|-

| [[S-Lang (programming language)|S-Lang]]

| <code>struct {''name [=value], ...''}</code>

|

Line 1,473:

|-

| [[Fortran]]

| <code>TYPE ''name{{indent|2}}type'' :: ''name{{indent|2}}...<br />''END TYPE</code>

|

|

Line 1,479:

|-

| [[PHP]]

| {{nN/aA|N/A}}{{ref|just classes|[a]}}

|

|

Line 1,485:

|-

| [[Perl]]

| {{nN/aA|N/A}}{{ref|Perl's records|[d]}}

|

|

| rowspan=3 {{nN/aA|N/A}}

|-

| [[Raku (programming language)|Raku]]

| {{nN/aA|N/A}}{{ref|just classes|[a]}}

|

|

Line 1,503:

| <code>case class ''name''(«''var''» ''name'': ''type'', ''...'')</code>

| <code>(''val{{sub|1}}'', ''val{{sub|2}}'', ''val{{sub|3}}'', ''...'' )</code>

| <code>abstract class ''name''{{indent|2}}case class ''Foo''(«''parameters''») extends ''name''{{indent|2}}case class ''Bar''(«''parameters''») extends ''name''{{indent|2}}''...''</code><br />or<br /><code>abstract class ''name''{{indent|2}}case object ''Foo'' extends ''name''{{indent|2}}case object ''Bar'' extends ''name''{{indent|2}}''...''</code><br />or a combination of case classes and case objects

|

|-

Line 1,516:

| rowspan=2| <code>«(»''val{{sub|1}}'', ''val{{sub|2}}'', ''val{{sub|3}}'', ''...'' «)»</code>

| rowspan=2| <code>type ''name'' = ''Foo'' «of ''type''» {{pipe}} ''Bar'' «of ''type''» {{pipe}} ''...''</code>

| rowspan=4 {{nN/aA|N/A}}

|-

| [[F Sharp (programming language)|F#]]

Line 1,525:

| <code>datatype ''name'' = ''Foo'' «of ''type''» {{pipe}} ''Bar'' «of ''type''» {{pipe}} ''...''</code>

|-

| [[Haskell (programming language)|Haskell]]

| <code>data ''Name'' = ''Constr'' {''name'' :: ''type'',''...''}</code>

| <code>data ''Name'' = ''Foo'' «''types''» {{pipe}} ''Bar'' «''types''» {{pipe}} ''...''</code>

|-

| [[COBOL]]

| <code>''{{codett|2=cobolfree|level-number name type clauses}}''.{{indent|2}}''{{codett|2=cobolfree|level-number+n name type clauses}}''.{{indent|2}}''...''</code>

| {{nN/aA|N/A}}

| {{nN/aA|N/A}}

| <code>''name'' REDEFINES ''variable type''.</code>

|}

* {{note|just classes|a}} Only classes are supported.

* {{note|C++'s struct|b}} {{<code|>struct}}</code>s in C++ are actually classes, but have default public visibility and ''are'' also [[Plain old data structure|POD]] objects. C++11 extended this further, to make classes act identically to POD objects in many more cases.

* {{note|pair only|c}} pair only

* {{note|Perl's records|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.

Line 1,543:

== Variable and constant declarations ==

{| class="wikitable sortable"

!

Line 1,571 ⟶ 1,570:

|-

| [[C Sharp (programming language)|C#]]

| <code>''type name₁''« = ''initial_value''», ''name₂''« = ''initial_value''», ''...'';</code><br />or<br /><code>var ''name'' = ''initial_value'';</code>

| <code>const ''type name'' = ''value'', ''name'' = ''value'', ''...'';</code><br />or<br /><code>readonly ''type name'' = ''value'', ''name'' = ''value'', ''...'' ;</code>

| <code>using ''synonym'' = ''type'';</code>

|-

| [[D (programming language)|D]]

| <code>''type name''« = ''initial_value''»;</code><br />or<br /><code>auto ''name'' = ''value'';</code>

| <code>const ''type name'' = ''value'';</code><br />or<br /><code>immutable ''type name'' = ''value'';</code>

| <code>alias ''type synonym'';</code>

|-

Line 1,585 ⟶ 1,584:

| rowspan=2 {{n/a}}

|-

| [[JavascriptJavaScript]]

| <code>var ''name''« = ''initial_value''»;</code> or<br /><code>let ''name''« = ''initial_value''»;</code> (since [[ECMAScript]] 2015)

| <code>const ''name'' = ''value'';</code> (since [[ECMAScript]] 2015)

|-

| [[Go (programming language)|Go]]

| <code>var ''name type''« = ''initial_value''»</code><br />or<br /><code>''name'' := ''initial_value''</code>

| <code>const ''name «type»'' = ''value''</code>

| <code>type ''synonym type''</code>

|-

| [[Rust (programming language)|Rust]]{{ref|Rust declaration|[f]}}

| <code>let mut ''name''«: ''type''»« = ''initial_value''»;</code><br /><code>static mut ''NAME'': ''type'' = ''value'';</code>

| <code>let ''name''«: ''type''»« = ''initial_value''»;</code><br /><code>const ''NAME'': ''type'' = ''value'';</code><br /><br /><code>static ''NAME'': ''type'' = ''value'';</code>

| <code>type ''synonym'' = ''typename'';</code>

|-

Line 1,605 ⟶ 1,604:

|-

| [[Common Lisp]]

| <code>(defparameter ''name initial-value'')</code><br />or<br /><code>(defvar ''name initial-value'')</code>

| <code>(defconstant ''name value'')</code>

| <code>(deftype ''synonym'' () <nowiki>'</nowiki>''type'')</code>

Line 1,615 ⟶ 1,614:

|-

| [[ISLISP]]

| <code>(defglobal ''name initial_value'')</code><br />or<br /><code>(defdynamic ''name initial_value'')</code>

| <code>(defconstant ''name value'')</code>

| {{n/a}}

Line 1,628 ⟶ 1,627:

| rowspan=3| See notes to left.

Constants use the same syntax, and:

* use {{<code|>Const}}</code> instead of {{<code|>Dim}}</code>

* have a restriction to only certain primitive types<br /><code>Const ''name₁'' «As ''type''» = ''value'', ''name₂'' «As ''type»'' = ''value, ...''</code>

|

|-

Line 1,635 ⟶ 1,634:

| The variable declaration syntax of VB.NET is unusually difficult to precisely describe.

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

* {{<code|>type_character}}</code>, available as an alternative to an {{<code|>As}}</code> clause for some primitive data types;

* {{<code|>nullable_specifier}}</code>; and

* {{<code|>array_specifier}}</code>;

and that

* a {{<code|>modified_identifier}}</code> is of the form {{<code|>identifier«type_character»«nullable_specifier»«array_specifier»}}</code>;

* a {{<code|>modified_identifier_list}}</code> is a comma-separated list of two or more occurrences of {{<code|>modified_identifier}}</code>; and

* a {{<code|>declarator_list}}</code> is a comma-separated list of declarators, which can be of the form

** <code>''identifier'' As ''object_creation_expression''</code>'' (object initializer declarator)'',

** <code>''modified_identifier'' «As ''non_array_type''«''array_rank_specifier''»»« = ''initial_value»''</code> ''(single declarator)'', or

Line 1,647 ⟶ 1,646:

valid declaration statements are of the form

{{In5}}<code>Dim ''declarator_list''</code>,

where, for the purpose of semantic analysis, to convert the {{<code|>declarator_list}}</code> to a list of only single declarators:

* The {{<code|>As}}</code> clauses of each ''multiple declarator'' is distributed over its {{<code|>modified_identifier_list}}</code>

* The <code>As New ''type...''</code> of each ''object initializer declarator'' is replaced with <code>As ''type'' = New ''type...''</code>

and for which, for each {{<code|>identifier}}</code>,

* a {{<code|>type_character}}</code> and {{<code|>As}}</code> clause do not both appear;

* if an {{<code|>As}}</code> clause is present,

** an {{<code|>array_rank_specifier}}</code> does not appear both as a modification of the identifier and on the type of the {{<code|>As}}</code> clause;

* an {{<code|>unmodified_type}}</code> can be determined, by the rule that,

** if a {{<code|>type_character}}</code> or {{<code|>As}}</code> clause is present,

*** {{<code|>unmodified_type}}</code> is that specified by such construct,

** and that otherwise,

*** either {{<code|>Option Infer}}</code> must be on and the {{<code|>identifier}}</code> must have an initializer, in which case {{<code|>unmodified_type}}</code> is that of the initializer, or

*** {{<code|>Option Strict}}</code> must be off, in which case {{<code|>unmodified_type}}</code> is {{<code|>Object}}</code>;

* its {{<code|>final_type}}</code> is its {{<code|>unmodified_type}}</code> prepended before its modifiers;

* its {{<code|>final_type}}</code> is a valid type; and

* if an {{<code|>initial_value}}</code> is present,

** either {{<code|>Option Strict}}</code> is on and {{<code|>initial_value}}</code> has a widening conversion to {{<code|>final_type}}</code>, or

** {{<code|>Option Strict}}</code> is off and {{<code|>initial_value}}</code> has a narrowing conversion to {{<code|>final_type}}</code>.

If {{<code|>Option Explicit}}</code> is off, variables do not require explicit declaration; they are declared implicitly when used:

{{code|<syntaxhighlight lang="basic" inline>name {{=}} initial_value}}</syntaxhighlight>

| <code>Imports ''synonym'' = ''type''</code>

|-

Line 1,681 ⟶ 1,680:

| <code>''name'' = ''initial_value''</code>| <code>''name'' = ''initial_value''</code>

|-

| [[S-Lang (programming language)|S-Lang]]

| <code>''name'' = ''initial_value'';</code>

|

Line 1,687 ⟶ 1,686:

|-

| [[Fortran]]

| <code>''type'' :: ''name''</code>

| <code>''type'', PARAMETER :: ''name'' = ''value''</code>

|

Line 1,693 ⟶ 1,692:

| [[PHP]]

| <code>$''name'' = ''initial_value'';</code>

| <code>define("''name''", ''value'');<br />const ''name'' = ''value (5.3+)''</code>

| rowspan=2 {{n/a}}

|-

Line 1,737 ⟶ 1,736:

| <code>val ''name'' «: ''type''» = ''value''</code>

|-

| [[Haskell (programming language)|Haskell]]

|

| <code>«''name''::''type'';» ''name'' = ''value''</code>

Line 1,761 ⟶ 1,760:

* {{note|variable types|b}}Types are just regular objects, so you can just assign them.

* {{note|Perl's my keyword|c}} In Perl, the "my" keyword scopes the variable into the block.

* {{note|ML ref|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 {{<code|>!}}</code> and {{code|<syntaxhighlight lang="sml" inline>:{{=}}}}</syntaxhighlight> operators, respectively.

* {{note|Ada declaration|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.

* {{note|Rust declaration|f}} In Rust, if no initial value is given to a {{<code|>let}}</code> or {{<code|>let mut}}</code> variable and it is never assigned to later, there is an [https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html#unused-variables "unused variable" warning]. If no value is provided for a {{<code|>const}}</code> or {{<code|>static}}</code> or {{<code|>static mut}}</code> variable, there is an error. There is a [https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html?#non-upper-case-globals "non-upper-case globals"] error for non-uppercase {{<code|>const}}</code> variables. After it is defined, a {{<code|>static mut}}</code> variable can only be assigned to in an {{<code|>unsafe}}</code> block or function.

== [[Control flow]] ==

=== [[Conditional (programming)|Conditional]] statements ===

{| class="wikitable sortable"

|- valign="top"

Line 1,778 ⟶ 1,775:

|- valign="top"

| [[Ada (programming language)|Ada]]<ref name="Ada_RM_2012" />

| <code>if ''condition'' then{{indent|2}}''statements''<br />«else{{indent|2}}''statements''»<br />end if</code>

| <code>if ''condition{{sub|1}}'' then{{indent|2}}''statements''<br />elsif ''condition{{sub|2}}'' then{{indent|2}}''statements''<br />''...''<br />«else{{indent|2}}''statements''»<br />end if</code>

| <code>case ''expression'' is{{indent|2}}when ''value_list''{{sub|1}} => ''statements''{{indent|2}}when ''value_list{{sub|2}}'' => ''statements''{{indent|2}}''...''{{indent|2}}«when others => ''statements''»<br />end case</code>

| <code>(if ''condition{{sub|1}}'' then{{indent|2}}''expression{{sub|1}}''<br />«elsif ''condition{{sub|2}}'' then{{indent|2}}''expression{{sub|2}}''»<br />''...''<br />else{{indent|2}}''expression{{sub|n}}''<br />)</code><br />or<br /><code>(case ''expression'' is{{indent|2}}when ''value_list{{sub|1}}'' => ''expression{{sub|1}}''{{indent|2}}when ''value_list{{sub|2}}'' => ''expression{{sub|2}}''{{indent|2}}''...''{{indent|2}}«when others => ''expression{{sub|n}}''»<br />)</code>

|- valign="top"

| [[Seed7]]

| <code>if ''condition'' then{{indent|2}}''statements''<br />«else{{indent|2}}''statements''»<br />end if</code>

| <code>if ''condition{{sub|1}}'' then{{indent|2}}''statements''<br />elsif ''condition{{sub|2}}'' then{{indent|2}}''statements''<br />''...''<br />«else{{indent|2}}''statements''»<br />end if</code>

| <code>case ''expression'' of{{indent|2}}when ''set1'' : ''statements''{{indent|2}}''...''{{indent|2}}«otherwise: ''statements''»<br />end case</code>

|

|- valign="top"

| [[Modula-2]]

| <code>if ''condition'' then{{indent|2}}''statements''<br />«else{{indent|2}}''statements''»<br />end</code>

| <code>if ''condition{{sub|1}}'' then{{indent|2}}''statements''<br />elsif ''condition{{sub|2}}'' then{{indent|2}}''statements''<br />''...''<br />«else{{indent|2}}''statements''»<br />end</code>

| rowspan=1 | <code>case ''expression'' of{{indent|2}}''caseLabelList'' : ''statements'' {{pipe}}{{indent|2}}''...''{{indent|2}}«else ''statements''»<br />end</code>

|

|- valign="top"

Line 1,801 ⟶ 1,798:

| <syntaxhighlight lang="text" inline>( condition | valueIfTrue | valueIfFalse )</syntaxhighlight>

|- valign="top"

| [[ALGOL 68]]<br />(brief form)

| <syntaxhighlight lang="text" inline>( condition | statements «| statements» )</syntaxhighlight>

| <syntaxhighlight lang="text" inline>( condition | statements |: condition | statements )</syntaxhighlight>

Line 1,808 ⟶ 1,805:

|- valign="top"

| [[APL (programming language)|APL]]

| <code>:If ''condition''{{indent|2}}''instructions''<br />«:Else{{indent|2}}''instructions''»<br />:EndIf</code>

| <code>:If ''condition''{{indent|2}}''instructions''<br />:ElseIf ''condition''{{indent|2}}''instructions''<br />''...''<br />«:Else{{indent|2}}''instructions''»<br />:EndIf</code>

| <code>:Select ''expression''{{indent|2}}:Case ''case1''{{indent|4}}''instructions''{{indent|2}}''...''{{indent|2}}«:Else{{indent|4}}''instructions''»<br />:EndSelect</code>

| <code>{''condition'':''valueIfTrue'' ⋄ ''valueIfFalse''}</code>

|- valign="top"

| [[C (programming language)|C]] ([[C99]])

| rowspan=7| <code>if (''condition'') ''instructions''<br />«else ''instructions''»</code><br />{{<code|>instructions}}</code> can be a single statement or a block in the form of: <code>{ ''statements'' }</code>

| rowspan=7| <code>if (''condition'') ''instructions''<br />else if (''condition'') ''instructions''<br />''...''<br />«else ''instructions»''</code><br />or<br /><code>if (''condition'') ''instructions''<br />else { if (''condition'') ''instructions'' }</code>

| rowspan=7| <code>switch (''variable'') { {{indent|2}}case ''case1'': ''instructions'' «; break;»{{indent|2}}''...''{{indent|2}}«default: ''instructions''»<br />}</code>

| rowspan=7| <code>''condition'' [[?:|?]] ''valueIfTrue'' [[?:|:]] ''valueIfFalse''</code>

|- valign="top"

Line 1,832 ⟶ 1,829:

|- valign="top"

| [[C Sharp (programming language)|C#]]

| <code>if (''condition'') ''instructions''<br />«else ''instructions''»</code>

{{<code|>instructions}}</code> can be a single statement or a block in the form of: <code>{ ''statements'' }</code>

| <code>if (''condition'') ''instructions''<br />else if (''condition'') ''instructions''<br />''...''<br />«else ''instructions''»</code>

| <code>switch (''variable'')<br />{ {{indent|2}}case ''case{{sub|1}}'':{{indent|4}}''instructions''{{indent|4}}«''break_or_jump_statement''»{{indent|2}}''...''{{indent|2}}«default:{{indent|4}}''instructions''{{indent|4}}''break_or_jump_statement''»<br />}</code>

All non-empty cases must end with a {{<code|>break}}</code> or {{<code|>goto case}}</code> statement (that is, they are not allowed to fall-through to the next case).

The {{<code|>default}}</code> case is not required to come last.

| <code>''condition'' [[?:|?]] ''valueIfTrue'' [[?:|:]] ''valueIfFalse''</code>

|- valign="top"

| [[Windows PowerShell]]

| <code>if (''condition'') ''instruction''<br />«else ''instructions''»</code>

| <code>if (''condition'') { ''instructions'' }<br />elseif (''condition'') { ''instructions'' }<br />''...''<br />«else { ''instructions'' }»</code>

| <code>switch (''variable'') { ''case1''{''instructions'' «break;» } ''...'' «default { ''instructions'' }»}</code>

|

|- valign="top"

| [[Go (programming language)|Go]]

| <code>if ''condition'' {''instructions''}<br />«else {''instructions''}»</code>

| <code>if ''condition'' {''instructions''}<br />else if ''condition'' {''instructions''}<br />''...''<br />«else {''instructions''}»</code><br />or<br /><code>switch { {{indent|2}}case ''condition'': ''instructions''{{indent|2}}''...''{{indent|2}}«default: ''instructions''»<br />}</code>

| <code>switch ''variable'' { {{indent|2}}case ''case₁'': ''instructions''{{indent|2}}''...''{{indent|2}}«default: ''instructions''»<br />}</code>

|

|- valign="top"

| [[Swift (programming language)|Swift]]

| <code>if ''condition'' {''instructions''}<br />«else {''instructions''}»</code>

| <code>if ''condition'' {''instructions''}<br />else if ''condition'' {''instructions''}<br />''...''<br />«else {''instructions''}»</code>

| <code>switch ''variable'' { {{indent|2}}case ''case₁'': ''instructions''{{indent|2}}''...''{{indent|2}}«default: ''instructions''»<br />}</code>

|

|- valign="top"

| [[Perl]]

| <code>if (''condition'') {''instructions''}<br />«else {''instructions''}»</code><br />or<br /><code>unless (''notcondition'') {''instructions''}<br />«else {''instructions''}»</code>

| <code>if (''condition'') {''instructions''}<br />elsif (''condition'') {''instructions''}<br />''...''<br />«else {''instructions''}»</code><br />or<br /><code>unless (''notcondition'') {''instructions''}<br />elsif (''condition'') {''instructions''}<br />''...''<br />«else {''instructions''}»</code>

| <code>use feature "switch";<br />''...''<br />given (''variable'') { {{indent|2}}when (''case₁'') { ''instructions'' }{{indent|2}}''...''{{indent|2}}«default { ''instructions'' }»<br />}</code>

| <code>''condition'' [[?:|?]] ''valueIfTrue'' [[?:|:]] ''valueIfFalse''</code>

|- valign="top"

| [[Raku (programming language)|Raku]]

| <code>if ''condition'' {''instructions''}<br />«else {''instructions''}»</code><br />or<br /><code>unless ''notcondition'' {''instructions''}</code>

| <code>if ''condition'' {''instructions''} <br />elsif ''condition'' {''instructions''} <br />...<br />«else {''instructions''}</code>

| <code>given ''variable'' { {{indent|2}}when ''case₁'' { ''instructions'' }{{indent|2}}''...''{{indent|2}}«default { ''instructions'' }»<br />}</code>

| <code>''condition'' [[?:|??]] ''valueIfTrue'' !! ''valueIfFalse''</code>

|- valign="top"

| [[Ruby (programming language)|Ruby]]

| <code>if ''condition''{{indent|2}}''instructions''<br />«else{{indent|2}}''instructions»''</code>

| <code>if ''condition''{{indent|2}}''instructions''<br />elsif ''condition''{{indent|2}}''instructions''<br />''...''<br />«else{{indent|2}}''instructions''»<br />end</code>

| <code>case ''variable''{{indent|2}}when ''case₁''{{indent|4}}''instructions''{{indent|2}}''...''{{indent|2}}«else{{indent|4}}''instructions''»<br />end</code>

| <code>''condition'' [[?:|?]] ''valueIfTrue'' [[?:|:]] ''valueIfFalse''</code>

|- valign="top"

| [[Scala (programming language)|Scala]]

| <code>if (''condition'') {''instructions''}<br />«else {''instructions''}»</code>

| <code>if (''condition'') {''instructions''}<br />else if (''condition'') {''instructions''}<br />...<br />«else {''instructions''}»</code>

| <code>''expression'' match { {{indent|2}}case ''pattern1'' => ''expression''{{indent|2}}case ''pattern2'' => ''expression''{{indent|2}}''...''{{indent|2}}«case _ => ''expression''»<br />}</code>{{ref|pattern matching|[b]}}

| <code>if (''condition'') ''valueIfTrue'' else ''valueIfFalse''</code>

|- valign="top"

| [[Smalltalk]]

| <code>''condition'' ifTrue:{{indent|2}}''trueBlock''<br />«ifFalse:{{indent|2}}''falseBlock''»<br />end</code>

|

|

Line 1,889 ⟶ 1,886:

|- valign="top"

| [[Common Lisp]]

| <code>''(when'' condition{{indent|2}}''instructions'')</code><br />or<br /><code>(unless ''condition''{{indent|2}}''instructions'')</code><br />or<br /><code>(if ''condition''{{indent|2}}(progn ''instructions''){{indent|2}}«(progn ''instructions'')»)</code>

| <code>(cond (''condition1 instructions''){{indent|2}}(''condition2 instructions''){{indent|2}}''...''{{indent|2}}«(t ''instructions'')»)</code>

| <code>(case ''expression''{{indent|2}}(''case1 instructions''){{indent|2}}(''case2 instructions''){{indent|2}}''...''{{indent|2}}«(otherwise ''instructions'')»)</code>

| <code>(if ''test then else'')</code><br />or<br /><code>(cond (''test1 value1'') (''test2 value2'') ''...''))</code>

|- valign="top"

| [[Scheme (programming language)|Scheme]]

| <code>(when ''condition instructions'')</code><br />or<br /><code>(if ''condition'' (begin ''instructions'') «(begin ''instructions'')»)</code>

| <code>(cond (''condition1 instructions'') (''condition2 instructions'') ''...'' «(else ''instructions'')»)</code>

| <code>(case (''variable'') ((''case1'') ''instructions'') ((''case2'') ''instructions'') ''...'' «(else ''instructions'')»)</code>

Line 1,907 ⟶ 1,904:

|- valign="top"

| [[Pascal (programming language)|Pascal]]

| <code>if ''condition'' then begin{{indent|2}}''instructions''<br />end<br />«else begin{{indent|2}}''instructions''<br />end»'</code>{{ref|pascal semicolon|[c]}}

| <code>if ''condition'' then begin{{indent|2}}''instructions''<br />end<br />else if ''condition'' then begin{{indent|2}}''instructions''<br />end<br />''...''<br />«else begin{{indent|2}}''instructions''<br />end»</code>{{ref|pascal semicolon|[c]}}

| <code>case ''variable'' of{{indent|2}}''case1'': ''instructions''{{indent|2}}''...''{{indent|2}}«else: ''instructions''»<br />end</code>{{ref|pascal semicolon|[c]}}

|- valign="top"

| [[Visual Basic (classic)|Visual Basic]]

| rowspan=3| <code>If ''condition'' Then{{indent|2}}''instructions''<br />«Else{{indent|2}}''instructions''»<br />End If</code><br />Single-line, when {{<code|>instructions}}</code> are <code>instruction{{sub|1}} : instruction{{sub|2}} : ...</code>:<br /><code>If ''condition'' Then ''instructions'' «Else ''instructions»''</code>

| rowspan=3| <code>If ''condition'' Then{{indent|2}}''instructions''<br />ElseIf ''condition'' Then{{indent|2}}''instructions''<br />''...''<br />«Else{{indent|2}}''instructions''»<br />End If</code><br />Single-line:<br />See note about C-like languages; the {{<code|>Else}}</code> clause of a single-line {{<code|>If}}</code> statement can contain another single-line {{<code|>If}}</code> statement.

| rowspan=3| <code>Select« Case» ''variable''{{indent|2}}Case ''case_pattern{{sub|1}}''{{indent|4}}''instructions''{{indent|2}}''...''{{indent|2}}«Case Else{{indent|4}}''instructions''»<br />End Select</code>

| <code>[[IIf]](''condition'', ''valueIfTrue'', ''valueIfFalse'')</code>

|- valign="top"

Line 1,923 ⟶ 1,920:

|- valign="top"

| [[Python (programming language)|Python]]{{ref|python indent|[a]}}

| <code>if ''condition'' :<br />{{keypress|Tab}}''instructions''<br />«else:<br />{{keypress|Tab}}''instructions»''</code>

| <code>if ''condition'' :<br />{{keypress|Tab}}''instructions''<br />elif ''condition'' :<br />{{keypress|Tab}}''instructions''<br />''...''<br />«else:<br />{{keypress|Tab}}''instructions»''</code>

| Python 3.10+:<br /><code>match ''variable'':<br />{{keypress|Tab}}case ''case1'':<br />{{keypress|Tab}}{{keypress|Tab}}''instructions''<br />{{keypress|Tab}}case ''case2'':<br />{{keypress|Tab}}{{keypress|Tab}}''instructions''</code>

| Python 2.5+:<br /><code>''valueIfTrue'' if ''condition'' else ''valueIfFalse''</code>

|- valign="top"

| [[S-Lang (programming language)|S-Lang]]

| <code>if (''condition'') { ''instructions'' } «else { ''instructions'' }»</code>

| <code>if (''condition'') { ''instructions'' } else if (''condition'') { ''instructions'' } ''...'' «else { ''instructions'' }»</code>

Line 1,935 ⟶ 1,932:

|- valign="top"

| [[Fortran]]

| <code>IF (''condition'') THEN{{indent|2}}''instructions''<br />ELSE{{indent|2}}''instructions''<br />ENDIF</code>

| <code>IF (''condition'') THEN{{indent|2}}''instructions''<br />ELSEIF (''condition'') THEN{{indent|2}}''instructions''<br />''...''<br />ELSE{{indent|2}}''instructions''<br />ENDIF</code>

| <code>SELECT CASE(''variable''){{indent|2}}CASE (''case1''){{indent|4}}''instructions''{{indent|2}}''...''{{indent|2}}CASE DEFAULT{{indent|4}}''instructions''<br />END SELECT</code>

|

|- valign="top"

Line 1,943 ⟶ 1,940:

| <code>''condition'' IF ''instructions'' « ELSE ''instructions''» THEN</code>

| <code>''condition'' IF ''instructions'' ELSE ''condition'' IF ''instructions'' THEN THEN</code>

| <code>''value'' CASE{{indent|2}}''case'' OF ''instructions'' ENDOF{{indent|2}}''case'' OF ''instructions'' ENDOF{{indent|4}}''default instructions''<br />ENDCASE</code>

| <code>''condition'' IF ''valueIfTrue ''ELSE ''valueIfFalse'' THEN</code>

|- valign="top"

Line 1,955 ⟶ 1,952:

| Lightweight syntax mode:

Either on a single line or with indentation as shown below:

<code>if ''condition'' then<br />{{keypress|Tab}}''instructions''<br />«else<br />{{keypress|Tab}}''instructions»''</code><br />Verbose syntax mode:<br />Same as Standard ML.

| Lightweight syntax mode:<br />Either on a single line or with indentation as shown below:<br /><code>if ''condition'' then<br />{{keypress|Tab}}''instructions''<br />elif ''condition'' then<br />{{keypress|Tab}}''instructions''<br />''...''<br />«else<br />{{keypress|Tab}}''instructions»''</code><br />Verbose syntax mode:<br />Same as Standard ML.

|- valign="top"

| [[Standard ML]]

| <code>if ''condition'' then «(''»instructions «'')»<br />else «(''» instructions «'')»</code>

| <code>if ''condition'' then «(''»instructions «'')»<br />else if ''condition'' then «(''» instructions «'')»<br />''...''<br />else «(''» instructions «'')»</code>

| <code>case ''value'' of{{indent|2}}''pattern1'' => ''expression''{{indent|2}}{{pipe}} ''pattern2'' => ''expression''{{indent|2}}''...''{{indent|2}}«{{pipe}} _ => ''expression»''</code>{{ref|pattern matching|[b]}}

|- valign="top"

| [[Haskell (programming language)|Haskell]] ([[Glasgow Haskell Compiler|GHC]])

| <code>if ''condition'' then ''expression'' else ''expression''</code><br />or<br /><code>when ''condition'' (do ''instructions'')</code><br />or<br /><code>unless ''notcondition'' (do ''instructions'')</code>

| <code>''result'' {{pipe}} ''condition'' = ''expression''{{indent|2}}{{pipe}} ''condition'' = ''expression''{{indent|2}}{{pipe}} otherwise = ''expression''</code>

| <code>case ''value'' of { {{indent|2}}''pattern1'' -> ''expression'';{{indent|2}}''pattern2'' -> ''expression'';{{indent|2}}''...''{{indent|2}}«_ -> ''expression»''<br />}</code>{{ref|pattern matching|[b]}}

|- valign="top"

| [[Bash shell]]

| <code>if ''condition-command;'' then{{indent|2}}''expression''<br />«else{{indent|2}}''expression''»<br />fi</code>

| <code>if ''condition-command;'' then{{indent|2}}''expression''<br />elif ''condition-command;'' then{{indent|2}}''expression''<br />«else{{indent|2}}''expression''»<br />fi</code>

| <code>case ''"$variable"'' in{{indent|2}}''"$condition1" ){{indent|4}}command...{{indent|2}}"$condition2" ){{indent|4}}command...''<br />esac</code>

|

|- valign="top"

| [[CoffeeScript]]

| <code>if ''condition'' then ''expression'' «else ''expression»''</code><br />or<br /><code>if ''condition{{indent|2}}expression''<br />«else{{indent|2}}''expression»''</code><br />or<br /><code>''expression'' if ''condition''</code><br />or<br /><code>unless ''condition''{{indent|2}}''expression''<br />«else{{indent|2}}''expression»''</code><br />or<br /><code>''expression'' unless ''condition''</code>

| <code>if ''condition'' then ''expression'' else if ''condition'' then ''expression'' «else ''expression»''</code><br />or<br /><code>if ''condition''{{indent|2}}''expression''<br />else if ''condition{{indent|2}}expression''<br />«else{{indent|2}}''expression»''</code><br />or<br /><code>unless ''condition''{{indent|2}}''expression''<br />else unless ''condition{{indent|2}}expression''<br />«else{{indent|2}}''expression»''</code>

| <code>switch ''expression''{{indent|2}}when ''condition'' then ''expression''{{indent|2}}else ''expression''</code><br />or<br /><code>switch ''expression''{{indent|2}}when ''condition''{{indent|4}}''expression''{{indent|2}}«else{{indent|4}}''expression»''</code>

| All conditions are expressions.

|- valign="top"

| [[COBOL]]

| <code>IF ''condition'' «THEN»{{indent|2}}''expression''<br />«ELSE{{indent|2}}''expression»''.</code>{{ref|COBOL END-IF|[d]}}

|

| <code>EVALUATE ''expression'' «ALSO ''expression...''»{{indent|2}}WHEN ''case-or-condition'' «ALSO ''case-or-condition...»{{indent|4}}expression{{indent|2}}...''{{indent|2}}«WHEN OTHER{{indent|4}}''expression''»<br />END-EVALUATE</code>

|

|- valign="top"

| [[Rust (programming language)|Rust]]

| <code>if ''condition'' { {{indent|2}}''expression''<br />}« else { {{indent|2}}''expression''<br />}»</code>

| <code>if ''condition'' { {{indent|2}}''expression''<br />} else if ''condition'' {''{{indent|2}}expression<br />''}« else {''{{indent|2}}expression<br />''}''»''</code>

| <code>match ''variable'' { {{indent|2}}''pattern1'' => ''expression,''{{indent|2}}''pattern2'' => ''expression,''{{indent|2}}''pattern3'' => ''expression,''{{indent|2}}«_ => ''expression''»<br />}</code>{{ref|pattern matching|[b]}}{{ref|Rust match expression|[e]}}

| All conditions are expressions

|- valign="top"

Line 2,003 ⟶ 2,000:

* {{note|pascal semicolon|c}} In languages of the Pascal family, the semicolon is not part of the statement. It is a separator between statements, not a terminator.

* {{note|COBOL END-IF|d}} <code>END-IF</code> may be used instead of the period at the end.

* {{note|Rust match expression|e}} In Rust, the comma ({{<code|>,}}</code>) 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 <code>{}</code>).

=== [[Control flow#Loops|Loop statements]] ===

{| class="wikitable sortable"

|-

Line 2,016 ⟶ 2,012:

|-

| [[Ada (programming language)|Ada]]<ref name="Ada_RM_2012" />

| <code>while ''condition'' loop{{indent|2}}''statements''<br />end loop</code>

| <code>loop{{indent|2}}''statements''{{indent|2}}exit when not ''condition''<br />end loop</code>

| <code>for ''index'' in «reverse» ''[first'' .. ''last {{pipe}} discrete_type]'' loop{{indent|2}}''statements''<br />end loop</code>

| <code>for ''item'' of «reverse» ''iterator'' loop{{indent|2}}''statements''<br />end loop</code><br />or<br /><code>(for [all {{pipe}} some] [in {{pipe}} of] ''[first'' .. ''last {{pipe}} discrete_type {{pipe}} iterator]'' => ''predicate'')</code>{{ref|Ada_quantifiers|[b]}}

|-

| rowspan=2| [[ALGOL 68]] || colspan=3 align=center| <code>«for ''index''» «from ''first''» «by ''increment''» «to ''last''» «while ''condition''» do ''statements'' od</code>

Line 2,029 ⟶ 2,025:

|-

| [[APL (programming language)|APL]]

| <code>:While ''condition''{{indent|2}}''statements''<br />:EndWhile</code>

| <code>:Repeat{{indent|2}}''statements''<br />:Until ''condition''</code>

| <code>:For ''var«s»'' :In ''list''{{indent|2}}''statements''<br />:EndFor</code>

| <code>:For ''var«s»'' :InEach ''list''{{indent|2}}''statements''<br />:EndFor</code>

|-

| [[C (programming language)|C]] ([[C99]])

| rowspan=9| {{<code|>instructions}}</code> can be a single statement or a block in the form of: <code>{ ''statements'' }</code><br /><code>while (''condition'') ''instructions''</code>

| rowspan=9| <code>do ''instructions'' while (''condition'');</code>

| rowspan=5| <code>for (''«type» i'' = ''first''; ''i'' <= ''last''; ''i''++) ''instructions''</code>

Line 2,044 ⟶ 2,040:

|-

| [[C++]] (STL)

| <code>«std::»for_each(''start'', ''end'', ''function'')</code><br />Since [[C++11]]:<br /><code>for (''type item'' : ''set'') ''instructions''</code>

|-

| [[C Sharp (programming language)|C#]]

Line 2,052 ⟶ 2,048:

| <code>for (''type item'' : ''set'') ''instructions''</code>

|-

| [[JavascriptJavaScript]]

| <code>for (var ''i'' = ''first''; ''i'' <= ''last''; ''i''++) ''instructions''</code>

| Since [[EcmaScript]] 2015:<ref>{{cite web|url=https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Statements/for...of|title=for...of|work=mozilla.org|access-date=30 January 2017}}</ref>

Line 2,058 ⟶ 2,054:

|-

| [[PHP]]

| <code>foreach (range(''first'', ''last'') as $i) ''instructions''</code><br />or<br /><code>for ($i = ''first''; $i <= ''last''; $i++) ''instructions''</code>

| <code>foreach (''set'' as ''item'') ''instructions''</code><br />or<br /><code>foreach (''set'' as ''key'' => ''item'') ''instructions''</code>

|-

| [[Windows PowerShell]]

Line 2,077 ⟶ 2,073:

| [[Swift (programming language)|Swift]]

| <code>while ''condition'' { ''instructions'' }</code>

| 2.x:<br /><code>repeat { ''instructions'' } while ''condition''</code><br />1.x:<br /><code>do { ''instructions'' } while ''condition''</code>

| <code>for ''i'' = ''first'' ... ''last'' { ''instructions'' }</code><br />or<br /><code>for ''i'' = ''first'' ..< ''last''+1'' { ''instructions'' }</code><br />or<br /><code>for var ''i'' = ''first''; ''i'' <= ''last''; ''i''++ { ''instructions'' }</code>

| <code>for ''item'' in ''set'' { ''instructions'' }</code>

|-

| [[Perl]]

| <code>while (''condition'') { ''instructions'' }</code><br />or<br /><code>until (''notcondition'') { ''instructions'' }</code>

| <code>do { ''instructions'' } while (''condition'')</code><br />or<br /><code>do { ''instructions'' } until (''notcondition'')</code>

| <code>for«each» «$i» (''first'' .. ''last'') { ''instructions'' }</code><br />or<br /><code>for ($i = ''first''; $i <= ''last''; $i++) { ''instructions'' }</code>

| <code>for«each» ''«$item»'' (''set'') { ''instructions'' }</code>

|-

| [[Raku (programming language)|Raku]]

| <code>while ''condition'' { ''instructions'' }</code><br />or<br /><code>until ''notcondition'' { ''instructions'' }</code>

| <code>repeat { ''instructions'' } while ''condition''</code><br />or<br /><code>repeat { ''instructions'' } until ''notcondition''</code>

| <code>for ''first''..''last'' -> $i { ''instructions'' }</code><br />or<br /><code>loop ($i = ''first''; $i <=''last''; $i++) { ''instructions'' }</code>

| <code>for ''set«'' -> ''$item»'' { ''instructions'' }</code>

|-

| [[Ruby (programming language)|Ruby]]

| <code>while ''condition''{{indent|2}}''instructions''<br />end</code><br />or<br /><code>until ''notcondition''{{indent|2}}''instructions''<br />end</code>

| <code>begin{{indent|2}}''instructions''<br />end while ''condition''</code><br />or<br /><code>begin{{indent|2}}''instructions''<br />end until ''notcondition''</code>

| <code>for i in ''first''..''last''{{indent|2}}''instructions''<br />end</code><br />or<br /><code>for i in ''first''...''last+1''{{indent|2}}''instructions''<br />end</code><br />or<br /><code>''first''.{{not a typo|upto}}(''last'') { {{pipe}}i{{pipe}} ''instructions'' }</code>

| <code>for ''item'' in ''set''{{indent|2}}''instructions''<br />end</code><br />or<br /><code>''set''.each { {{pipe}}''item''{{pipe}} ''instructions'' }</code>

|-

| [[Bash shell]]

| <code>while ''condition ;''do{{indent|2}}''instructions''<br />done</code><br />or<br /><code>until ''notcondition ;''do{{indent|2}}''instructions''<br />done</code>

| {{n/a}}

| <code>for ((''i'' = ''first''; ''i'' <= ''last''; ++''i'')) ; do{{indent|2}}''instructions''<br />done</code>

| <code>for ''item'' in ''set ;''do{{indent|2}}''instructions''<br />done</code>

|-

| [[Scala (programming language)|Scala]]

| <code>while (''condition'') { ''instructions'' }</code>

| <code>do { ''instructions'' } while (''condition'')</code>

| <code>for (''i'' <- ''first'' to ''last'' «by 1») { ''instructions'' }</code><br />or<br /><code>''first'' to ''last'' «by 1» foreach (''i'' => { ''instructions'' })</code>

| <code>for (''item'' <- ''set'') { ''instructions'' }</code><br />or<br /><code>''set'' foreach (''item'' => { ''instructions'' })</code>

|-

| [[Smalltalk]]

Line 2,118 ⟶ 2,114:

|-

| [[Common Lisp]]

| <code>(loop{{indent|2}}while ''condition''{{indent|2}}do{{indent|2}}''instructions'')</code><br />or<br /><code>(do () (''notcondition''){{indent|2}}''instructions'')</code>

| <code>(loop{{indent|2}}do{{indent|2}}''instructions''{{indent|2}}while ''condition'')</code>

| <code>(loop{{indent|2}}for i from ''first'' to ''last «by 1»''{{indent|2}}do{{indent|2}}''instructions'')</code><br />or<br /><code>(dotimes (i N){{indent|2}}''instructions'')</code><br />or<br /><code>(do ((i ''first'' {{codett|2=lisp|1=(1+ i))) ((>=i}} ''last''))<br />{{indent|2}}''instructions'')</code>

| <code>(loop{{indent|2}}for ''item'' in ''list''{{indent|2}}do{{indent|2}}''instructions'')</code><br />or<br /><code>(loop{{indent|2}}for ''item'' across ''vector''{{indent|2}}do{{indent|2}}''instructions'')</code><br />or<br /><code>(dolist (''item list''){{indent|2}}''instructions'')</code><br />or<br /><code>(mapc ''function list'')</code><br />or<br /><code>(map ''type function sequence'')</code>

|-

| [[Scheme (programming language)|Scheme]]

| <code>(do () (''notcondition'') ''instructions'')</code><br />or<br /><code>{{codett|2=scheme|(let loop () (if}} ''condition'' (begin ''instructions'' (loop))))</code>

| <code>{{codett|2=scheme|(let loop () (}}''instructions'' (if ''condition'' (loop))))</code>

| <code>(do ((i ''first'' {{codett|2=scheme|1=(+ i 1))) ((>= i}} ''last'')) ''instructions'')</code><br />or<br /><code>{{codett|2=scheme|(let loop ((i}} ''first''{{codett|2=scheme|1)) (if (< i}} ''last'') (begin ''instructions'' {{codett|2=scheme|(loop (+ i 1)))))}}</code>

| <code>{{codett|2=scheme|(for-each (lambda (}}''item'') ''instructions'') ''list'')</code>

|-

| [[ISLISP]]

| <code>(while ''condition instructions'')</code>

| <code>{{codett|2=lisp|1=(tagbody loop}} ''instructions'' (if ''condition'' {{codett|2=lisp|1=(go loop))}}</code>

| <code>{{codett|2=lisp|1=(for ((i}} ''first'' {{codett|2=lisp|1=(+ i 1))) ((>= i}} ''last'')) ''instructions'')</code>

| <code>{{codett|2=lisp|1=(mapc (lambda (}}''item'') ''instructions'') ''list'')</code>

|-

| [[Pascal (programming language)|Pascal]]

| <code>while ''condition'' do begin{{indent|2}}''instructions''<br />end</code>

| <code>repeat{{indent|2}}''instructions''<br />until ''notcondition'';</code>

| <code>for ''i'' := ''first'' «step 1» to ''last'' do begin{{indent|2}}''instructions''<br />end;</code>{{ref|step|[a]}}

| <code>for ''item'' in ''set'' do ''instructions''</code>

|-

| [[Visual Basic (classic)|Visual Basic]]

| rowspan=2| <code>Do While ''condition''{{indent|2}}''instructions''<br />Loop</code><br />or<br /><code>Do Until ''notcondition''{{indent|2}}''instructions''<br />Loop</code><br />or<br /><code>While ''condition''{{indent|2}}''instructions''<br />Wend</code> (Visual Basic .NET uses {{<code|>End While}}</code> instead)

| rowspan=2| <code>Do{{indent|2}}''instructions''<br />Loop While ''condition''</code><br />or<br /><code>Do{{indent|2}}''instructions''<br />Loop Until ''notcondition''</code>

| {{<code|>i}}</code> must be declared beforehand.

<code>For ''i'' = ''first'' To ''last'' «Step ''1»{{indent|2}}instructions''<br />Next i</code>

| <code>For Each ''item'' In ''set''{{indent|2}}''instructions''<br />Next ''item''</code>

|-

| [[Visual Basic .NET]]

| rowspan=2| <code>For i« As ''type»'' = ''first'' To ''last«'' Step ''1»{{indent|2}}instructions''<br />Next« i»</code>{{ref|step|[a]}}

| rowspan=2| <code>For Each ''item«'' As ''type»'' In ''set''{{indent|2}}''instructions''<br />Next''« item»''</code>

|-

| [[Xojo]]

| <code>While ''condition''{{indent|2}}''instructions''<br />Wend</code>

| <code>Do Until ''notcondition''{{indent|2}}''instructions''<br />Loop</code><br />or<br /><code>Do{{indent|2}}''instructions''<br />Loop Until ''notcondition''</code>

|-

| [[Python (programming language)|Python]]

| <code>while ''condition'' :<br />{{keypress|Tab}}''instructions''<br />«else:<br />{{keypress|Tab}}''instructions»''</code>

| {{n/a}}

| Python 3.x:<br /><code>for i in range(''first'', ''last+1''):<br />{{keypress|Tab}}''instructions''<br />«else:<br />{{keypress|Tab}}''instructions»''</code><br />Python 2.x:<br /><code>for i in xrange(''first'', ''last+1''):<br />{{keypress|Tab}}''instructions''<br />«else:<br />{{keypress|Tab}}''instructions»''</code>

| <code>for ''item'' in ''set'':<br />{{keypress|Tab}}''instructions''<br />«else:<br />{{keypress|Tab}}''instructions»''</code>

|-

| [[S-Lang (programming language)|S-Lang]]

| <code>while (''condition'') { ''instructions'' } «then ''optional-block»''</code>

| <code>do { ''instructions'' } while (''condition'') «then ''optional-block»''</code>

Line 2,169 ⟶ 2,165:

|-

| [[Fortran]]

| <code>DO WHILE (''condition''){{indent|2}}''instructions''<br />ENDDO</code>

| <code>DO{{indent|2}}''instructions''{{indent|2}}IF (''condition'') EXIT<br />ENDDO</code>

| <code>DO ''I'' = ''first'',''last''{{indent|2}}''instructions''<br />ENDDO</code>

| {{n/a}}

|-

Line 2,184 ⟶ 2,180:

| {{n/a}}

| <code>for i = ''first'' to ''last'' do ''instructions'' done</code>

| <code>Array.iter (fun ''item'' -> ''instructions'') ''array''</code><br />or<br /><code>List.iter (fun ''item'' -> ''instructions'') ''list''</code>

|-

| [[F Sharp (programming language)|F#]]

| <code>while ''condition'' do<br />{{keypress|Tab}}''instructions''</code>

| {{n/a}}

| <code>for i = ''first'' to ''last'' do <br />{{keypress|Tab}}''instructions''</code>

| <code>for''item'' in ''set'' do<br />{{keypress|Tab}}''instructions''</code><br />or<br /><code>Seq.iter (fun ''item'' -> ''instructions'') ''set''</code>

|-

| [[Standard ML]]

| <code>while ''condition'' do ( ''instructions'' )</code>

| colspan=2 {{n/a}}

| <code>Array.app (fn ''item'' => ''instructions'') ''array''</code><br />or<br /><code>app (fn ''item'' => ''instructions'') ''list''</code>

|-

| [[Haskell (programming language)|Haskell]] ([[Glasgow Haskell Compiler|GHC]])

| colspan=2 {{n/a}}

| <code>Control.Monad.forM_ [''first''..''last''] (\i -> do ''instructions'')</code>

Line 2,203 ⟶ 2,199:

|-

| [[Eiffel (programming language)|Eiffel]]

| colspan=4| <code>from{{indent|2}}''setup''<br />until{{indent|2}}''condition''<br />loop{{indent|2}}''instructions''<br />end</code>

|-

| [[CoffeeScript]]

| <code>while ''condition''{{indent|2}}''expression''</code><br />or<br /><code>''expression'' while ''condition''</code><br />or<br /><code>while ''condition'' then ''expression''</code><br />or<br /><code>until ''condition''{{indent|2}}''expression''</code><br />or<br /><code>''expression'' until ''condition''</code><br />or<br /><code>until ''expression'' then ''condition''</code>

| {{n/a}}

| <code>for ''i'' in [''first''..''last'']{{indent|2}}''expression''</code><br />or<br/ ><code>for ''i'' in [''first''..''last''] then ''expression''</code><br />or<br /><code>''expression'' for ''i'' in [''first''..''last'']</code>

| <code>for ''item'' in ''set''{{indent|2}}''expression''</code><br />or<br /><code>for ''item'' in ''set'' then ''expression''</code><br />or<br /><code>''expression'' for ''item'' in ''set''</code>

|-

| [[COBOL]]

| <code>PERFORM ''procedure-1'' «THROUGH ''procedure-2''» ««WITH» TEST BEFORE» UNTIL ''condition''</code>{{ref|COBOL THRU|[c]}}<br />or<br /><code>{{codett|2=cobolfree|PERFORM ««WITH» TEST BEFORE» UNTIL}} ''condition''{{indent|2}}''expression''<br />END-PERFORM</code>

| <code>PERFORM ''procedure-1'' «THROUGH ''procedure-2''» «WITH» TEST AFTER UNTIL ''condition''</code>{{ref|COBOL THRU|[c]}}<br />or<br /><code>{{codett|2=cobolfree|PERFORM «WITH» TEST AFTER UNTIL}} ''condition''{{indent|2}}''expression''<br />END-PERFORM</code>

| <code>PERFORM ''procedure-1'' «THROUGH ''procedure-2»'' VARYING ''i'' FROM ''first'' BY ''increment'' UNTIL ''i'' > ''last''</code>{{ref|COBOL GREATER THAN|[d]}}<br />or<br /><code>PERFORM VARYING ''i'' FROM ''first'' BY ''increment'' UNTIL ''i'' > ''last''{{indent|2}}''expression''<br />END-PERFORM</code>{{ref|COBOL GREATER THAN|[d]}}

| {{n/a}}

|-

| [[Rust (programming language)|Rust]]

| <code>while ''condition'' { {{indent|2}}''expression''<br />}</code>

| <code>loop { {{indent|2}}''expression''{{indent|4}}if ''condition'' { {{indent|6}}break;{{indent|2}}}<br />}</code>

| <code>for i in ''first''..''last+1'' { {{indent|2}}''expression''<br />}</code><br />or<br /><code>for i in ''first''..=''last'' { {{indent|2}}''expression''<br />}</code>

| <code>for ''item'' in ''set'' { {{indent|2}}''expression''<br />}</code>{{ref|Rust FOREACH|[e]}}<br />or<br /><code>''set''.into_iter().for_each({{pipe}}''item''{{pipe}} expression);</code>{{ref|Rust FOREACH|[e]}}

|}

* {{note|step|a}} "<code>step</code> n" is used to change the loop interval. If "<code>step</code>" is omitted, then the loop interval is 1.

* {{note|Ada_quantifiers|b}} This implements the [[universal quantifier]] ("for all" or "<{{math>\|&forall</math>";}}) as well as the [[existential quantifier]] ("there exists" or "<{{math>\exists</math>"|&exist;}}).

* {{note|COBOL THRU|c}} <code>THRU</code> may be used instead of <code>THROUGH</code>.

* {{note|COBOL GREATER THAN|d}} <{{code>|2=cobolfree|«IS» GREATER «THAN»</code>}} may be used instead of <code>></code>.

* {{note|Rust FOREACH|e}} Type of set expression must implement trait <code>std::iter::IntoIterator</code>.

=== [[Exception handling|Exceptions]] ===

{{furtherFurther|Exception handling syntax}}

{{further|Exception handling syntax}}

{| class="wikitable sortable"

|-

Line 2,243 ⟶ 2,237:

| [[Ada (programming language)|Ada]]<ref name="Ada_RM_2012" />

| <code>raise ''exception_name'' «with ''string_expression»''</code>

| <code>begin{{indent|2}}''statements''<br />exception{{indent|2}}when ''exception_list₁'' <nowiki>=></nowiki> ''statements;''{{indent|2}}when ''exception_list₂'' <nowiki>=></nowiki> ''statements;''<br />''...''{{indent|2}}«when others <nowiki>=></nowiki> ''statements;''»<br />end</code>{{ref|Ada_uncaught_exceptions|[b]}}

| <code>{{codett|2=ada|1=pragma Assert}} («Check <nowiki>=></nowiki>» ''boolean_expression'' ««Message =>» ''string_expression''»)<br />''[function {{pipe}} procedure {{pipe}} entry]'' with{{indent|2}}Pre <nowiki>=></nowiki> ''boolean_expression''{{indent|2}}Post <nowiki>=></nowiki> ''boolean_expression''<br />''any_type'' with Type_Invariant <nowiki>=></nowiki> ''boolean_expression''</code>

|-

| [[APL (programming language)|APL]]

| <code>''«string_expression»'' ⎕SIGNAL ''number_expression''</code>

| <code>:Trap ''number«s»_expression''{{indent|2}}''statements''<br />«:Case ''number«s»_expression''{{indent|2}}''statements''»<br />''...''<br />«:Else ''number«s»_expression''{{indent|2}}''statements''»<br />:EndTrap</code>

| <code>''«string_expression»'' {{codett|⎕SIGNAL 98/⍨~|apl}}''condition''</code>

|-

| [[C (programming language)|C]] ([[C99]])

Line 2,262 ⟶ 2,256:

| [[C Sharp (programming language)|C#]]

| <code>try { ''instructions'' } catch «(''exception« name»'')» { ''instructions'' } ''...'' «finally { ''instructions'' }»</code>

| <code>System.Diagnostics.Debug.Assert(''condition'');</code><br />or<br /><code>System.Diagnostics.Trace.Assert(''condition'');</code>

|-

| [[Java (programming language)|Java]]

Line 2,268 ⟶ 2,262:

| <code>assert ''condition'' «: ''description''»;</code>

|-

| [[JavascriptJavaScript]]

| <code>try { ''instructions'' } catch (''exception'') { ''instructions''} «finally { ''instructions'' }»</code>

| {{dunno}}

Line 2,280 ⟶ 2,274:

| <code>assert(''condition'');</code>

|-

| [[S-Lang (programming language)|S-Lang]]

| <code>try { ''instructions'' } catch ''«exception»'' { ''instructions'' } ''...'' «finally { ''instructions'' }»</code>

| {{dunno}}

|-

| [[Windows PowerShell]]

| <code>trap «[''exception'']» { ''instructions'' } ''... instructions''</code><br />or<br /><code>try { ''instructions'' } catch «[''exception'']» { ''instructions'' } ''...'' «finally { ''instructions'' }»</code>

| <code>{{codett|[Debug]::Assert(|ps1}}''condition'')</code>

|-

| [[Objective-C]]

Line 2,300 ⟶ 2,294:

| [[Perl]]

| rowspan=2| <code>die ''exception'';</code>

| <code>eval { ''instructions'' {{codett|}; if ($@) {|perl}} ''instructions'' }</code>

| {{dunno}}

|-

Line 2,309 ⟶ 2,303:

| [[Ruby (programming language)|Ruby]]

| <code>raise ''exception''</code>

| <code>begin{{indent|2}}''instructions''<br />rescue ''exception''{{indent|2}}''instructions''<br />''...''<br />«else{{indent|2}}''instructions''»<br />«ensure{{indent|2}}''instructions''»<br />end</code>

|

|-

Line 2,318 ⟶ 2,312:

|-

| [[Common Lisp]]

| <code>(error ''"exception"'')</code><br />or<br /><code>(error{{indent|2}}''type''{{indent|2}}''arguments'')</code><br />or<br /><code>(error (make-condition{{indent|2}}''type''{{indent|2}}''arguments''))</code>

| <code>(handler-case{{indent|2}}(progn ''instructions''){{indent|2}}(''exception instructions''){{indent|2}}''...'')</code><br />or<br /><code>(handler-bind{{indent|2}}(''condition''{{indent|4}}(lambda{{indent|4}}''instructions''{{indent|4}}«invoke-restart ''restart args»''))<br />''...'')</code>{{ref|a|[a]}}

| <code>(assert ''condition'')</code><br />or<br /><code>(assert ''condition''{{indent|2}}«(''place''){{indent|2}}''«error»»'')</code><br />or<br /><code>(check-type ''var type'')</code>

|-

| [[Scheme (programming language)|Scheme]] ([[R6RS|R⁶RS]])

Line 2,328 ⟶ 2,322:

|-

| [[ISLISP]]

| <code>(error ''"error-string" objects'')</code><br />or<br /><code>(signal-condition ''condition continuable'')</code>

| <code>(with-handler{{indent|2}}''handler form*''<br />)</code>

| {{dunno}}

|-

Line 2,339 ⟶ 2,333:

| [[Visual Basic (classic)|Visual Basic]]

| <code>Err.Raise ''ERRORNUMBER''</code>

| <code>{{codett|2=vbnet|With New}} ''Try''{{codett|2=vbnet|: On Error Resume Next}}{{indent|2}}''OneInstruction<br />.Catch''{{codett|2=vbnet|: On Error GoTo 0: Select Case}} ''.Number''{{indent|2}}Case ''SOME_ERRORNUMBER''{{indent|4}}''instructions''<br />{{codett|2=vbnet|End Select: End With}}</code><syntaxhighlight lang="vbnet">

'*** Try class ***

Private mstrDescription As String

Line 2,355 ⟶ 2,349:

Public Property Get Description() As String

Description = mstrDescription

End Property</syntaxhighlight><ref>{{cite web|url=https://sites.google.com/site/truetryforvisualbasic/|title=Try-Catch for VB|work=google.com|access-date=30 January 2017|archive-date=16 April 2016|archive-url=https://web.archive.org/web/20160416093023/https://sites.google.com/site/truetryforvisualbasic/|url-status=dead}}</ref>

| <code>Debug.Assert ''condition''</code>

|-

| [[Visual Basic .NET]]

| <code>Throw ''exception''</code><br />or<br /><code>Error ''errorcode''</code>

| <code>Try{{indent|2}}''instructions''<br />Catch« ''name'' As ''exception''»« When ''condition''»{{indent|2}}''instructions''<br />''...''<br />«Finally{{indent|2}}''instructions''»<br />End Try</code>

| <code>System.Diagnostics.<wbr/code><code>Debug.Assert(''condition'')</code><br />or<br /><code>System.Diagnostics.<wbr/>Trace.Assert(''condition'')</code>

|-

| [[Xojo]]

| <code>Raise ''exception''</code>

| <code>Try{{indent|2}}''instructions''<br />Catch ''«exception»''{{indent|2}}''instructions''<br />''...''<br />«Finally{{indent|2}}''instructions''»<br />End Try</code>

| {{n/a}}

|-

| [[Python (programming language)|Python]]

| <code>raise ''exception''</code>

| <code>try:<br />{{keypress|Tab}}''instructions''<br />except ''«exception»'':<br />{{keypress|Tab}}''instructions''<br />''...''<br />«else:<br />{{keypress|Tab}}''instructions''»<br />«finally:<br />{{keypress|Tab}}''instructions»''</code>

| <code>assert ''condition''</code>

|-

Line 2,387 ⟶ 2,381:

|-

| [[F Sharp (programming language)|F#]]

| <code>try ''expression'' with ''pattern'' -> ''expression ...''</code><br />or<br /><code>try ''expression'' finally ''expression''</code>

|-

| [[Standard ML]]

Line 2,394 ⟶ 2,388:

|

|-

| [[Haskell (programming language)|Haskell]] ([[Glasgow Haskell Compiler|GHC]])

| <code>throw ''exception''</code><br />or<br /><code>throwError ''expression''</code>

| <code>catch ''tryExpression catchExpression''</code><br />or<br /><code>catchError ''tryExpression catchExpression''</code>

| <code>assert ''condition expression''</code>

|-

| [[COBOL]]

| <code>{{codett|2=cobolfree|RAISE «EXCEPTION»}} ''exception''</code>

| <code>{{codett|2=cobolfree|USE «AFTER» EXCEPTION OBJECT}} ''class-name''.</code><br />or<br /><code>{{codett|2=cobolfree|USE «AFTER» EO}} ''class-name''.</code><br />or<br /><code>{{codett|2=cobolfree|USE «AFTER» EXCEPTION CONDITION}} ''exception-name'' «FILE ''file-name»''.</code><br />or<br /><code>{{codett|2=cobolfree|USE «AFTER» EC}} ''exception-name'' «FILE ''file-name»''.</code>

| {{n/a}}

|-

Line 2,409 ⟶ 2,403:

|}

* {{note|common lisp restarts|a}} Common Lisp allows {{<code|>with-simple-restart}}</code>, {{<code|>restart-case}}</code> and {{<code|>restart-bind}}</code> to define restarts for use with {{<code|>invoke-restart}}</code>. Unhandled conditions may cause the implementation to show a restarts menu to the user before unwinding the stack.

* {{note|Ada_uncaught_exceptionsAda uncaught exceptions|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 ===

{| class="wikitable sortable"

|-

Line 2,433 ⟶ 2,426:

| <code>''value'' exit;</code> ...

| <code>do ''statements;'' skip exit; ''label: statements'' od</code>

| {{<code|>label:}}</code> ...

| <code>go to ''label; ...''<br />goto ''label; ...<br />label; ...''</code>

| <code>yield(value)</code>

([[Callback (computer science)|Callback]])<ref>{{cite web|url=http://rosettacode.org/wiki/Prime_decomposition#ALGOL_68|title=Prime decomposition – Rosetta Code|work=rosettacode.org|access-date=30 January 2017}}</ref>

Line 2,442 ⟶ 2,435:

| <code>:Continue</code>

| <code>''label'':</code>

| <code>→''label''</code><br />or<br /><code>:GoTo ''label''</code>

| {{n/a}}

|-

Line 2,467 ⟶ 2,460:

|

|-

| [[JavascriptJavaScript]]

| <code>yield ''value«;»''</code>

|-

Line 2,504 ⟶ 2,497:

|-

| [[Common Lisp]]

| <code>(return)</code><br />or<br /><code>(return-from ''block'')</code><br />or<br /><code>(loop-finish)</code>

|

| <code>(tagbody ''tag''{{indent|2}}''...''{{indent|2}}''tag''<br />''...'')</code>

| <code>(go ''tag'')</code>

|

Line 2,520 ⟶ 2,513:

| <code>(return-from ''block'')</code>

|

| <code>(tagbody ''tag''{{indent|2}}''...''{{indent|2}}''tag''<br />''...'')</code>

| <code>(go ''tag'')</code>

|

Line 2,535 ⟶ 2,528:

|-

| [[Visual Basic (classic)|Visual Basic]]

| rowspan=3| <code>Exit ''block''</code>Alternatively, for methods,<br />{{<code|>Return}}</code>

| {{n/a}}

| rowspan=3| <code>''label'':</code>

Line 2,559 ⟶ 2,552:

|

|-

| [[S-Lang (programming language)|S-Lang]]

| <code>break;</code>

| <code>continue;</code>

Line 2,569 ⟶ 2,562:

| <code>EXIT</code>

| <code>CYCLE</code>

| {{<code|>label}}</code>{{ref|Fortran label|[b]}}

| <code>GOTO ''label''</code>

| {{n/a}}

Line 2,597 ⟶ 2,590:

|

|-

| [[Haskell (programming language)|Haskell]] ([[Glasgow Haskell Compiler|GHC]])

|

|-

Line 2,611 ⟶ 2,604:

== [[Subroutine|Function]]s ==

See ''[[Reflectionreflective (computer science)|reflectionprogramming]]'' for calling and declaring functions by strings.

{{sort-under}}

See [[Reflection (computer science)|reflection]] for calling and declaring functions by strings.

{| class="wikitable sortable sort-under"

{| class="wikitable sortable"

|- valign="top"

!

Line 2,644 ⟶ 2,636:

| rowspan="5" | <code>[[void type|void]] ''foo''(''«parameters»'') { ''instructions'' }</code>

| rowspan="5" | <code>''type'' ''foo''(''«parameters»'') { ''instructions ...'' return ''value''; }</code>

| rowspan=3| <code>''«global declarations»''<br />{{codett|2=c|int main(«int argc, char *argv[]»)}} { {{indent|2}}''instructions''<br />}</code>

|- valign="top"

| [[Objective-C]]

Line 2,651 ⟶ 2,643:

|- valign="top"

| [[Java (programming language)|Java]]

| <code>{{codett|2=java|public static void main(String[] args)}} { ''instructions'' }</code><br />or<br /><code>{{codett|2=java|public static void main(String}}[[variadic function|...]] args) { ''instructions'' }</code>

|- valign="top"

| [[D (programming language)|D]]

| <code>{{codett|2=d|int main(«char[][] args»)}} { ''instructions''}</code><br />or<br /><code>{{codett|2=d|int main(«string[] args»)}} { ''instructions''}</code><br />or<br /><code>{{codett|2=d|void main(«char[][] args»)}} { ''instructions''}</code><br />or<br /><code>{{codett|2=d|void main(«string[] args»)}} { ''instructions''}</code>

|- valign="top"

| [[C Sharp (programming language)|C#]]

Line 2,661 ⟶ 2,653:

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

<code>[[void type|void]] foo(''«parameters»'') => ''expression'';</code>

| <{{code>|2=c#|static void Main(«string[] args») method_body</code>}}<br />May instead return {{<code|>int}}</code>.<br />(starting with C# 7.1:) May return {{<code|>Task}}</code> or {{code|2=c#|Task<int>}}, and if so, may be {{<code|>async}}</code>.

|- valign="top"

| [[JavascriptJavaScript]]

| <code>function foo(''«parameters»'') { ''instructions'' }</code><br />or<br /><code>{{codett|2=javascript|1=var foo = function (}}''«parameters»'') { ''instructions'' }</code><br />or<br /><code>{{codett|2=javascript|1=var foo = new Function (}}''"«parameter»"'', ''...'', ''"«last parameter»"'' "''instructions''");</code>

| <code>function foo(''«parameters»'') { ''instructions ...'' return ''value''; }</code>

| {{n/a}}

Line 2,680 ⟶ 2,672:

| [[Common Lisp]]

| rowspan=3| <code>(foo ''«parameters»'')</code>

| <code>([[defun]] foo (''«parameters»''){{indent|2}}''instructions'')</code><br />or<br /><code>{{codett|2=lisp|1=(setf (symbol-function <nowiki>'</nowiki>}}''symbol''){{indent|2}}''function'')</code>

| <code>([[defun]] foo (''«parameters»''){{indent|2}}''...{{indent|2}}value'')</code>

| rowspan=3 {{n/a}}

|- valign="top"

| [[Scheme (programming language)|Scheme]]

| <code>(define (foo ''parameters'') ''instructions'')</code><br />or<br /><code>(define foo ([[anonymous function|lambda]] (''parameters'') ''instructions''))</code>

| <code>(define (foo ''parameters'') ''instructions... return_value'')</code><br />or<br /><code>(define foo ([[anonymous function|lambda]] (''parameters'') ''instructions... return_value''))</code>

|- valign="top"

| [[ISLISP]]

Line 2,694 ⟶ 2,686:

| [[Pascal (programming language)|Pascal]]

| <code>foo«(''parameters'')»</code>

| <code>procedure foo«(''parameters'')»; «forward;»{{ref|forward declaration|[a]}}<br />«label{{indent|2}}''label declarations''»<br />«const{{indent|2}}''constant declarations''»<br />«type{{indent|2}}''type declarations''»<br />«var{{indent|2}}''variable declarations»<br />«local function declarations»''<br />begin{{indent|2}}''instructions''<br />end;</code>

| <code>function foo«(''parameters'')»: ''type''; «forward;»{{ref|forward declaration|[a]}}<br />«label{{indent|2}}''label declarations''»<br />«const{{indent|2}}''constant declarations''»<br />«type{{indent|2}}''type declarations''»<br />«var{{indent|2}}''variable declarations»<br />«local function declarations»''<br />begin{{indent|2}}''instructions'';{{indent|2}}foo := ''value''<br />end;</code>

| <code>program ''name'';<br />«label{{indent|2}}''label declarations''»<br />«const{{indent|2}}''constant declarations''»<br />«type{{indent|2}}''type declarations''»<br />«var{{indent|2}}''variable declarations»<br />«function declarations»''<br />begin{{indent|2}}''instructions''<br />end.</code> <!-- somewhat of a technicality -->

|- valign="top"

| [[Visual Basic (classic)|Visual Basic]]

| rowspan=3| <code>Foo(''«parameters»'')</code>

| rowspan=3| <code>Sub Foo«(''parameters'')»{{indent|2}}''instructions''<br />End Sub</code>

| <code>Function Foo«(''parameters'')»« As'' type»''{{indent|2}}''instructions''{{indent|2}}Foo = ''value''<br />End Function</code>

| <code>Sub Main(){{indent|2}}''instructions''<br />End Sub</code>

|- valign="top"

| [[Visual Basic .NET]]

| rowspan=2| Same as above; alternatively:

<code>Function Foo«(''parameters'')»« As ''type»''{{indent|2}}''instructions''{{indent|2}}Return ''value''<br />End Function</code><br />The {{<code|>As}}</code> clause is not required if {{<code|>Option Strict}}</code> is off. A type character may be used instead of the {{<code|>As}}</code> clause.<br />If control exits the function without a return value having been explicitly specified, the function returns the default value for the return type.

| rowspan=2| <code>{{codett|2=vbnet|Sub Main(««ByVal »args() As String»)}}{{indent|2}}''instructions''<br />End Sub</code>or<br /><code>{{codett|2=vbnet|Function Main(««ByVal »args() As String») As Integer}}{{indent|2}}''instructions''<br />End Function</code>

|- valign="top"

| [[Xojo]]

Line 2,713 ⟶ 2,705:

| [[Python (programming language)|Python]]

| <code>foo(''«parameters»'')</code>

| <code>def foo(''«parameters»''):<br />{{keypress|Tab}}''instructions''</code>

| <code>def foo(''«parameters»''):<br />{{keypress|Tab}}''instructions''<br />{{keypress|Tab}}return ''value''</code>

| {{n/a}}

|- valign="top"

| [[S-Lang (programming language)|S-Lang]]

| <code>foo(''«parameters» «;qualifiers»'')</code>

| <code>define foo (''«parameters»'') { ''instructions'' }</code>

Line 2,724 ⟶ 2,716:

|- valign="top"

| [[Fortran]]

| <code>foo (''«arguments»'')<br />CALL sub_foo (''«arguments»'')</code>{{ref|Fortran arguments|[c]}}

| <code>SUBROUTINE sub_foo (''«arguments»''){{indent|2}}''instructions<br />''END SUBROUTINE</code>{{ref|Fortran arguments|[c]}}

| <code>''type'' FUNCTION foo (''«arguments»''){{indent|2}}''instructions''{{indent|2}}''...''{{indent|2}}''foo'' = ''value''<br />END FUNCTION</code>{{ref|Fortran arguments|[c]}}

| <code>PROGRAM ''main''{{indent|2}}''instructions''<br />END PROGRAM</code>

|- valign="top"

| [[Forth (programming language)|Forth]]

| <code>''«parameters» ''FOO</code>

| <code>{{codett|2=forth|: FOO « stack effect comment:}} ('' before'' -- ) »{{indent|2}}''instructions''<br />;</code>

| <code>{{codett|2=forth|: FOO « stack effect comment:}} ('' before'' -- ''after'' ) »{{indent|2}}''instructions''<br />;</code>

| {{n/a}}

|- valign="top"

Line 2,742 ⟶ 2,734:

|- valign="top"

| [[Perl]]

| <code>foo(''«parameters»'')</code><br />or<br /><code>&foo«(''parameters'')»</code>

| <code>{{codett|2=perl|sub foo { «my (}}''parameters'') = @_;» ''instructions ''}</code>

| <code>{{codett|2=perl|sub foo { «my (}}''parameters'') = @_;» ''instructions''... «return» ''value''; }</code>

|- valign="top"

| [[Raku (programming language)|Raku]]

| <code>foo(''«parameters»'')</code><br />or<br /><code>&foo«(''parameters'')»</code>

| <code>{{codett|2=raku|«multi »sub foo(}}''parameters'') { ''instructions'' }</code>

| <code>«our «''«type''» »{{codett|2=raku|«''multi »sub foo(}}''parameters'') { ''instructions ...'' «return» ''value''; }</code>

|- valign="top"

| [[Ruby (programming language)|Ruby]]

| <code>foo«(''parameters'')»</code>

| <code>def foo«(''parameters'')»{{indent|2}}''instructions''<br />end</code>

| <code>def foo«(''parameters'')»{{indent|2}}''instructions''{{indent|2}}«return» ''value''<br />end</code>

|- valign="top"

| [[Rust (programming language)|Rust]]

Line 2,766 ⟶ 2,758:

| <code>def ''foo''«(''parameters'')»«: Unit =» { ''instructions'' }</code>

| <code>def ''foo''«(''parameters'')»«: ''type»'' = { ''instructions ...'' «return» ''value'' }</code>

| <code>{{codett|2=scala|1=def main(args: Array[String])}} { ''instructions'' }</code>

|- valign="top"

| [[Windows PowerShell]]

| <code>foo ''«parameters»''</code>

| <code>function ''foo'' { ''instructions'' };</code><br />or<br /><code>function ''foo'' { «param(''parameters'')» ''instructions'' }</code>

| <code>function ''foo'' «(''parameters'')» { ''instructions ...'' return ''value'' };</code><br />or<br /><code>function foo { «param(''parameters'')» ''instructions ...'' return ''value'' }</code>

| rowspan=4 {{n/a}}

|- valign="top"

| rowspan=2| [[Bash shell]]

| rowspan=2| <code>foo ''«parameters»''</code>

| <code>function foo {{{indent|2}}''instructions''<br />}</code><br />or<br /><code>foo () {{{indent|2}}''instructions''<br />}</code>

| <code>function foo {{{indent|2}}''instructions''{{indent|2}}return ''«exit_code»''<br />}</code><br />or<br /><code>foo () { {{indent|2}}''instructions''{{indent|2}}return ''«exit_code»''<br />}</code>

|- valign="top"

| colspan=2|

Line 2,793 ⟶ 2,785:

|- valign="top"

| [[F Sharp (programming language)|F#]]

| <code>{{codett|2=f#|[<EntryPoint>] let main args}} ='' instructions''</code>

|- valign="top"

| [[Standard ML]]

Line 2,800 ⟶ 2,792:

|

|- valign="top"

| [[Haskell (programming language)|Haskell]]

| <code>foo ''parameters'' = do<br />{{keypress|Tab}}''instructions''</code>

| <code>foo ''parameters'' = ''return_value''</code><br />or<br /><code>foo ''parameters'' = do<br />{{keypress|Tab}}''instructions''<br />{{keypress|Tab}}return ''value''</code>

| <code>«main :: IO ()»<br />main = do ''instructions''</code>

|- valign="top"

| [[Eiffel (programming language)|Eiffel]]

Line 2,813 ⟶ 2,805:

| rowspan=2| [[CoffeeScript]]

| <code>foo()</code>

| <{{code>|2=coffeescript|1=foo = <nowiki>-></nowiki></code>}}

| <code>{{codett|2=coffeescript|1=foo = <nowiki>-></nowiki>}} ''value''</code>

| rowspan=2 {{n/a}}

|- valign="top"

| <code>foo ''parameters''</code>

| <{{code>|2=coffeescript|1=foo = <nowiki>() -></nowiki></code>}}

| <code>foo = ( ''parameters'' ) <nowiki>-></nowiki> ''value''</code>

|- valign="top"

| rowspan=2 | [[COBOL]]

| <code>CALL "''foo''" «USING ''parameters»{{indent|2}}«exception-handling»<br />«''END-CALL''»''</code>{{ref|COBOL calling programs|[d]}}

| <code>«IDENTIFICATION DIVISION.»<br />PROGRAM-ID. ''foo''.''<br />«other divisions...»<br />''PROCEDURE DIVISION ''«''USING ''parameters»''.''{{indent|2}}instructions''.</code>

| rowspan=2 | <code>«IDENTIFICATION DIVISION.»<br />PROGRAM-ID/FUNCTION-ID. ''foo''.<br />«''other divisions...''»<br />DATA DIVISION.<br />«''other sections...''»<br />LINKAGE SECTION.<br />«''parameter definitions...''»<br />''variable-to-return definition''<br />«''other sections...''»<br />PROCEDURE DIVISION «USING ''parameters»'' RETURNING ''variable-to-return''.{{indent|2}}''instructions''.</code>

| rowspan=2 {{n/a}}

|-

Line 2,831 ⟶ 2,823:

|}

* {{note|forward declaration|a}} Pascal requires "{{<code|>forward;}}</code>" for [[forward declaration]]s.

* {{note|root class and feature|b}} Eiffel allows the specification of an application's root class and feature.

* {{note|Fortran arguments|c}} In Fortran, function/subroutine parameters are called arguments (since {{<code|>PARAMETER}}</code> is a language keyword); the {{<code|>CALL}}</code> keyword is required for subroutines.

* {{note|COBOL calling programs|d}} Instead of using {{<code|>"foo"}}</code>, a string variable may be used instead containing the same value.

== [[Type conversion]]s{{anchor|Data conversions}} ==

Where ''string'' is a signed decimal number:

{| class="wikitable sortable sort-under"

{| class="wikitable sortable"

|-

!

Line 2,859 ⟶ 2,849:

| colspan=5 align=center| With prior declarations and association of: <code>string ''buf := "12345678.9012e34 ";'' file ''proxy; associate(proxy, buf);''</code>

|-

| {{<code|>get(proxy, ivar);}}</code>

| {{<code|>get(proxy, livar);}}</code>

| {{<code|>get(proxy, rvar);}}</code>

| {{<code|>put(proxy, ival);}}</code>

| {{<code|>put(proxy, rval);}}</code>

|-

| {{<code|>getf(proxy, ($g$, ivar));}}</code><br />or<br />{{<code|>getf(proxy, ($dddd$, ivar));}}</code>

| {{<code|>getf(proxy, ($g$, livar));}}</code><br />or<br />{{<code|>getf(proxy, ($8d$, livar));}}</code>

| {{<code|>getf(proxy, ($g$, rvar));}}</code><br />or<br />{{<code|>getf(proxy, ($8d.4dE2d$, rvar));}}</code>

| {{<code|>putf(proxy, ($g$, ival));}}</code><br />or<br />{{<code|>putf(proxy, ($4d$, ival));}}</code>

| {{<code|>putf(proxy, ($g(width, places, exp)$, rval));}}</code><br />or<br />{{<code|>putf(proxy, ($8d.4dE2d$, rval));}}</code>

|-

| [[APL (programming language)|APL]]

Line 2,889 ⟶ 2,879:

| <code>''long'' = [''string'' longLongValue];</code>

| <code>''float'' = [''string'' doubleValue];</code>

| <code>''string'' = {{codett|2=objc|[NSString stringWithFormat<wbr/>:@"%i",}} ''integer''];</code>

| <code>''string'' = {{codett|2=objc|[NSString stringWithFormat<wbr/>:@"%f",}} ''float''];</code>

|-

| [[C++]] (STL)

Line 2,911 ⟶ 2,901:

| <code>''integer'' = std.conv.to!int<wbr/>(''string'')</code>

| <code>''long'' = std.conv.to!long<wbr/>(''string'')</code>

| <code>''float'' = std.conv.to!float<wbr/>(''string'')</code><br /><code>''double'' = std.conv.to!double<wbr />(''string'')</code>

| colspan=2| <code>''string'' = std.conv.to!string<wbr/>(''number'')</code>

|-

Line 2,917 ⟶ 2,907:

| <code>''integer'' = Integer.parseInt<wbr/>(''string'');</code>

| <code>''long'' = Long.parseLong<wbr/>(''string'');</code>

| <code>''float'' = Float.parseFloat<wbr/>(''string'');</code><br /><code>''double'' = Double.parseDouble<wbr/>(''string'');</code>

| <code>''string'' = Integer.toString<wbr/>(''integer'');</code><br /><code>''string'' = String.valueOf<wbr />(''integer'');</code>

| <code>''string'' = Float.toString<wbr/>(''float'');</code><br /><code>''string'' = Double.toString<wbr />(''double'');</code>

|-

| [[JavascriptJavaScript]]{{ref|JavaScript's technicalities|[a]}}

| colspan=2| <code>''integer'' = parseInt(''string'');</code>

| <code>''float'' = parseFloat(''string'');</code><br /><code>''float'' = new Number (''string'');</code><br /><code>''float'' = Number (''string'');</code><br /><code>''float'' = +''string;''</code>

| colspan=2| <code>''string'' = ''number''.toString ();</code><br /><code>''string'' = String (''number'');</code><br /><code>''string'' = ''number''+"";</code><br /><code>''string'' = `${''number''}`</code>

|-

| [[Go (programming language)|Go]]

| <code>''integer'', ''error'' = strconv.Atoi(''string'')<br />''integer'', ''error'' = strconv.ParseInt<wbr/>(''string'', 10, 0)</code>

| <code>''long'', ''error'' = strconv.ParseInt<wbr/>(''string'', 10, 64)</code>

| <code>''float'', ''error'' = strconv.ParseFloat<wbr/>(''string'', 64)</code>

| <code>''string'' = strconv.Itoa(''integer'')</code><br /><code>''string'' = strconv.FormatInt<wbr />(''integer'', 10)</code><br /><code>''string'' = fmt.Sprint(''integer'')</code>

| <code>''string'' = strconv.FormatFloat<wbr/>(''float'')</code><br /><code>''string'' = fmt.Sprint<wbr />(''float'')</code>

|-

| [[Rust (programming language)|Rust]]{{ref|Rust type conversion|[d]}}

| <code>''string''.parse::<i32>()</code><br /><code>i32::from_str(''string'')</code>

| <code>''string''.parse::<i64>()</code><br /><code>i64::from_str(''string'')</code>

| <code>''string''.parse::<f64>()</code><br /><code>f64::from_str(''string'')</code>

| <code>''integer''.to_string()</code>

| <code>''float''.to_string()</code>

Line 2,964 ⟶ 2,954:

| <code>''integer'' = CInt(''string'')</code>

| <code>''long'' = CLng(''string'')</code>

| <code>''float'' = CSng(''string'')<br />''double'' = CDbl(''string'')</code>

| <code>''string'' = CStr(''number'')</code>

|

|-

| [[Visual Basic .NET]]<br />(can use both VB syntax above and .NET methods shown right)

| <code>''integer'' = Integer.Parse<wbr />(''string'')</code>

| <code>''long'' = Long.Parse<wbr />(''string'')</code>

| <code>''float'' = Single.Parse<wbr />(''string'')</code><br /><code>''double'' = Double.Parse<wbr />(''string'')</code>

| colspan="2" | <code>''string'' ='' number''<wbr />.ToString()</code>

|-

Line 2,977 ⟶ 2,967:

| <code>''integer'' = Val(''string'')</code>

| <code>''long'' = Val(''string'')</code>

| <code>''double'' = Val(''string'')</code><br /><code>''double'' = CDbl(''string'')</code>

| colspan=2| <code>''string'' = CStr(''number'')</code><br />or<br /><code>''string'' = Str(''number'')</code>

|-

| [[Python (programming language)|Python]]

Line 2,986 ⟶ 2,976:

| colspan=2| <code>''string'' = str(''number'')</code>

|-

| [[S-Lang (programming language)|S-Lang]]

| <code>''integer'' = [[atoi]](''string'');</code>

| <code>''long'' = [[atol (programming)|atol]](''string'');</code>

Line 2,997 ⟶ 2,987:

|-

| [[PHP]]

| colspan=2| <code>''integer'' = intval(''string'');</code><br />or<br /><code>''integer'' = (int)''string'';</code>

| <code>''float'' = floatval(''string'');</code><br /><code>''float'' = (float)''string'';</code>

| colspan=2| <code>''string'' = "''$number''";</code><br />or<br /><code>''string'' = strval(''number'');</code><br />or<br /><code>''string'' = (string)''number'';</code>

|-

| [[Perl]]{{ref|Perl's technicalities|[b]}}

Line 3,010 ⟶ 3,000:

|-

| [[Ruby (programming language)|Ruby]]

| colspan=2| <code>''integer'' = ''string''.to_i</code><br />or<br /><code>''integer'' = Integer(''string'')</code>

| <code>''float'' = ''string''.to_f</code><br /><code>''float'' = Float(''string'')</code>

| colspan=2| <code>''string'' = ''number''.to_s</code>

|-

Line 3,029 ⟶ 3,019:

| <code>''long'' = [long]''string''</code>

| <code>''float'' = [float]''string''</code>

| colspan=2| <code>''string'' = [string]''number'';</code><br />or<br /><code>''string'' = "''number''";</code><br />or<br /><code>''string'' = (''number'').ToString()</code>

|-

| [[OCaml]]

Line 3,051 ⟶ 3,041:

| <code>val ''string'' = Real<wbr/>.toString ''float''</code>

|-

| [[Haskell (programming language)|Haskell]] ([[Glasgow Haskell Compiler|GHC]])

| colspan=3| <code>''number'' = read ''string''</code>

| colspan=2| <code>''string'' = show ''number''</code>

|-

| [[COBOL]]

| colspan=3 | <code>{{codett|2=cobolfree|MOVE «FUNCTION» NUMVAL(}}''string''){{ref|COBOL's NUMVAL alternatives|[c]}} TO ''number''</code>

| colspan=2 | <code>MOVE ''number'' TO ''numeric-edited''</code>

|-

Line 3,063 ⟶ 3,053:

* {{note|JavaScript's technicalities|a}} JavaScript only uses floating point numbers so there are some technicalities.<ref name="Javascript numbers" />

* {{note|Perl's technicalities|b}} Perl doesn't have separate types. Strings and numbers are interchangeable.

* {{note|COBOL's NUMVAL alternatives|c}} {{<code|>NUMVAL-C}}</code> or {{<code|>NUMVAL-F}}</code> may be used instead of {{<code|>NUMVAL}}</code>.

* {{note|Rust type conversion}} [https://doc.rust-lang.org/stable/std/primitive.str.html#method.parse {{<code|>str::parse}}</code>] is available to convert any type that has an implementation of the [https://doc.rust-lang.org/stable/std/str/trait.FromStr.html {{<code|>std::str::FromStr}}</code>] trait. Both {{<code|>str::parse}}</code> and [https://doc.rust-lang.org/stable/std/str/trait.FromStr.html#tymethod.from_str {{<code|>FromStr::from_str}}</code>] return a [[result type|{{<code|>Result}}</code>]] that contains the specified type if there is no error. The [[turbofish]] ({{<code|><nowiki>::<_>}}</nowiki></code>) on {{<code|>str::parse}}</code> can be omitted if the type can be inferred from context.

== [[Standard streams|Standard stream I/O]] ==

{| class="wikitable sortable"

|-

Line 3,084 ⟶ 3,073:

|-

| [[ALGOL 68]]

| <code>readf((''$format$'', ''x''));</code><br />or<br /><code>getf(stand in, (''$format$'', ''x''));</code>

| <code>[[printf]]((''$format$'', ''x''));</code><br />or<br /><code>putf(stand out, (''$format$'', ''x''));</code>

| <code>putf(stand error, (''$format$'', ''x''));</code>{{ref|ALGOL Unformatted|[a]}}

|-

Line 3,094 ⟶ 3,083:

|-

| [[C (programming language)|C]] ([[C99]])

| <code>[[scanf]](''format'', &''x'');</code><br />or<br /><code>[[fscanf]](stdin, ''format'', &''x'');</code>{{ref|more c input|[b]}}

| <code>[[printf]](''format'', ''x'');</code><br />or<br /><code>[[fprintf]](stdout, ''format'', ''x'');</code>{{ref|more c output|[c]}}

| <code>[[fprintf]](stderr, ''format'', ''x'');</code>{{ref|more c error output|[d]}}

|-

Line 3,104 ⟶ 3,093:

|-

| [[C++]]

| <code>[[iostream|«std::»cin]] >> ''x'';</code><br />or<br /><code>«std::»getline(«std::»cin, ''str'');</code>

| <code>[[iostream|«std::»cout]] << ''x'';</code>

| <code>[[iostream|«std::»cerr]] << ''x'';</code><br />or<br /><code>[[iostream|«std::»clog]] << ''x'';</code>

|-

| [[C Sharp (programming language)|C#]]

| <code>''x'' = Console.Read();</code><br />or<br /><code>''x'' = Console.ReadLine();</code>

| <code>Console.Write(''«format'', »''x'');</code><br />or<br /><code>Console.WriteLine(''«format'', »''x'');</code>

| <code>Console.Error<wbr/>.Write(''«format'', »''x'');</code><br />or<br /><code>Console.Error<wbr/>.WriteLine(''«format'', »''x'');</code>

|-

| [[D (programming language)|D]]

| <code>''x'' = std.stdio.readln()</code>

| <code>std.stdio.write(''x'')</code><br />or<br /><code>std.stdio.writeln(''x'')</code><br />or<br /><code>std.stdio.writef(''format'', ''x'')</code><br />or<br /><code>std.stdio.writefln(''format'', ''x'')</code>

| <code>stderr.write(''x'')</code><br />or<br /><code>stderr.writeln(''x'')</code><br />or<br /><code>std.stdio<wbr/>.writef(stderr, ''format'', ''x'')</code><br />or<br /><code>std.stdio<wbr/>.writefln(stderr, ''format'', ''x'')</code>

|-

| [[Java (programming language)|Java]]

| {{code|2<syntaxhighlight lang="java|1=" inline>x = System.in.read();}}</syntaxhighlight><br />or<br />{{code|2<syntaxhighlight lang="java|1=" inline>x = new Scanner(System.in).nextInt();}}</syntaxhighlight><br />or<br />{{code|2<syntaxhighlight lang="java|1=" inline>x = new Scanner(System.in).nextLine();}}</syntaxhighlight>

| <code>System.out.print(''x'');</code><br />or<br /><code>System.out.[[printf]](''format'', ''x'');</code><br />or<br /><code>System.out.println(''x'');</code>

| <code>System.err.print(''x'');</code><br />or<br /><code>System.err.[[printf]](''format'', ''x'');</code><br />or<br /><code>System.err.println(''x'');</code>

|-

| [[Go (programming language)|Go]]

| <code>fmt.Scan(&''x'')</code><br />or<br /><code>fmt.[[Scanf]](''format'', &''x'')</code><br />or<br />{{code|2<syntaxhighlight lang="go|1=" inline>x = bufio.NewReader(os.Stdin).ReadString('\n')}}</syntaxhighlight>

| <code>fmt.Println(''x'')</code><br />or<br /><code>fmt.[[Printf]](''format'', ''x'')</code>

| <code>fmt.Fprintln(os{{Not a typo|.}}Stderr, x)</code><br />or<br /><code>fmt.[[Fprintf]](os{{Not a typo|.}}Stderr, ''format'', ''x'')</code>

|-

| [[Swift (programming language)|Swift]]

| <code>''x'' = readLine()</code> (2.x)

| <code>print(''x'')</code> (2.x)<br /><code>println(''x'')</code> (1.x)

|

|-

| [[JavascriptJavaScript]]<br /><small>[[Client-side JavaScript|Web Browser implementation]]</small>

|

| <code>document.write(''x'')</code>

|

|-

| [[JavascriptJavaScript]]<br /><small>[[Active Server Pages]]</small>

|

| <code>Response.Write(''x'')</code>

|

|-

| [[JavascriptJavaScript]]<br /><small>[[Windows Script Host]]</small>

| <code>''x'' = WScript.StdIn.Read(''chars'')</code><br />or<br /><code>''x'' = WScript.StdIn.ReadLine()</code>

| <code>WScript.Echo(''x'')</code><br />or<br /><code>WScript.StdOut.Write(''x'')</code><br />or<br /><code>WScript.StdOut.WriteLine(''x'')</code>

| <code>WScript.StdErr.Write(''x'')</code><br />or<br /><code>WScript.StdErr.WriteLine(''x'')</code>

|-

| [[Common Lisp]]

| {{code|<syntaxhighlight lang="lisp" inline>(setf x (read-line))|lisp}}</syntaxhighlight>

| <code>(princ ''x'')</code><br />or<br /><code>(format t ''format x'')</code>

| {{code|<syntaxhighlight lang="lisp" inline>(princ x *error-output*)|lisp}}</syntaxhighlight><br />or<br /><code>{{codett|(format *error-output*|lisp}} ''format x'')</code>

|-

| [[Scheme (programming language)|Scheme]] ([[R6RS|R⁶RS]])

| {{code|<syntaxhighlight lang="scheme" inline>(define x (read-line))|scheme}}</syntaxhighlight>

| <code>(display ''x'')</code><br />or<br /><code>{{codett|(format #t|scheme}} ''format x'')</code>

| {{code|<syntaxhighlight lang="scheme" inline>(display x (current-error-port))|scheme}}</syntaxhighlight><br />or<br /><code>{{codett|(format (current-error-port)|scheme}} ''format x'')</code>

|-

| [[ISLISP]]

| {{<code|>(setf x (read-line))|lisp}}</code>

| <code>{{codett|(format (standard-output)|lisp}} ''format x'')</code>

| <code>{{codett|(format (error-output)|lisp}} ''format x'')</code>

|-

| [[Pascal (programming language)|Pascal]]

| <code>read(''x'');</code><br />or<br /><code>readln(''x'');</code>

| <code>write(''x'');</code><br />or<br /><code>writeln(''x'');</code>

| <code>write(stderr, ''x'');</code><br />or<br /><code>writeln(stderr, ''x'');</code>

|-

| [[Visual Basic (classic)|Visual Basic]]

| <code>Input« ''prompt'',» ''x''</code>

| <code>Print ''x''</code><br />or<br /><code>? ''x''</code>

| {{n/a}}

|-

| [[Visual Basic .NET]]

| <code>''x'' = Console.Read()</code><br />or<br /><code>''x'' = Console.ReadLine()</code>

| <code>Console.Write(''«format'',»''x'')</code><br />or<br /><code>Console.WriteLine(''«format'', »''x'')</code>

| <code>Console.Error<wbr/>.Write(''«format'', ''»x'')</code><br />or<br /><code>Console.Error<wbr/>.WriteLine(''«format'', »''x'')</code>

|-

| [[Xojo]]

| <code>''x'' = StandardInputStream.Read()</code><br />or<br /><code>''x'' = StandardInputStreame.ReadLine()</code>

| <code>StandardOutputStream.Write(''x'')</code><br />or<br /><code>StandardOutputStream.WriteLine(''x'')</code>

| <code>StdErr.Write(''x'')</code><br />or<br /><code>StdErr.WriteLine(''x'')</code>

|-

| [[Python (programming language)|Python]] 2.x

| <code>''x'' = raw_input(''«prompt»'')</code>

| <code>print ''x''</code><br />or<br /><code>sys.stdout.write(''x'')</code>

| <code>{{codett|print >> sys.stderr,|python2}} ''x''</code><br />or<br /><code>sys.stderr.write(''x'')</code>

|-

| [[Python (programming language)|Python]] 3.x

Line 3,193 ⟶ 3,182:

| <code>print(''x«'', end=""», file=sys.stderr)</code>

|-

| [[S-Lang (programming language)|S-Lang]]

| <code>[[fgets]] (&''x'', stdin)</code>

| <code>[[fputs]] (''x'', stdout)</code>

Line 3,199 ⟶ 3,188:

|-

| [[Fortran]]

| <code>READ(*,''format'') ''variable names'' </code><br />or<br /><code>READ(INPUT_UNIT,''format'') ''variable names''</code>{{ref|Fortran standard units|[e]}}

| <code>WRITE(*,''format'') ''expressions'' </code><br />or<br /><code>WRITE(OUTPUT_UNIT,''format'') ''expressions''</code>{{ref|Fortran standard units|[e]}}

| <code>WRITE(ERROR_UNIT,''format'') ''expressions''</code>{{ref|Fortran standard units|[e]}}

|-

| [[Forth (programming language)|Forth]]

| <code>''buffer length'' ACCEPT ''( # chars read )''<br />KEY ''( char )''</code>

| <code>''buffer length'' TYPE<br />''char'' EMIT</code>

| {{n/a}}

|-

| [[PHP]]

| <code>''$x'' = [[fgets]](STDIN);</code><br />or<br /><code>''$x'' = [[fscanf]](STDIN, ''format'');</code>

| <code>print ''x'';</code><br />or<br /><code>[[echo (command)|echo]] ''x'';</code><br />or<br /><code>[[printf]](''format'', ''x'');</code>

| <code>[[fprintf]](STDERR, ''format'', ''x'');</code>

|-

| [[Perl]]

| <code>''$x'' = <>;</code><br />or<br /><code>''$x'' = <STDIN>;</code>

| <code>print ''x'';</code><br />or<br /><code>[[printf]] ''format'', ''x'';</code>

| <code>print STDERR ''x'';</code><br />or<br /><code>[[printf]] STDERR ''format'', ''x'';</code>

|-

| [[Raku (programming language)|Raku]]

| {{code|2<syntaxhighlight lang="raku|1=" inline>$x = $*IN.get;}}</syntaxhighlight>

| <code>''x''.print</code><br />or<br /><code>''x''.say</code>

| <code>''x''.note</code><br />or<br />{{code|2<syntaxhighlight lang="raku|1=" inline>$*ERR.print(x)}}</syntaxhighlight><br />or<br />{{code|2<syntaxhighlight lang="raku|1=" inline>$*ERR.say(x)}}</syntaxhighlight>

|-

| [[Ruby (programming language)|Ruby]]

| <code>''x'' = gets</code>

| <code>puts ''x''</code><br />or<br /><code>[[printf]](''format'', ''x'')</code>

| {{<code|2=ruby|1=>$stderr.puts(x)}}</code><br />or<br /><code>$stderr.[[printf]](''format'', ''x'')</code>

|-

| [[Windows PowerShell]]

| <code>''$x'' = Read-Host«« -Prompt» ''text''»;</code><br />or<br />{{code|2<syntaxhighlight lang="ps1|1=" inline>$x = [Console]::Read();}}</syntaxhighlight><br />or<br />{{code|2<syntaxhighlight lang="ps1|1=" inline>$x = [Console]::ReadLine()}}</syntaxhighlight>

| <code>''x'';</code><br />or<br /><code>Write-Output ''x'';</code><br />or<br /><code>echo ''x''</code>

| <code>Write-Error ''x''</code>

|-

| [[OCaml]]

| <code>let ''x'' = read_int ()</code><br />or<br /><code>let ''str'' = read_line ()</code><br />or<br /><code>Scanf.[[scanf]] ''format'' (fun ''x ...'' <nowiki>-></nowiki> ''...'')</code>

| <code>print_int ''x''</code><br />or<br /><code>print_endline ''str''</code><br />or<br /><code>Printf.[[printf]] ''format x ...''</code>

| <code>prerr_int ''x''</code><br />or<br /><code>prerr_endline ''str''</code><br />or<br /><code>Printf.[[fprintf|eprintf]] ''format x ...''</code>

|-

| [[F Sharp (programming language)|F#]]

| {{code|2<syntaxhighlight lang="f#|1=" inline>let x = System.Console.ReadLine()}}</syntaxhighlight>

| <code>[[printf]] ''format x ...''</code><br />or<br /><code>[[printf]]n ''format x ...''</code>

| <code>[[fprintf|eprintf]] ''format x ...''</code><br />or<br /><code>[[fprintf|eprintf]]n ''format x ...''</code>

|-

| [[Standard ML]]

| {{code|2<syntaxhighlight lang="sml|1=" inline>val str = TextIO.inputLIne TextIO.stdIn}}</syntaxhighlight>

| <code>print ''str''</code>

| <code>{{codett|TextIO.output (TextIO.stdErr,|sml}}'' str'')</code>

|-

| [[Haskell (programming language)|Haskell]] ([[Glasgow Haskell Compiler|GHC]])

| <code>''x'' <- readLn</code><br />or<br /><code>''str'' <nowiki><-</nowiki> getLine</code>

| <code>print ''x''</code><br />or<br /><code>putStrLn ''str''</code>

| <code>hPrint stderr ''x''</code><br />or<br /><code>hPutStrLn stderr ''str''</code>

|-

| [[COBOL]]

Line 3,267 ⟶ 3,256:

== Reading [[command-line argument]]s ==

{| class="wikitable sortable"

|-

Line 3,301 ⟶ 3,289:

| first argument

|-

| [[JavascriptJavaScript]]<br /><small>[[Windows Script Host]] implementation</small>

| <code>WScript.Arguments(''n'')</code>

| <code>WScript.Arguments.length</code>

| <code>WScript.ScriptName</code><br />or<br /><code>WScript.ScriptFullName</code>

|-

| [[Go (programming language)|Go]]

Line 3,312 ⟶ 3,300:

|-

| [[Rust (programming language)|Rust]]{{ref|Rust args|[a]}}

| <code>std::env::args().nth(''n'')</code><br /><code>std::env::args_os().nth(''n'')</code>

| <{{code>|2=rust|std::env::args().count()</code>}}<br /><{{code>|2=rust|std::env::args_os().count()</code>}}

| <{{code>|2=rust|std::env::args().next()</code>}}<br /><{{code>|2=rust|std::env::args_os().next()</code>}}

|-

| [[Swift (programming language)|Swift]]

| <code>Process.arguments[''n'']</code> or<br /><code>Process.unsafeArgv[''n'']</code>

| <code>Process.arguments.count</code> or<br /><code>Process.argc</code>

| first argument

|-

Line 3,327 ⟶ 3,315:

|-

| [[Scheme (programming language)|Scheme]] ([[R6RS|R⁶RS]])

| {{code|2=lisp|(list-ref (command-line) n)|scheme}}

| {{code|2=lisp|(length (command-line))|scheme}}

| first argument

|-

Line 3,349 ⟶ 3,337:

| <code>CmdArgs(''n'')</code>

| <code>CmdArgs.Length</code>

| <{{code>|2=vbnet|[Assembly].GetEntryAssembly().Location</code>}}

|-

| [[Xojo]]

Line 3,361 ⟶ 3,349:

| first argument

|-

| [[S-Lang (programming language)|S-Lang]]

| <code>__argv[''n'']</code>

| <code>__argc</code>

Line 3,367 ⟶ 3,355:

|-

| [[Fortran]]

| <code>DO ''i'' = ''1'',''argc''{{indent|2}}CALL GET_COMMAND_ARGUMENT (''i'',''argv(i)'')<br />ENDDO</code>

| <code>''argc'' = COMMAND_ARGUMENT_COUNT ()</code>

| <code>CALL GET_COMMAND_ARGUMENT (''0'',''progname'')</code>

Line 3,377 ⟶ 3,365:

|-

| [[Bash shell]]

| <code>$''n'' ($1, $2, $3, ''...'')</code><br /><code>$@</code> (all arguments)

| <code>$#</code>

| <code>$0</code>

Line 3,383 ⟶ 3,371:

| [[Perl]]

| <code>$ARGV[''n'']</code>

| <{{code>|2=perl|scalar(@ARGV)</code>}}

| <code>$0</code>

|-

| [[Raku (programming language)|Raku]]

| <code>@*ARGS[''n'']</code>

| <{{code>|2=raku|@*ARGS.elems</code>}}

| <code>$PROGRAM_NAME</code>

|-

Line 3,412 ⟶ 3,400:

|-

| [[Standard ML]]

| <{{code>|lang=sml|List.nth (CommandLine<wbr/>.arguments (), ''n'')</code>}}

| <{{code>|lang=sml|length (CommandLine<wbr/>.arguments ())</code>}}

| <{{code>|lang=sml|CommandLine.name ()</code>}}

|-

| [[Haskell (programming language)|Haskell]] ([[Glasgow Haskell Compiler|GHC]])

| {{code|lang=haskell|do { args <- System.getArgs; return length args !! n }}}

| {{code|lang=haskell|do { args <- System.getArgs; return length args }}}

Line 3,426 ⟶ 3,414:

|}

* {{note|Rust args|a}} In Rust, {{<code|>std::env::args}}</code> and {{<code|>std::env::args_os}}</code> return iterators, {{<code|>std::env::Args}}</code> and {{<code|>std::env::ArgsOs}}</code> respectively. {{<code|>Args}}</code> converts each argument to a {{<code|>String}}</code> and it panics if it reaches an argument that cannot be converted to [[UTF-8]]. {{<code|>ArgsOs}}</code> returns a non-lossy representation of the raw strings from the operating system ({{<code|>std::ffi::OsString}}</code>), which can be invalid UTF-8.

* {{note|unseparated|b}} In Visual Basic, command-line arguments are not separated. Separating them requires a split function <code>Split(''string'')</code>.

* {{note|COBOL Arguments|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 {{<code|>ACCEPT}}</code> statements.

== Execution of commands ==

{| class="wikitable sortable"

!

Line 3,444 ⟶ 3,431:

| rowspan=3| <code>[[system (C standard library)|system]]("''command''");</code>

|

| rowspan=2| <code>[[Exec (operating system)|execl]](''path'', ''args'');</code><br />or<br /><code>[[Exec (operating system)|execv]](''path'', ''arglist'');</code>

|-

| [[C++]]

Line 3,450 ⟶ 3,437:

|-

| [[Objective-C]]

| {{code|<syntaxhighlight lang="objc" inline>[NSTask launchedTaskWithLaunchPath:(NSString *)path arguments:(NSArray *)arguments];|objectivec}}</syntaxhighlight>

|

|-

Line 3,489 ⟶ 3,476:

| [[Java (programming language)|Java]]

|

| <code>Runtime.exec(''command'');</code><br />or<br />{{<code|>new ProcessBuilder(command).start();|java}}</code>

|

|-

| [[JavascriptJavaScript]]<br /><small>[[Windows Script Host]] implementation</small>

| <code>{{codett|WScript.CreateObject ("WScript.Shell").Run(|js}}''command'' «,&nbsp;''WindowStyle''» «,&nbsp;''isWaitOnReturn''»);</code>

| <code>WshShell.Exec(command)</code>

|

Line 3,518 ⟶ 3,505:

|-

| [[OCaml]]

| <code>Sys.command ''command,'', Unix.open_process_full ''command env (stdout, stdin, stderr),...''</code>

| <code>Unix.create_process ''prog args new_stdin new_stdout new_stderr, ...''</code>

| <code>Unix.execv ''prog args''</code><br />or<br /><code>Unix.execve ''prog args env''</code>

|-

| [[Standard ML]]

Line 3,527 ⟶ 3,514:

| <code>Posix.Process.exec (''path'', ''args'')</code>

|-

| [[Haskell (programming language)|Haskell]] ([[Glasgow Haskell Compiler|GHC]])

| <code>System.system ''command''</code>

| <code>System.Process<wbr/>.runProcess ''path args ...''</code>

Line 3,533 ⟶ 3,520:

|-

| [[Perl]]

| <code>system(''command'')</code><br />or<br /><code>''$output'' = `''command''`</code><br />or<br /><code>''$output'' = qx(''command'')</code>

|

| <code>exec(''path'', ''args'')</code>

|-

| [[Ruby (programming language)|Ruby]]

| <code>system(''command'')</code><br />or<br /><code>''output'' = `''command''`</code>

|

| <code>exec(''path'', ''args'')</code>

|-

| [[PHP]]

| <code>system(''command'')</code><br />or<br /><code>''$output'' = `''command''`</code><br />or<br /><code>exec(''command'')</code><br />or<br /><code>passthru(''command'')</code>

|

|

|-

| [[Python (programming language)|Python]]

| <code>os.system(''command'')</code><br />or<br /><code>subprocess.Popen(''command'')</code>

| <code>subprocess.call(''["program", "arg1", "arg2", ...]'')</code>

| <code>os.execv(''path'', ''args'')</code>

|-

| [[S-Lang (programming language)|S-Lang]]

| <code>system(''command'')</code>

|

Line 3,563 ⟶ 3,550:

|-

| [[Windows PowerShell]]

| {{code|<syntaxhighlight lang="ps1" inline>[Diagnostics.Process]::Start(command)|ps1}}</syntaxhighlight>

| <code>«Invoke-Item »''program arg1 arg2 ...''</code>

|

|-

| [[Bash shell]]

| <code>''output''=`''command''`</code><br />or<br /><code>''output''=$(''command'')</code>

| {{<code|>program arg1 arg2 ...}}</code>

|

|}

{{note|Fortran 2008|a}} Fortran 2008 or newer.<ref>{{cite web|url=https://gcc.gnu.org/onlinedocs/gfortran/EXECUTE_005fCOMMAND_005fLINE.html|title=EXECUTE_COMMAND_LINE – The GNU Fortran Compiler|work=gnu.org|access-date=30 January 2017}}</ref>

==See also==

* [[List of open-source programming languages]]

== References ==