Wikipedia

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

Browse history interactively
← Previous editNext edit →
Content deleted Content added
VisualWikitext
Rescuing 1 sources and tagging 0 as dead.) #IABot (v2.0.9.5
substituting most {{code| }} calls with {{subst:codenowiki| }} to go under the expensive parser limit
Tag: nowiki added
Line 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|><nowiki>range -2**7 .. 2**7 - 1}}</nowiki></code>{{ref|Ada_range|[j]}}
| {{<code|><nowiki>range 0 .. 2**8 - 1}}</nowiki></code>{{ref|Ada_range|[j]}} or {{<code|><nowiki>mod 2**8}}</nowiki></code>{{ref|Ada_mod|[k]}}
| {{<code|><nowiki>range -2**15 .. 2**15 - 1}}</nowiki></code>{{ref|Ada_range|[j]}}
| {{<code|><nowiki>range 0 .. 2**16 - 1}}</nowiki></code>{{ref|Ada_range|[j]}} or {{<code|><nowiki>mod 2**16}}</nowiki></code>{{ref|Ada_mod|[k]}}
| {{<code|><nowiki>range -2**31 .. 2**31 - 1}}</nowiki></code>{{ref|Ada_range|[j]}}
| {{<code|><nowiki>range 0 .. 2**32 - 1}}</nowiki></code>{{ref|Ada_range|[j]}} or {{<code|><nowiki>mod 2**32}}</nowiki></code>{{ref|Ada_mod|[k]}}
| {{<code|><nowiki>range -2**63 .. 2**63 - 1}}</nowiki></code>{{ref|Ada_range|[j]}}
| {{<code|><nowiki>mod 2**64}}</nowiki></code>{{ref|Ada_mod|[k]}}
| {{<code|><nowiki>Integer}}</nowiki></code>{{ref|Ada_range|[j]}}
| <code>range 0 .. 2**Integer'<wbr/>Size - 1</code>{{ref|Ada_range|[j]}} or <code>mod Integer'<wbr/>Size</code>{{ref|Ada_mod|[k]}}
| {{n/a}}
|-
| rowspan=2| [[ALGOL 68]] (variable-width)
| rowspan=2| {{<code|><nowiki>short short int}}</nowiki></code>{{ref|CInt|[c]}}
| rowspan=2 {{n/a}}
| rowspan=2| {{<code|><nowiki>short int}}</nowiki></code>{{ref|CInt|[c]}}
| rowspan=2 {{n/a}}
| rowspan=2| {{<code|><nowiki>int}}</nowiki></code>{{ref|CInt|[c]}}
| rowspan=2 {{n/a}}
| rowspan=2| {{<code|><nowiki>long int}}</nowiki></code>{{ref|CInt|[c]}}
| rowspan=2 {{n/a}}
| {{<code|><nowiki>int}}</nowiki></code>{{ref|CInt|[c]}}
| {{n/a}}
| rowspan=2| {{<code|><nowiki>long long int}}</nowiki></code>{{ref|a68|[a]}}{{ref|a68g|[g]}}
|-
| colspan=2 align=center|{{<code|><nowiki>bytes}}</nowiki></code> and {{<code|><nowiki>bits}}</nowiki></code>
|-
| [[C (programming language)|C]] ([[C99]] fixed-width)
| rowspan=2| {{<code|><nowiki>int8_t}}</nowiki></code>
| rowspan=2| {{<code|><nowiki>uint8_t}}</nowiki></code>
| rowspan=2| {{<code|><nowiki>int16_t}}</nowiki></code>
| rowspan=2| {{<code|><nowiki>uint16_t}}</nowiki></code>
| rowspan=2| {{<code|><nowiki>int32_t}}</nowiki></code>
| rowspan=2| {{<code|><nowiki>uint32_t}}</nowiki></code>
| rowspan=2| {{<code|><nowiki>int64_t}}</nowiki></code>
| rowspan=2| {{<code|><nowiki>uint64_t}}</nowiki></code>
| rowspan=2| {{<code|><nowiki>intptr_t}}</nowiki></code>{{ref|CInt|[c]}}
| rowspan=2| {{<code|><nowiki>size_t}}</nowiki></code>{{ref|CInt|[c]}}
| rowspan=5 {{n/a}}
|-
Line 77:
|-
| [[C (programming language)|C]] ([[C99]] variable-width)
| rowspan=2| {{<code|><nowiki>signed char}}</nowiki></code>
| rowspan=2| {{<code|><nowiki>unsigned char}}</nowiki></code>
| rowspan=2| {{<code|><nowiki>short}}</nowiki></code>{{ref|CInt|[c]}}
| rowspan=2| {{<code|><nowiki>unsigned short}}</nowiki></code>{{ref|CInt|[c]}}
| rowspan=2| {{<code|><nowiki>long}}</nowiki></code>{{ref|CInt|[c]}}
| rowspan=2| {{<code|><nowiki>unsigned long}}</nowiki></code>{{ref|CInt|[c]}}
| rowspan=2| {{<code|><nowiki>long long}}</nowiki></code>{{ref|CInt|[c]}}
| rowspan=2| {{<code|><nowiki>unsigned long long}}</nowiki></code>{{ref|CInt|[c]}}
| rowspan=2| {{<code|><nowiki>int}}</nowiki></code>{{ref|CInt|[c]}}
| rowspan=2| {{<code|><nowiki>unsigned int}}</nowiki></code>{{ref|CInt|[c]}}
|-
| [[C++]] ([[C++11]] variable-width)
|-
| [[Objective-C]] ([[Cocoa (API)|Cocoa]])
| {{<code|><nowiki>signed char}}</nowiki></code> or {{<code|><nowiki>int8_t}}</nowiki></code>
| {{<code|><nowiki>unsigned char}}</nowiki></code> or {{<code|><nowiki>uint8_t}}</nowiki></code>
| {{<code|><nowiki>short}}</nowiki></code> or {{<code|><nowiki>int16_t}}</nowiki></code>
| {{<code|><nowiki>unsigned short}}</nowiki></code> or {{<code|><nowiki>uint16_t}}</nowiki></code>
| {{<code|><nowiki>int}}</nowiki></code> or {{<code|><nowiki>int32_t}}</nowiki></code>
| {{<code|><nowiki>unsigned int}}</nowiki></code> or {{<code|><nowiki>uint32_t}}</nowiki></code>
| {{<code|><nowiki>long long}}</nowiki></code> or {{<code|><nowiki>int64_t}}</nowiki></code>
| {{<code|><nowiki>unsigned long long}}</nowiki></code> or {{<code|><nowiki>uint64_t}}</nowiki></code>
| {{<code|><nowiki>NSInteger}}</nowiki></code> or {{<code|><nowiki>long}}</nowiki></code>
| {{<code|><nowiki>NSUInteger}}</nowiki></code> or {{<code|><nowiki>unsigned long}}</nowiki></code>
|-
| [[C Sharp (programming language)|C#]]
| {{<code|><nowiki>sbyte}}</nowiki></code>
| {{<code|><nowiki>byte}}</nowiki></code>
| rowspan=2| {{<code|><nowiki>short}}</nowiki></code>
| {{<code|><nowiki>ushort}}</nowiki></code>
| rowspan=2| {{<code|><nowiki>int}}</nowiki></code>
| {{<code|><nowiki>uint}}</nowiki></code>
| rowspan=2| {{<code|><nowiki>long}}</nowiki></code>
| {{<code|><nowiki>ulong}}</nowiki></code>
| {{<code|><nowiki>IntPtr}}</nowiki></code>
| {{<code|><nowiki>UIntPtr}}</nowiki></code>
| <code>System.Numerics.<wbr/>BigInteger</code><br/>(.NET 4.0)
|-
| [[Java (programming language)|Java]]
| {{<code|><nowiki>byte}}</nowiki></code>
| {{n/a}}
| {{<code|><nowiki>char}}</nowiki></code>{{ref|Java char|[b]}}
| {{n/a}}
| {{n/a}}
Line 126:
|-
| [[Go (programming language)|Go]]
| {{<code|><nowiki>int8}}</nowiki></code>
| {{<code|><nowiki>uint8}}</nowiki></code> or {{<code|><nowiki>byte}}</nowiki></code>
| {{<code|><nowiki>int16}}</nowiki></code>
| {{<code|><nowiki>uint16}}</nowiki></code>
| {{<code|><nowiki>int32}}</nowiki></code>
| {{<code|><nowiki>uint32}}</nowiki></code>
| {{<code|><nowiki>int64}}</nowiki></code>
| {{<code|><nowiki>uint64}}</nowiki></code>
| {{<code|><nowiki>int}}</nowiki></code>
| {{<code|><nowiki>uint}}</nowiki></code>
| {{<code|><nowiki>big.Int}}</nowiki></code>
|-
| [[Rust (programming language)|Rust]]
| {{<code|><nowiki>i8}}</nowiki></code>
| {{<code|><nowiki>u8}}</nowiki></code>
| {{<code|><nowiki>i16}}</nowiki></code>
| {{<code|><nowiki>u16}}</nowiki></code>
| {{<code|><nowiki>i32}}</nowiki></code>
| {{<code|><nowiki>u32}}</nowiki></code>
| {{<code|><nowiki>i64}}</nowiki></code>
| {{<code|><nowiki>u64}}</nowiki></code>
| {{<code|><nowiki>isize}}</nowiki></code>
| {{<code|><nowiki>usize}}</nowiki></code>
| {{n/a}}
|-
| [[Swift (programming language)|Swift]]
| {{<code|><nowiki>Int8}}</nowiki></code>
| {{<code|><nowiki>UInt8}}</nowiki></code>
| {{<code|><nowiki>Int16}}</nowiki></code>
| {{<code|><nowiki>UInt16}}</nowiki></code>
| {{<code|><nowiki>Int32}}</nowiki></code>
| {{<code|><nowiki>UInt32}}</nowiki></code>
| {{<code|><nowiki>Int64}}</nowiki></code>
| {{<code|><nowiki>UInt64}}</nowiki></code>
| {{<code|><nowiki>Int}}</nowiki></code>
| {{<code|><nowiki>UInt}}</nowiki></code>
|-
| [[D (programming language)|D]]
| {{<code|><nowiki>byte}}</nowiki></code>
| {{<code|><nowiki>ubyte}}</nowiki></code>
| {{<code|><nowiki>short}}</nowiki></code>
| {{<code|><nowiki>ushort}}</nowiki></code>
| {{<code|><nowiki>int}}</nowiki></code>
| {{<code|><nowiki>uint}}</nowiki></code>
| {{<code|><nowiki>long}}</nowiki></code>
| {{<code|><nowiki>ulong}}</nowiki></code>
| {{n/a}}
| {{n/a}}
| {{<code|><nowiki>BigInt}}</nowiki></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|><nowiki>(signed-byte 8)}}</nowiki></code>
| {{<code|><nowiki>(unsigned-byte 8)}}</nowiki></code>
| {{<code|><nowiki>(signed-byte 16)}}</nowiki></code>
| {{<code|><nowiki>(unsigned-byte 16)}}</nowiki></code>
| {{<code|><nowiki>(signed-byte 32)}}</nowiki></code>
| {{<code|><nowiki>(unsigned-byte 32)}}</nowiki></code>
| {{<code|><nowiki>(signed-byte 64)}}</nowiki></code>
| {{<code|><nowiki>(unsigned-byte 64)}}</nowiki></code>
|
|
| {{<code|><nowiki>bignum}}</nowiki></code>
|-
| [[Scheme (programming language)|Scheme]]
Line 213:
|
|
| {{<code|><nowiki>bignum}}</nowiki></code>
|-
| [[Pascal (programming language)|Pascal]] ([[Free Pascal|FPC]])
| {{<code|><nowiki>shortint}}</nowiki></code>
| {{<code|><nowiki>byte}}</nowiki></code>
| {{<code|><nowiki>smallint}}</nowiki></code>
| {{<code|><nowiki>word}}</nowiki></code>
| {{<code|><nowiki>longint}}</nowiki></code>
| {{<code|><nowiki>longword}}</nowiki></code>
| {{<code|><nowiki>int64}}</nowiki></code>
| {{<code|><nowiki>qword}}</nowiki></code>
| {{<code|><nowiki>integer}}</nowiki></code>
| {{<code|><nowiki>cardinal}}</nowiki></code>
| {{n/a}}
|-
| [[Visual Basic (classic)|Visual Basic]]
| {{n/a}}
| rowspan=2|{{<code|><nowiki>Byte}}</nowiki></code>
| {{<code|><nowiki>Integer}}</nowiki></code>
| {{n/a}}
| {{<code|><nowiki>Long}}</nowiki></code>
| {{n/a}}
| colspan=2 {{n/a}}
Line 240:
|-
| [[Visual Basic .NET]]
| {{<code|><nowiki>SByte}}</nowiki></code>
| {{<code|><nowiki>Short}}</nowiki></code>
| {{<code|><nowiki>UShort}}</nowiki></code>
| {{<code|><nowiki>Integer}}</nowiki></code>
| {{<code|><nowiki>UInteger}}</nowiki></code>
| {{<code|><nowiki>Long}}</nowiki></code>
| {{<code|><nowiki>ULong}}</nowiki></code>
| <code>System.Numerics<wbr/>.BigInteger</code><br/>(.NET 4.0)
|-
| [[FreeBasic]]
| {{<code|><nowiki>Byte}}</nowiki></code> or {{<code|><nowiki>Integer<8>}}</nowiki></code>
| {{<code|><nowiki>UByte}}</nowiki></code> or {{<code|><nowiki>UInteger<8>}}</nowiki></code>
| {{<code|><nowiki>Short}}</nowiki></code> or {{<code|><nowiki>Integer<16>}}</nowiki></code>
| {{<code|><nowiki>UShort}}</nowiki></code> or {{<code|><nowiki>UInteger<16>}}</nowiki></code>
| {{<code|><nowiki>Long}}</nowiki></code> or {{<code|><nowiki>Integer<32>}}</nowiki></code>
| {{<code|><nowiki>ULong}}</nowiki></code> or {{<code|><nowiki>UInteger<32>}}</nowiki></code>
| {{<code|><nowiki>LongInt}}</nowiki></code> or {{<code|><nowiki>Integer<64>}}</nowiki></code>
| {{<code|><nowiki>ULongInt}}</nowiki></code> or {{<code|><nowiki>UInteger<64>}}</nowiki></code>
| {{<code|><nowiki>Integer}}</nowiki></code>
| {{<code|><nowiki>UInteger}}</nowiki></code>
| {{n/a}}
|-
Line 267:
| colspan=2 {{n/a}}
| colspan=2 {{n/a}}
| {{<code|><nowiki>int}}</nowiki></code>
| {{n/a}}
| {{<code|><nowiki>long}}</nowiki></code>
|-
| [[Python (programming language)|Python]] 3.x
Line 277:
| colspan=2 {{n/a}}
| colspan=2 {{n/a}}
| {{<code|><nowiki>int}}</nowiki></code>
|-
| [[S-Lang (programming language)|S-Lang]]
Line 303:
| colspan=2 {{n/a}}
| colspan=2 {{n/a}}
| {{<code|><nowiki>int}}</nowiki></code>{{ref|PHP 32/64 bit long|[m]}}
| {{n/a}}
| {{<code|><nowiki>int}}</nowiki></code>{{ref|PHP 32/64 bit long|[m]}}
| {{n/a}}
| colspan=2 {{n/a}}
Line 316:
| colspan=2 {{n/a}}{{ref|scalars|[d]}}
| colspan=2 {{n/a}}{{ref|scalars|[d]}}
| {{<code|><nowiki>Math::BigInt}}</nowiki></code>
|-
| [[Raku (programming language)|Raku]]
| {{<code|><nowiki>int8}}</nowiki></code>
| {{<code|><nowiki>uint8}}</nowiki></code>
| {{<code|><nowiki>int16}}</nowiki></code>
| {{<code|><nowiki>uint16}}</nowiki></code>
| {{<code|><nowiki>int32}}</nowiki></code>
| {{<code|><nowiki>uint32}}</nowiki></code>
| {{<code|><nowiki>int64}}</nowiki></code>
| {{<code|><nowiki>uint64}}</nowiki></code>
| {{<code|><nowiki>Int}}</nowiki></code>
| colspan=2 {{n/a}}
|-
Line 335:
| colspan=2 {{n/a}}
| colspan=2 {{n/a}}
| {{<code|><nowiki>Fixnum}}</nowiki></code>
| {{n/a}}
| {{<code|><nowiki>Bignum}}</nowiki></code>
|-
| [[Erlang (programming language)|Erlang]]{{ref|Erlang_int|[n]}}
Line 344:
| colspan=2 {{n/a}}
| colspan=2 {{n/a}}
| {{<code|><nowiki>integer()}}</nowiki></code>
| {{n/a}}
| {{<code|><nowiki>integer()}}</nowiki></code>{{ref|Erlang_arb|[o]}}
|-
| [[Scala (programming language)|Scala]]
| {{<code|><nowiki>Byte}}</nowiki></code>
| {{n/a}}
| {{<code|><nowiki>Short}}</nowiki></code>
| {{<code|><nowiki>Char}}</nowiki></code>{{ref|Scala Char|[l]}}
| {{<code|><nowiki>Int}}</nowiki></code>
| {{n/a}}
| {{<code|><nowiki>Long}}</nowiki></code>
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{<code|><nowiki>scala.math.BigInt}}</nowiki></code>
|-
| [[Seed7]]
Line 368:
| {{n/a}}
| {{n/a}}
| {{<code|><nowiki>integer}}</nowiki></code>
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{<code|><nowiki>bigInteger}}</nowiki></code>
|-
| [[Smalltalk]]
Line 379:
| colspan=2 {{n/a}}
| colspan=2 {{n/a}}
| {{<code|><nowiki>SmallInteger}}</nowiki></code>{{ref|Smalltalk|[i]}}
| {{n/a}}
| {{<code|><nowiki>LargeInteger}}</nowiki></code>{{ref|Smalltalk|[i]}}
|-
| [[Windows PowerShell]]
Line 394:
| colspan=2 {{n/a}}
| colspan=2 {{n/a}}
| {{<code|><nowiki>int32}}</nowiki></code>
| {{n/a}}
| rowspan=2| {{<code|><nowiki>int64}}</nowiki></code>
| {{n/a}}
| {{<code|><nowiki>int}}</nowiki></code> or {{<code|><nowiki>nativeint}}</nowiki></code>
|
| {{<code|><nowiki>open Big_int;;}}</nowiki></code> or {{<code|><nowiki>big_int}}</nowiki></code>
|-
| [[F Sharp (programming language)|F#]]
| {{<code|><nowiki>sbyte}}</nowiki></code>
| {{<code|><nowiki>byte}}</nowiki></code>
| {{<code|><nowiki>int16}}</nowiki></code>
| {{<code|><nowiki>uint16}}</nowiki></code>
| {{<code|><nowiki>int32}}</nowiki></code> or {{<code|><nowiki>int}}</nowiki></code>
| {{<code|><nowiki>uint32}}</nowiki></code>
| {{<code|><nowiki>uint64}}</nowiki></code>
| {{<code|><nowiki>nativeint}}</nowiki></code>
| {{<code|><nowiki>unativeint}}</nowiki></code>
| {{<code|><nowiki>bigint}}</nowiki></code>
|-
| [[Standard ML]]
| {{n/a}}
| {{<code|><nowiki>Word8.word}}</nowiki></code>
| colspan=2 {{n/a}}
| {{<code|><nowiki>Int32.int}}</nowiki></code>
| {{<code|><nowiki>Word32.word}}</nowiki></code>
| {{<code|><nowiki>Int64.int}}</nowiki></code>
| {{<code|><nowiki>Word64.word}}</nowiki></code>
| {{<code|><nowiki>int}}</nowiki></code>
| {{<code|><nowiki>word}}</nowiki></code>
| {{<code|><nowiki>LargeInt.int}}</nowiki></code> or<br/>{{<code|><nowiki>IntInf.int}}</nowiki></code>
|-
| [[Haskell]] ([[Glasgow Haskell Compiler|GHC]])
| {{<code|><nowiki>«import Int»}}</nowiki></code> or {{<code|><nowiki>Int8}}</nowiki></code>
| {{<code|><nowiki>«import Word»}}</nowiki></code> or {{<code|><nowiki>Word8}}</nowiki></code>
| {{<code|><nowiki>«import Int»}}</nowiki></code> or {{<code|><nowiki>Int16}}</nowiki></code>
| {{<code|><nowiki>«import Word»}}</nowiki></code> or {{<code|><nowiki>Word16}}</nowiki></code>
| {{<code|><nowiki>«import Int»}}</nowiki></code> or {{<code|><nowiki>Int32}}</nowiki></code>
| {{<code|><nowiki>«import Word»}}</nowiki></code> or {{<code|><nowiki>Word32}}</nowiki></code>
| {{<code|><nowiki>«import Int»}}</nowiki></code> or {{<code|><nowiki>Int64}}</nowiki></code>
| {{<code|><nowiki>«import Word»}}</nowiki></code> or {{<code|><nowiki>Word64}}</nowiki></code>
| {{<code|><nowiki>Int}}</nowiki></code>
| {{<code|><nowiki>«import Word»}}</nowiki></code> or {{<code|><nowiki>Word}}</nowiki></code>
| {{<code|><nowiki>Integer}}</nowiki></code>
|-
| [[Eiffel (programming language)|Eiffel]]
| {{<code|><nowiki>INTEGER_8}}</nowiki></code>
| {{<code|><nowiki>NATURAL_8}}</nowiki></code>
| {{<code|><nowiki>INTEGER_16}}</nowiki></code>
| {{<code|><nowiki>NATURAL_16}}</nowiki></code>
| {{<code|><nowiki>INTEGER_32}}</nowiki></code>
| {{<code|><nowiki>NATURAL_32}}</nowiki></code>
| {{<code|><nowiki>INTEGER_64}}</nowiki></code>
| {{<code|><nowiki>NATURAL_64}}</nowiki></code>
| {{<code|><nowiki>INTEGER}}</nowiki></code>
| {{<code|><nowiki>NATURAL}}</nowiki></code>
| {{n/a}}
|-
| [[COBOL]]{{ref|Cobol|[h]}}
| {{<code|><nowiki>BINARY-CHAR «SIGNED»}}</nowiki></code>
| {{<code|><nowiki>BINARY-CHAR UNSIGNED}}</nowiki></code>
| {{<code|><nowiki>BINARY-SHORT «SIGNED»}}</nowiki></code>
| {{<code|><nowiki>BINARY-SHORT UNSIGNED}}</nowiki></code>
| {{<code|><nowiki>BINARY-LONG «SIGNED»}}</nowiki></code>
| {{<code|><nowiki>BINARY-LONG UNSIGNED}}</nowiki></code>
| {{<code|><nowiki>BINARY-DOUBLE «SIGNED»}}</nowiki></code>
| {{<code|><nowiki>BINARY-DOUBLE UNSIGNED}}</nowiki></code>
| {{n/a}}
| {{n/a}}
Line 471:
| colspan=2 {{n/a}}
| colspan=2 {{n/a}}
| {{<code|><nowiki>Integer}}</nowiki></code>
|-
| [[Wolfram Language]]
Line 479:
| colspan=2 {{n/a}}
| colspan=2 {{n/a}}
| {{<code|><nowiki>Integer}}</nowiki></code>
|}
 
* {{note|a68|a}} The ''standard'' constants {{<code|><nowiki>int shorts}}</nowiki></code> and {{<code|><nowiki>int lengths}}</nowiki></code> can be used to determine how many {{<code|><nowiki>short}}</nowiki></code>s and {{<code|><nowiki>long}}</nowiki></code>s can be usefully prefixed to {{<code|><nowiki>short int}}</nowiki></code> and {{<code|><nowiki>long int}}</nowiki></code>. The actual sizes of {{<code|><nowiki>short int}}</nowiki></code>, {{<code|><nowiki>int}}</nowiki></code>, and {{<code|><nowiki>long int}}</nowiki></code> are available as the constants {{<code|><nowiki>short max int}}</nowiki></code>, {{<code|><nowiki>max int}}</nowiki></code>, and {{<code|><nowiki>long max int}}</nowiki></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|><nowiki>short}}</nowiki></code>, {{<code|><nowiki>int}}</nowiki></code>, {{<code|><nowiki>long}}</nowiki></code>, and ([[C99]], [[C++11]]) {{<code|><nowiki>long long}}</nowiki></code>, so they are implementation-dependent. In C and C++ {{<code|><nowiki>short}}</nowiki></code>, {{<code|><nowiki>long}}</nowiki></code>, and {{<code|><nowiki>long long}}</nowiki></code> types are required to be at least 16, 32, and 64 bits wide, respectively, but can be more. The {{<code|><nowiki>int}}</nowiki></code> type is required to be at least as wide as {{<code|><nowiki>short}}</nowiki></code> and at most as wide as {{<code|><nowiki>long}}</nowiki></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|><nowiki>[u]intN_t}}</nowiki></code> exact-width types in the [[stdint.h]] header. See [[C syntax#Integral types]] for more information. In addition the types {{<code|><nowiki>size_t}}</nowiki></code> and {{<code|><nowiki>ptrdiff_t}}</nowiki></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|><nowiki>n}}</nowiki></code> is provided by the {{<code|><nowiki>SELECTED_INT_KIND}}</nowiki></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|><nowiki>--precision "number"}}</nowiki></code> can set precision for {{<code|><nowiki>long long int}}</nowiki></code>s to the required "number" significant digits. The ''standard'' constants {{<code|><nowiki>long long int width}}</nowiki></code> and {{<code|><nowiki>long long max int}}</nowiki></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|><nowiki>PIC S9999}}</nowiki></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>) and Natural (<code>range 0 .. Integer'Last</code>). {{<code|><nowiki>Short_Short_Integer}}</nowiki></code> (8 bits), {{<code|><nowiki>Short_Integer}}</nowiki></code> (16 bits) and {{<code|><nowiki>Long_Integer}}</nowiki></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 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|><nowiki>int}}</nowiki></code> in PHP has the same width as {{<code|><nowiki>long}}</nowiki></code> type in C has on that system.{{ref|CInt|[c]}}
* {{note|Erlang 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 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>
Line 507:
|-
| [[Ada (programming language)|Ada]]<ref name="Ada_RM_2012" />
| {{<code|><nowiki>Float}}</nowiki></code>
| {{<code|><nowiki>Long_Float}}</nowiki></code>
| {{n/a}}
|-
| [[ALGOL 68]]
| {{<code|><nowiki>real}}</nowiki></code>{{ref|a68|[a]}}
| {{<code|><nowiki>long real}}</nowiki></code>{{ref|a68|[a]}}
| {{<code|><nowiki>short real}}</nowiki></code>, {{<code|><nowiki>long long real}}</nowiki></code>, etc.{{ref|a68g|[d]}}
|-
| [[C (programming language)|C]]
| rowspan=3| {{<code|><nowiki>float}}</nowiki></code>{{ref|lax floats|[b]}}
| rowspan=5| {{<code|><nowiki>double}}</nowiki></code>
| rowspan=3| {{<code|><nowiki>long double}}</nowiki></code>{{ref|C-long-double|[f]}}
|-
| [[C++]] (STL)
|-
| [[Objective-C]] ([[Cocoa (API)|Cocoa]])
| {{<code|><nowiki>CGFloat}}</nowiki></code>
|-
| [[C Sharp (programming language)|C#]]
| rowspan=2| {{<code|><nowiki>float}}</nowiki></code>
| rowspan=4 {{n/a}}
|-
Line 533:
|-
| [[Go (programming language)|Go]]
| {{<code|><nowiki>float32}}</nowiki></code>
| {{<code|><nowiki>float64}}</nowiki></code>
|-
| [[Rust (programming language)|Rust]]
| {{<code|><nowiki>f32}}</nowiki></code>
| {{<code|><nowiki>f64}}</nowiki></code>
|-
| [[Swift (programming language)|Swift]]
| {{<code|><nowiki>Float}}</nowiki></code> or {{<code|><nowiki>Float32}}</nowiki></code>
| {{<code|><nowiki>Double}}</nowiki></code> or {{<code|><nowiki>Float64}}</nowiki></code>
| {{<code|><nowiki>Float80}}</nowiki></code>{{ref|Swift-long-double|[g]}}
| {{<code|><nowiki>CGFloat}}</nowiki></code>
|-
| [[D (programming language)|D]]
| {{<code|><nowiki>float}}</nowiki></code>
| {{<code|><nowiki>double}}</nowiki></code>
|
| {{<code|><nowiki>real}}</nowiki></code>
|-
| [[Common Lisp]]
| {{<code|><nowiki>single-float}}</nowiki></code>
| {{<code|><nowiki>double-float}}</nowiki></code>
| {{<code|><nowiki>float, short-float, long-float}}</nowiki></code>
|-
| [[Scheme (programming language)|Scheme]]
Line 568:
|-
| [[Pascal (programming language)|Pascal]] ([[Free Pascal|FPC]])
| {{<code|><nowiki>single}}</nowiki></code>
| {{<code|><nowiki>double}}</nowiki></code>
|
| {{<code|><nowiki>real}}</nowiki></code>
|-
| [[Visual Basic (classic)|Visual Basic]]
| rowspan=3| {{<code|><nowiki>Single}}</nowiki></code>
| rowspan=3| {{<code|><nowiki>Double}}</nowiki></code>
| rowspan=3 {{n/a}}
|-
Line 584:
| [[Python (programming language)|Python]]
| rowspan=2 {{n/a}}
| {{<code|><nowiki>float}}</nowiki></code>
|
|-
| [[JavaScript]]
| {{<code|><nowiki>Number}}</nowiki></code><ref name="Javascript numbers">[https://www.mozilla.org/js/language/E262-3.pdf 8.5 The Number Type]</ref>
| {{n/a}}
|-
Line 602:
| [[PHP]]
|
| {{<code|><nowiki>float}}</nowiki></code>
|
|-
Line 611:
|-
| [[Raku (programming language)|Raku]]
| {{<code|><nowiki>num32}}</nowiki></code>
| {{<code|><nowiki>num64}}</nowiki></code>
|
| {{<code|><nowiki>Num}}</nowiki></code>
|-
| [[Ruby (programming language)|Ruby]]
| {{n/a}}
| {{<code|><nowiki>Float}}</nowiki></code>
| rowspan=4 {{n/a}}
|-
| [[Scala (programming language)|Scala]]
| {{<code|><nowiki>Float}}</nowiki></code>
| {{<code|><nowiki>Double}}</nowiki></code>
|-
| [[Seed7]]
| {{n/a}}
| {{<code|><nowiki>float}}</nowiki></code>
|-
| [[Smalltalk]]
| {{<code|><nowiki>Float}}</nowiki></code>
| {{<code|><nowiki>Double}}</nowiki></code>
|-
| [[Windows PowerShell]]
Line 640:
| [[OCaml]]
| {{n/a}}
| rowspan=2| {{<code|><nowiki>float}}</nowiki></code>
| rowspan=3 {{n/a}}
|-
| [[F Sharp (programming language)|F#]]
| {{<code|><nowiki>float32}}</nowiki></code>
|-
| [[Standard ML]]
| {{n/a}}
|
| {{<code|><nowiki>real}}</nowiki></code>
|-
| [[Haskell]] ([[Glasgow Haskell Compiler|GHC]])
| {{<code|><nowiki>Float}}</nowiki></code>
| {{<code|><nowiki>Double}}</nowiki></code>
|
|-
| [[Eiffel (programming language)|Eiffel]]
| {{<code|><nowiki>REAL_32}}</nowiki></code>
| {{<code|><nowiki>REAL_64}}</nowiki></code>
|
|-
| [[COBOL]]
| {{<code|><nowiki>FLOAT-BINARY-7}}</nowiki></code>{{ref|Cobol_ieee|[e]}}
| {{<code|><nowiki>FLOAT-BINARY-34}}</nowiki></code>{{ref|Cobol_ieee|[e]}}
| {{<code|><nowiki>FLOAT-SHORT}}</nowiki></code>, {{<code|><nowiki>FLOAT-LONG}}</nowiki></code>, {{<code|><nowiki>FLOAT-EXTENDED}}</nowiki></code>
|-
| [[Mathematica]]
Line 670:
| {{n/a}}
|
| {{<code|><nowiki>Real}}</nowiki></code>
|}
 
* {{note|a68_real|a}} The ''standard'' constants {{<code|><nowiki>real shorts}}</nowiki></code> and {{<code|><nowiki>real lengths}}</nowiki></code> can be used to determine how many {{<code|><nowiki>short}}</nowiki></code>s and {{<code|><nowiki>long}}</nowiki></code>s can be usefully prefixed to {{<code|><nowiki>short real}}</nowiki></code> and {{<code|><nowiki>long real}}</nowiki></code>. The actual sizes of {{<code|><nowiki>short real}}</nowiki></code>, {{<code|><nowiki>real}}</nowiki></code>, and {{<code|><nowiki>long real}}</nowiki></code> are available as the constants {{<code|><nowiki>short max real}}</nowiki></code>, {{<code|><nowiki>max real}}</nowiki></code> and {{<code|><nowiki>long max real}}</nowiki></code> etc. With the constants {{<code|><nowiki>short small real}}</nowiki></code>, {{<code|><nowiki>small real}}</nowiki></code> and {{<code|><nowiki>long small real}}</nowiki></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|><nowiki>n}}</nowiki></code> is provided by the {{<code|><nowiki>SELECTED_REAL_KIND}}</nowiki></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|><nowiki>--precision "number"}}</nowiki></code> can set precision for {{<code|><nowiki>long long real}}</nowiki></code>s to the required "number" significant digits. The ''standard'' constants {{<code|><nowiki>long long real width}}</nowiki></code> and {{<code|><nowiki>long long max real}}</nowiki></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|><nowiki>double}}</nowiki></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|><nowiki>long double}}</nowiki></code> in C languages.
 
=== [[Complex number]]s ===
Line 691:
| [[Ada (programming language)|Ada]]<ref name="Ada_RM_2012" />
| {{n/a}}
| {{<code|><nowiki>Complex}}</nowiki></code>{{ref|generic type|[b]}}
| {{<code|><nowiki>Complex}}</nowiki></code>{{ref|generic type|[b]}}
| {{<code|><nowiki>Complex}}</nowiki></code>{{ref|generic type|[b]}}
|-
| [[ALGOL 68]]
| {{n/a}}
| {{<code|><nowiki>compl}}</nowiki></code>
| {{<code|><nowiki>long compl}}</nowiki></code> etc.
| {{<code|><nowiki>short compl}}</nowiki></code> etc. and {{<code|><nowiki>long long compl}}</nowiki></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|><nowiki>float complex}}</nowiki></code>
| {{<code|><nowiki>double complex}}</nowiki></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|><nowiki>System.Numerics.Complex}}</nowiki></code><br/>(.NET 4.0)
|-
| [[Java (programming language)|Java]]
Line 724:
| [[Go (programming language)|Go]]
| {{n/a}}
| {{<code|><nowiki>complex64}}</nowiki></code>
| {{<code|><nowiki>complex128}}</nowiki></code>
|-
| [[D (programming language)|D]]
| {{n/a}}
| {{<code|><nowiki>cfloat}}</nowiki></code>
| {{<code|><nowiki>cdouble}}</nowiki></code>
|-
| [[Objective-C]]
Line 762:
| {{n/a}}
| {{n/a}}
| {{<code|><nowiki>System.Numerics.Complex}}</nowiki></code><br/>(.NET 4.0)
|-
| [[Perl]]
|
|
| {{<code|><nowiki>Math::Complex}}</nowiki></code>
|
|-
| [[Raku (programming language)|Raku]]
|
| {{<code|><nowiki>complex64}}</nowiki></code>
| {{<code|><nowiki>complex128}}</nowiki></code>
| {{<code|><nowiki>Complex}}</nowiki></code>
|-
| [[Python (programming language)|Python]]
|
|
| {{<code|><nowiki>complex}}</nowiki></code>
| rowspan=15 {{n/a}}
|-
Line 797:
|-
| [[Ruby (programming language)|Ruby]]
| {{<code|><nowiki>Complex}}</nowiki></code>
| {{n/a}}
| {{<code|><nowiki>Complex}}</nowiki></code>
|-
| [[Scala (programming language)|Scala]]
Line 809:
| {{n/a}}
| {{n/a}}
| {{<code|><nowiki>complex}}</nowiki></code>
|-
| [[Smalltalk]]
| {{<code|><nowiki>Complex}}</nowiki></code>
| {{<code|><nowiki>Complex}}</nowiki></code>
| {{<code|><nowiki>Complex}}</nowiki></code>
|-
| [[Windows PowerShell]]
Line 824:
| {{n/a}}
| {{n/a}}
| {{<code|><nowiki>Complex.t}}</nowiki></code>
|-
| [[F Sharp (programming language)|F#]]
|
|
| {{<code|><nowiki>System.Numerics.Complex}}</nowiki></code><br/>(.NET 4.0)
|-
| [[Standard ML]]
Line 838:
| [[Haskell]] ([[Glasgow Haskell Compiler|GHC]])
| {{n/a}}
| {{<code|><nowiki>Complex{{Not a typo|.}}Complex Float}}</nowiki></code>
| {{<code|><nowiki>Complex{{Not a typo|.}}Complex Double}}</nowiki></code>
|-
| [[Eiffel (programming language)|Eiffel]]
Line 852:
|-
| [[Mathematica]]
| {{<code|><nowiki>Complex}}</nowiki></code>
| {{n/a}}
| {{n/a}}
| {{<code|><nowiki>Complex}}</nowiki></code>
|}
 
* {{note|complex kinds|a}} The value of {{<code|><nowiki>n}}</nowiki></code> is provided by the {{<code|><nowiki>SELECTED_REAL_KIND}}</nowiki></code><ref name="ReferenceA" /> intrinsic function.
* {{note|generic type|b}} Generic type which can be instantiated with any base floating point type.
 
Line 873:
|-
| [[Ada (programming language)|Ada]]<ref name="Ada_RM_2012" />
| {{<code|><nowiki>Character}}</nowiki></code>
| {{<code|><nowiki>String}}</nowiki></code>, {{<code|><nowiki>Bounded_String}}</nowiki></code>, {{<code|><nowiki>Unbounded_String}}</nowiki></code>
| {{<code|><nowiki>Boolean}}</nowiki></code>
| <code>(''item<sub>1</sub>'', ''item<sub>2</sub>'', ''...'')</code>
| {{<code|><nowiki>tagged null record}}</nowiki></code>
|-
| [[ALGOL 68]]
| {{<code|><nowiki>char}}</nowiki></code>
| {{<code|><nowiki>string}}</nowiki></code>, {{<code|><nowiki>bytes}}</nowiki></code>
| {{<code|><nowiki>bool}}</nowiki></code>, {{<code|><nowiki>bits}}</nowiki></code>
| {{n/a}} - [http://rosettacode.org/wiki/Enumerations#ALGOL_68 User defined]
| {{n/a}}
|-
| [[C (programming language)|C]] ([[C99]])
| rowspan=2| {{<code|><nowiki>char}}</nowiki></code>, {{<code|><nowiki>wchar_t}}</nowiki></code>
| {{n/a}}
| rowspan=2| {{<code|><nowiki>bool}}</nowiki></code>{{ref|int bool|[b]}}
| rowspan=3| <code>enum ''«name»'' { ''item<sub>1</sub>'', ''item<sub>2</sub>'', ''...'' };</code>
| rowspan=2| <code>[[void type|void]] [[pointer (computer programming)|*]]</code>
|-
| [[C++]] (STL)
| [[C++ string handling|{{<code|><nowiki>«std::»string}}</nowiki></code>]]
|-
| [[Objective-C]]
| {{<code|><nowiki>unichar}}</nowiki></code>
| {{<code|><nowiki>NSString *}}</nowiki></code>
| {{<code|><nowiki>BOOL}}</nowiki></code>
| {{<code|><nowiki>id}}</nowiki></code>
|-
| [[C Sharp (programming language)|C#]]
| rowspan=2| {{<code|><nowiki>char}}</nowiki></code>
| {{<code|><nowiki>string}}</nowiki></code>
| {{<code|><nowiki>bool}}</nowiki></code>
| <code>enum ''name'' { ''item<sub>1</sub>''« = ''value''», ''item<sub>2</sub>''« = ''value''», ''...'' }</code>
| object
|-
| [[Java (programming language)|Java]]
| {{<code|><nowiki>String}}</nowiki></code>
| {{<code|><nowiki>boolean}}</nowiki></code>
| <code>enum ''name'' { ''item<sub>1</sub>'', ''item<sub>2</sub>'', ''...'' }</code>
| {{<code|><nowiki>Object}}</nowiki></code>
|-
| [[Go (programming language)|Go]]
| {{<code|><nowiki>byte}}</nowiki></code>, {{<code|><nowiki>rune}}</nowiki></code>
| {{<code|><nowiki>string}}</nowiki></code>
| {{<code|><nowiki>bool}}</nowiki></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|><nowiki>char}}</nowiki></code>
| {{<code|><nowiki>String}}</nowiki></code>
| {{<code|><nowiki>bool}}</nowiki></code>
| <code>enum ''name'' { ''item{{sub|1}}''« = ''value''», ''item{{sub|2}}''« = ''value''», ''...'' }</code>
| {{<code|><nowiki>std::any::Any}}</nowiki></code>
|-
| [[Swift (programming language)|Swift]]
| {{<code|><nowiki>Character}}</nowiki></code>
| {{<code|><nowiki>String}}</nowiki></code>
| {{<code|><nowiki>Bool}}</nowiki></code>
| <code>enum ''name'' { case ''item<sub>1</sub>'', ''item<sub>2</sub>'', ''...'' }</code>
| {{<code|><nowiki>Any}}</nowiki></code>
|-
| [[D (programming language)|D]]
| {{<code|><nowiki>char}}</nowiki></code>
| {{<code|><nowiki>string}}</nowiki></code>
| {{<code|><nowiki>bool}}</nowiki></code>
| <code>enum ''name'' { ''item<sub>1</sub>'', ''item<sub>2</sub>'', ''...'' }</code>
| {{<code|><nowiki>std.variant.Variant}}</nowiki></code>
|-
| [[Common Lisp]]
| {{<code|><nowiki>character}}</nowiki></code>
| {{<code|><nowiki>string}}</nowiki></code>
| {{<code|><nowiki>boolean}}</nowiki></code>
| <code>(member ''item<sub>1</sub>'' ''item<sub>2</sub>'' ''...'')</code>
| {{<code|><nowiki>t}}</nowiki></code>
|-
| [[Scheme (programming language)|Scheme]]
Line 965:
|-
| Pascal (ISO)
| rowspan=2| {{<code|><nowiki>char}}</nowiki></code>
| {{n/a}}
| rowspan=2| {{<code|><nowiki>boolean}}</nowiki></code>
| rowspan=2| <code>( ''item<sub>1</sub>'', ''item<sub>2</sub>'', ''...'' )</code>
| {{n/a}}
|-
| [[Object Pascal]] (Delphi)
| {{<code|><nowiki>string}}</nowiki></code>
| {{<code|><nowiki>variant}}</nowiki></code>
|-
| [[Visual Basic (classic)|Visual Basic]]
| {{n/a}}
| rowspan=3| {{<code|><nowiki>String}}</nowiki></code>
| rowspan=3| {{<code|><nowiki>Boolean}}</nowiki></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|><nowiki>[[Variant type|Variant]]}}</nowiki></code>
|-
| [[Visual Basic .NET]]
| {{<code|><nowiki>Char}}</nowiki></code>
| {{<code|><nowiki>Object}}</nowiki></code>
|-
| [[Xojo]]
| {{n/a}}
| {{<code|><nowiki>Object}}</nowiki></code> or {{<code|><nowiki>Variant}}</nowiki></code>
|-
| [[Python (programming language)|Python]]
| {{n/a}}{{ref|string as char|[d]}}
| {{<code|><nowiki>str}}</nowiki></code>
| {{<code|><nowiki>bool}}</nowiki></code>
| <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>
| {{<code|><nowiki>object}}</nowiki></code>
|-
| [[JavaScript]]
| {{n/a}}{{ref|string as char|[d]}}
| {{<code|><nowiki>String}}</nowiki></code>
| {{<code|><nowiki>Boolean}}</nowiki></code>
|
| {{<code|><nowiki>Object}}</nowiki></code>
|-
| [[S-Lang (programming language)|S-Lang]]
Line 1,016:
| <code>LOGICAL(KIND = n)</code>{{ref|logical kinds|[f]}}
|
| {{<code|><nowiki>CLASS(*)}}</nowiki></code>
|-
| [[PHP]]
| {{n/a}}{{ref|string as char|[d]}}
| {{<code|><nowiki>string}}</nowiki></code>
| {{<code|><nowiki>bool}}</nowiki></code>
|
| (type declaration omitted)
Line 1,030:
|
|
| {{<code|><nowiki>UNIVERSAL}}</nowiki></code>
|-
| [[Raku (programming language)|Raku]]
| {{<code|><nowiki>Char}}</nowiki></code>
| {{<code|><nowiki>Str}}</nowiki></code>
| {{<code|><nowiki>Bool}}</nowiki></code>
| <code>enum ''name<item<sub>1</sub> item<sub>2</sub> ...>''</code><br/><code>enum ''name <<:item<sub>1</sub>(value) :item<sub>2</sub>(value) ..>>''</code>
| {{<code|><nowiki>Mu}}</nowiki></code>
|-
| [[Ruby (programming language)|Ruby]]
| {{n/a}}{{ref|string as char|[d]}}
| {{<code|><nowiki>String}}</nowiki></code>
| {{<code|><nowiki>Object}}</nowiki></code>{{ref|Ruby's bool|[c]}}
|
| {{<code|><nowiki>Object}}</nowiki></code>
|-
| [[Scala (programming language)|Scala]]
| {{<code|><nowiki>Char}}</nowiki></code>
| {{<code|><nowiki>String}}</nowiki></code>
| {{<code|><nowiki>Boolean}}</nowiki></code>
| <code>object ''name'' extends Enumeration {<br/>{{Spaces|3}}''val item{{sub|1}}, item{{sub|2}}, ... = Value''<br/>}</code>
| {{<code|><nowiki>Any}}</nowiki></code>
|-
| [[Seed7]]
| {{<code|><nowiki>char}}</nowiki></code>
| {{<code|><nowiki>string}}</nowiki></code>
| {{<code|><nowiki>boolean}}</nowiki></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,068:
|-
| [[OCaml]]
| rowspan=3| {{<code|><nowiki>char}}</nowiki></code>
| rowspan=3| {{<code|><nowiki>string}}</nowiki></code>
| rowspan=3| {{<code|><nowiki>bool}}</nowiki></code>
| {{n/a}}{{ref|enum|[e]}}
| {{n/a}}
Line 1,076:
| [[F Sharp (programming language)|F#]]
| <code>type ''name'' = ''item<sub>1</sub>'' = ''value'' {{pipe}}''item<sub>2</sub>'' = ''value'' {{pipe}} ''...''</code>
| {{<code|><nowiki>obj}}</nowiki></code>
|-
| [[Standard ML]]
Line 1,083:
|-
| [[Haskell]] ([[Glasgow Haskell Compiler|GHC]])
| {{<code|><nowiki>Char}}</nowiki></code>
| {{<code|><nowiki>String}}</nowiki></code>
| {{<code|><nowiki>Bool}}</nowiki></code>
| {{n/a}}{{ref|enum|[e]}}
| {{n/a}}
|-
| [[Eiffel (programming language)|Eiffel]]
| {{<code|><nowiki>CHARACTER}}</nowiki></code>
| {{<code|><nowiki>STRING}}</nowiki></code>
| {{<code|><nowiki>BOOLEAN}}</nowiki></code>
| {{n/a}}
| {{<code|><nowiki>ANY}}</nowiki></code>
|-
| [[COBOL]]
| {{<code|><nowiki>PIC X}}</nowiki></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>
| {{n/a}}
| {{<code|><nowiki>OBJECT REFERENCE}}</nowiki></code>
|-
| [[Mathematica]]
| {{n/a}}{{ref|string as char|[d]}}
| {{<code|><nowiki>String}}</nowiki></code>
|
|
Line 1,113:
* {{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|><nowiki>TrueClass}}</nowiki></code>'' evaluates to true and everything in ''{{<code|><nowiki>FalseClass}}</nowiki></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|><nowiki>n}}</nowiki></code>'' is provided by the {{<code|><nowiki>SELECTED_INT_KIND}}</nowiki></code><ref name="fortranwiki.org" /> intrinsic function.
 
== Derived types ==
Line 1,203:
|- valign="top"
| [[Common Lisp]]
| {{<code|><nowiki>(simple-array type (dimension))|lisp}}</nowiki></code>
| {{<code|><nowiki>(simple-array type (dimension1 dimension2))|lisp}}</nowiki></code>
| {{<code|><nowiki>(array type (dimension))|lisp}}</nowiki></code>
| {{<code|><nowiki>(array type (dimension1 dimension2))|lisp}}</nowiki></code>
|- valign="top"
| [[Scheme (programming language)|Scheme]]
Line 1,339:
|}
 
* {{note|C's array|a}}In most expressions (except the <code>[[sizeof]]</code> and {{<code|><nowiki>&}}</nowiki></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|><nowiki>DEPENDING ON}}</nowiki></code> clause in COBOL does not create a ''true'' variable length array and will always allocate the maximum size of the array.
 
=== Other types ===
Line 1,419:
|-
| [[Common Lisp]]
| {{<code|><nowiki>(defstruct name slot-name (slot-name initial-value) (slot-name initial-value :type type) ...)|lisp}}</nowiki></code>
| rowspan=3| <code>(cons ''val{{sub|1}} val{{sub|2}}'')</code>{{ref|pair only|[c]}}
|
Line 1,529:
 
* {{note|just classes|a}} Only classes are supported.
* {{note|C++'s struct|b}} {{<code|><nowiki>struct}}</nowiki></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,619:
| rowspan=3| See notes to left.
Constants use the same syntax, and:
* use {{<code|><nowiki>Const}}</nowiki></code> instead of {{<code|><nowiki>Dim}}</nowiki></code>
* have a restriction to only certain primitive types<br/><code>Const ''name<sub>1</sub>'' «As ''type''» = ''value'', ''name<sub>2</sub>'' «As ''type»'' = ''value, ...''</code>
|
Line 1,626:
| The variable declaration syntax of VB.NET is unusually difficult to precisely describe.
Given that there exist the identifier suffixes ("modifiers"):
* {{<code|><nowiki>type_character}}</nowiki></code>, available as an alternative to an {{<code|><nowiki>As}}</nowiki></code> clause for some primitive data types;
* {{<code|><nowiki>nullable_specifier}}</nowiki></code>; and
* {{<code|><nowiki>array_specifier}}</nowiki></code>;
and that
* a {{<code|><nowiki>modified_identifier}}</nowiki></code> is of the form {{<code|><nowiki>identifier«type_character»«nullable_specifier»«array_specifier»}}</nowiki></code>;
* a {{<code|><nowiki>modified_identifier_list}}</nowiki></code> is a comma-separated list of two or more occurrences of {{<code|><nowiki>modified_identifier}}</nowiki></code>; and
* a {{<code|><nowiki>declarator_list}}</nowiki></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,638:
valid declaration statements are of the form
{{In5}}<code>Dim ''declarator_list''</code>,
where, for the purpose of semantic analysis, to convert the {{<code|><nowiki>declarator_list}}</nowiki></code> to a list of only single declarators:
* The {{<code|><nowiki>As}}</nowiki></code> clauses of each ''multiple declarator'' is distributed over its {{<code|><nowiki>modified_identifier_list}}</nowiki></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|><nowiki>identifier}}</nowiki></code>,
* a {{<code|><nowiki>type_character}}</nowiki></code> and {{<code|><nowiki>As}}</nowiki></code> clause do not both appear;
* if an {{<code|><nowiki>As}}</nowiki></code> clause is present,
** an {{<code|><nowiki>array_rank_specifier}}</nowiki></code> does not appear both as a modification of the identifier and on the type of the {{<code|><nowiki>As}}</nowiki></code> clause;
* an {{<code|><nowiki>unmodified_type}}</nowiki></code> can be determined, by the rule that,
** if a {{<code|><nowiki>type_character}}</nowiki></code> or {{<code|><nowiki>As}}</nowiki></code> clause is present,
*** {{<code|><nowiki>unmodified_type}}</nowiki></code> is that specified by such construct,
** and that otherwise,
*** either {{<code|><nowiki>Option Infer}}</nowiki></code> must be on and the {{<code|><nowiki>identifier}}</nowiki></code> must have an initializer, in which case {{<code|><nowiki>unmodified_type}}</nowiki></code> is that of the initializer, or
*** {{<code|><nowiki>Option Strict}}</nowiki></code> must be off, in which case {{<code|><nowiki>unmodified_type}}</nowiki></code> is {{<code|><nowiki>Object}}</nowiki></code>;
* its {{<code|><nowiki>final_type}}</nowiki></code> is its {{<code|><nowiki>unmodified_type}}</nowiki></code> prepended before its modifiers;
* its {{<code|><nowiki>final_type}}</nowiki></code> is a valid type; and
* if an {{<code|><nowiki>initial_value}}</nowiki></code> is present,
** either {{<code|><nowiki>Option Strict}}</nowiki></code> is on and {{<code|><nowiki>initial_value}}</nowiki></code> has a widening conversion to {{<code|><nowiki>final_type}}</nowiki></code>, or
** {{<code|><nowiki>Option Strict}}</nowiki></code> is off and {{<code|><nowiki>initial_value}}</nowiki></code> has a narrowing conversion to {{<code|><nowiki>final_type}}</nowiki></code>.
If {{<code|><nowiki>Option Explicit}}</nowiki></code> is off, variables do not require explicit declaration; they are declared implicitly when used:
{{<code|><nowiki>name {{=}} initial_value}}</nowiki></code>
| <code>Imports ''synonym'' = ''type''</code>
|-
Line 1,752:
* {{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|><nowiki>!}}</nowiki></code> and {{<code|><nowiki>:{{=}}}}</nowiki></code> 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|><nowiki>let}}</nowiki></code> or {{<code|><nowiki>let mut}}</nowiki></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|><nowiki>const}}</nowiki></code> or {{<code|><nowiki>static}}</nowiki></code> or {{<code|><nowiki>static mut}}</nowiki></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|><nowiki>const}}</nowiki></code> variables. After it is defined, a {{<code|><nowiki>static mut}}</nowiki></code> variable can only be assigned to in an {{<code|><nowiki>unsafe}}</nowiki></code> block or function.
 
== [[Control flow]] ==
Line 1,803:
|- valign="top"
| [[C (programming language)|C]] ([[C99]])
| rowspan=7| <code>if (''condition'') ''instructions''<br/>«else ''instructions''»</code><br/>{{<code|><nowiki>instructions}}</nowiki></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>
Line 1,822:
| [[C Sharp (programming language)|C#]]
| <code>if (''condition'') ''instructions''<br/>«else ''instructions''»</code>
{{<code|><nowiki>instructions}}</nowiki></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|><nowiki>break}}</nowiki></code> or {{<code|><nowiki>goto case}}</nowiki></code> statement (that is, they are not allowed to fall-through to the next case).
The {{<code|><nowiki>default}}</nowiki></code> case is not required to come last.
| <code>''condition'' [[?:|?]] ''valueIfTrue'' [[?:|:]] ''valueIfFalse''</code>
|- valign="top"
Line 1,901:
|- 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|><nowiki>instructions}}</nowiki></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|><nowiki>Else}}</nowiki></code> clause of a single-line {{<code|><nowiki>If}}</nowiki></code> statement can contain another single-line {{<code|><nowiki>If}}</nowiki></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>
Line 1,992:
* {{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|><nowiki>,}}</nowiki></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]] ===
Line 2,023:
|-
| [[C (programming language)|C]] ([[C99]])
| rowspan=9| {{<code|><nowiki>instructions}}</nowiki></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,130:
|-
| [[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|><nowiki>End While}}</nowiki></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|><nowiki>i}}</nowiki></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>
Line 2,395:
|}
 
* {{note|common lisp restarts|a}} Common Lisp allows {{<code|><nowiki>with-simple-restart}}</nowiki></code>, {{<code|><nowiki>restart-case}}</nowiki></code> and {{<code|><nowiki>restart-bind}}</nowiki></code> to define restarts for use with {{<code|><nowiki>invoke-restart}}</nowiki></code>. Unhandled conditions may cause the implementation to show a restarts menu to the user before unwinding the stack.
* {{note|Ada 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).
 
Line 2,418:
| <code>''value'' exit;</code> ...
| <code>do ''statements;'' skip exit; ''label: statements'' od</code>
| {{<code|><nowiki>label:}}</nowiki></code> ...
| <code>go to ''label; ...''<br/>goto ''label; ...<br/>label; ...''</code>
| <code>yield(value)</code>
Line 2,520:
|-
| [[Visual Basic (classic)|Visual Basic]]
| rowspan=3| <code>Exit ''block''</code>Alternatively, for methods,<br/>{{<code|><nowiki>Return}}</nowiki></code>
| {{n/a}}
| rowspan=3| <code>''label'':</code>
Line 2,554:
| <code>EXIT</code>
| <code>CYCLE</code>
| {{<code|><nowiki>label}}</nowiki></code>{{ref|Fortran label|[b]}}
| <code>GOTO ''label''</code>
| {{n/a}}
Line 2,644:
| Same as above; alternatively, if simple enough to be an expression:
<code>[[void type|void]] foo(''«parameters»'') => ''expression'';</code>
| <code>static void Main(«string[] args») method_body</code><br/>May instead return {{<code|><nowiki>int}}</nowiki></code>.<br/>(starting with C# 7.1:) May return {{<code|><nowiki>Task}}</nowiki></code> or {{<code|><nowiki>Task<int>}}</nowiki></code>, and if so, may be {{<code|><nowiki>async}}</nowiki></code>.
|- valign="top"
| [[JavaScript]]
Line 2,689:
| [[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|><nowiki>As}}</nowiki></code> clause is not required if {{<code|><nowiki>Option Strict}}</nowiki></code> is off. A type character may be used instead of the {{<code|><nowiki>As}}</nowiki></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>Sub Main(««ByVal »args() As String»){{indent|2}}''instructions''<br/>End Sub</code>or<br/><code>Function Main(««ByVal »args() As String») As Integer{{indent|2}}''instructions''<br/>End Function</code>
|- valign="top"
Line 2,814:
|}
 
* {{note|forward declaration|a}} Pascal requires "{{<code|><nowiki>forward;}}</nowiki></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|><nowiki>PARAMETER}}</nowiki></code> is a language keyword); the {{<code|><nowiki>CALL}}</nowiki></code> keyword is required for subroutines.
* {{note|COBOL calling programs|d}} Instead of using {{<code|><nowiki>"foo"}}</nowiki></code>, a string variable may be used instead containing the same value.
 
== [[Type conversion]]s{{anchor|Data conversions}} ==
Line 2,840:
| colspan=5 align=center| With prior declarations and association of: <code>string ''buf := "12345678.9012e34 ";'' file ''proxy; associate(proxy, buf);''</code>
|-
| {{<code|><nowiki>get(proxy, ivar);}}</nowiki></code>
| {{<code|><nowiki>get(proxy, livar);}}</nowiki></code>
| {{<code|><nowiki>get(proxy, rvar);}}</nowiki></code>
| {{<code|><nowiki>put(proxy, ival);}}</nowiki></code>
| {{<code|><nowiki>put(proxy, rval);}}</nowiki></code>
|-
| {{<code|><nowiki>getf(proxy, ($g$, ivar));}}</nowiki></code><br/>or<br/>{{<code|><nowiki>getf(proxy, ($dddd$, ivar));}}</nowiki></code>
| {{<code|><nowiki>getf(proxy, ($g$, livar));}}</nowiki></code><br/>or<br/>{{<code|><nowiki>getf(proxy, ($8d$, livar));}}</nowiki></code>
| {{<code|><nowiki>getf(proxy, ($g$, rvar));}}</nowiki></code><br/>or<br/>{{<code|><nowiki>getf(proxy, ($8d.4dE2d$, rvar));}}</nowiki></code>
| {{<code|><nowiki>putf(proxy, ($g$, ival));}}</nowiki></code><br/>or<br/>{{<code|><nowiki>putf(proxy, ($4d$, ival));}}</nowiki></code>
| {{<code|><nowiki>putf(proxy, ($g(width, places, exp)$, rval));}}</nowiki></code><br/>or<br/>{{<code|><nowiki>putf(proxy, ($8d.4dE2d$, rval));}}</nowiki></code>
|-
| [[APL (programming language)|APL]]
Line 3,044:
* {{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|><nowiki>NUMVAL-C}}</nowiki></code> or {{<code|><nowiki>NUMVAL-F}}</nowiki></code> may be used instead of {{<code|><nowiki>NUMVAL}}</nowiki></code>.
* {{note|Rust type conversion}} [https://doc.rust-lang.org/stable/std/primitive.str.html#method.parse {{<code|><nowiki>str::parse}}</nowiki></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|><nowiki>std::str::FromStr}}</nowiki></code>] trait. Both {{<code|><nowiki>str::parse}}</nowiki></code> and [https://doc.rust-lang.org/stable/std/str/trait.FromStr.html#tymethod.from_str {{<code|><nowiki>FromStr::from_str}}</nowiki></code>] return a [[result type|{{<code|><nowiki>Result}}</nowiki></code>]] that contains the specified type if there is no error. The [[turbofish]] ({{<code|><nowiki>::<_>}}</nowiki></code>) on {{<code|><nowiki>str::parse}}</nowiki></code> can be omitted if the type can be inferred from context.
 
== [[Standard streams|Standard stream I/O]] ==
Line 3,099:
|-
| [[Java (programming language)|Java]]
| {{<code|2=java|1=><nowiki>x = System.in.read();}}</nowiki></code><br/>or<br/>{{<code|2=java|1=><nowiki>x = new Scanner(System.in).nextInt();}}</nowiki></code><br/>or<br/>{{<code|2=java|1=><nowiki>x = new Scanner(System.in).nextLine();}}</nowiki></code>
| <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=go|1=><nowiki>x = bufio.NewReader(os.Stdin).ReadString('\n')}}</nowiki></code>
| <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>
Line 3,129:
|-
| [[Common Lisp]]
| {{<code|><nowiki>(setf x (read-line))|lisp}}</nowiki></code>
| <code>(princ ''x'')</code><br/>or<br/><code>(format t ''format x'')</code>
| {{<code|><nowiki>(princ x *error-output*)|lisp}}</nowiki></code><br/>or<br/><code>{{codett|(format *error-output*|lisp}} ''format x'')</code>
|-
| [[Scheme (programming language)|Scheme]] ([[R6RS|R<sup>6</sup>RS]])
| {{<code|><nowiki>(define x (read-line))|scheme}}</nowiki></code>
| <code>(display ''x'')</code><br/>or<br/><code>{{codett|(format #t|scheme}} ''format x'')</code>
| {{<code|><nowiki>(display x (current-error-port))|scheme}}</nowiki></code><br/>or<br/><code>{{codett|(format (current-error-port)|scheme}} ''format x'')</code>
|-
| [[ISLISP]]
| {{<code|><nowiki>(setf x (read-line))|lisp}}</nowiki></code>
| <code>{{codett|(format (standard-output)|lisp}} ''format x'')</code>
| <code>{{codett|(format (error-output)|lisp}} ''format x'')</code>
Line 3,199:
|-
| [[Raku (programming language)|Raku]]
| {{<code|2=raku|1=><nowiki>$x = $*IN.get;}}</nowiki></code>
| <code>''x''.print</code><br/>or<br/><code>''x''.say</code>
| <code>''x''.note</code><br/>or<br/>{{<code|2=raku|1=><nowiki>$*ERR.print(x)}}</nowiki></code><br/>or<br/>{{<code|2=raku|1=><nowiki>$*ERR.say(x)}}</nowiki></code>
|-
| [[Ruby (programming language)|Ruby]]
| <code>''x'' = gets</code>
| <code>puts ''x''</code><br/>or<br/><code>[[printf]](''format'', ''x'')</code>
| {{<code|2=ruby|1=><nowiki>$stderr.puts(x)}}</nowiki></code><br/>or<br/><code>$stderr.[[printf]](''format'', ''x'')</code>
|-
| [[Windows PowerShell]]
| <code>''$x'' = Read-Host«« -Prompt» ''text''»;</code><br/>or<br/>{{<code|2=ps1|1=><nowiki>$x = [Console]::Read();}}</nowiki></code><br/>or<br/>{{<code|2=ps1|1=><nowiki>$x = [Console]::ReadLine()}}</nowiki></code>
| <code>''x'';</code><br/>or<br/><code>Write-Output ''x'';</code><br/>or<br/><code>echo ''x''</code>
| <code>Write-Error ''x''</code>
Line 3,219:
|-
| [[F Sharp (programming language)|F#]]
| {{<code|2=f#|1=><nowiki>let x = System.Console.ReadLine()}}</nowiki></code>
| <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=sml|1=><nowiki>val str = TextIO.inputLIne TextIO.stdIn}}</nowiki></code>
| <code>print ''str''</code>
| <code>{{codett|TextIO.output (TextIO.stdErr,|sml}}'' str'')</code>
Line 3,306:
|-
| [[Scheme (programming language)|Scheme]] ([[R6RS|R<sup>6</sup>RS]])
| {{<code|><nowiki>(list-ref (command-line) n)|scheme}}</nowiki></code>
| {{<code|><nowiki>(length (command-line))|scheme}}</nowiki></code>
| first argument
|-
Line 3,405:
|}
 
* {{note|Rust args|a}} In Rust, {{<code|><nowiki>std::env::args}}</nowiki></code> and {{<code|><nowiki>std::env::args_os}}</nowiki></code> return iterators, {{<code|><nowiki>std::env::Args}}</nowiki></code> and {{<code|><nowiki>std::env::ArgsOs}}</nowiki></code> respectively. {{<code|><nowiki>Args}}</nowiki></code> converts each argument to a {{<code|><nowiki>String}}</nowiki></code> and it panics if it reaches an argument that cannot be converted to [[UTF-8]]. {{<code|><nowiki>ArgsOs}}</nowiki></code> returns a non-lossy representation of the raw strings from the operating system ({{<code|><nowiki>std::ffi::OsString}}</nowiki></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|><nowiki>ACCEPT}}</nowiki></code> statements.
 
== Execution of commands ==
Line 3,428:
|-
| [[Objective-C]]
| {{<code|><nowiki>[NSTask launchedTaskWithLaunchPath:(NSString *)path arguments:(NSArray *)arguments];|objectivec}}</nowiki></code>
|
|-
Line 3,467:
| [[Java (programming language)|Java]]
|
| <code>Runtime.exec(''command'');</code><br/>or<br/>{{<code|><nowiki>new ProcessBuilder(command).start();|java}}</nowiki></code>
|
|-
Line 3,541:
|-
| [[Windows PowerShell]]
| {{<code|><nowiki>[Diagnostics.Process]::Start(command)|ps1}}</nowiki></code>
| <code>«Invoke-Item »''program arg1 arg2 ...''</code>
|
Line 3,547:
| [[Bash shell]]
| <code>''output''=`''command''`</code><br/>or<br/><code>''output''=$(''command'')</code>
| {{<code|><nowiki>program arg1 arg2 ...}}</nowiki></code>
|
|}
Retrieved from "https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(basic_instructions)"