Generally, var, var, or var is how variable names or other non-literal values to be interpreted by the reader are represented. The rest is literal code. Guillemets (« and ») enclose optional sections. Tab ↹ indicates a necessary (whitespace) indentation.
The tables are not sorted lexicographically ascending by programming language name by default, and that some languages have entries in some tables but not others.
^a The standard constants int shorts and int lengths can be used to determine how many shorts and longs can be usefully prefixed to short int and long int. The actual sizes of short int, int, and long int are available as the constants short max int, max int, and long max int etc.
^c The ALGOL 68, C and C++ languages do not specify the exact width of the integer types short, int, long, and (C99, C++11) long long, so they are implementation-dependent. In C and C++ short, long, and long long types are required to be at least 16, 32, and 64 bits wide, respectively, but can be more. The int type is required to be at least as wide as short and at most as wide as long, and is typically the width of the word size on the processor of the machine (i.e. on a 32-bit machine it is often 32 bits wide; on 64-bit machines it is sometimes 64 bits wide). C99 and C++11[citation needed] also define the [u]intN_t exact-width types in the stdint.h header. See C syntax#Integral types for more information. In addition the types size_t and ptrdiff_t are defined in relation to the address size to hold unsigned and signed integers sufficiently large to handle array indices and the difference between pointers.
^d Perl 5 does not have distinct types. Integers, floating point numbers, strings, etc. are all considered "scalars".
^e PHP has two arbitrary-precision libraries. The BCMath library just uses strings as datatype. The GMP library uses an internal "resource" type.
^f The value of n is provided by the SELECTED_INT_KIND[4] intrinsic function.
^gALGOL 68G's runtime option --precision "number" can set precision for long long ints to the required "number" significant digits. The standard constants long long int width and long long max int can be used to determine actual precision.
^hCOBOL allows the specification of a required precision and will automatically select an available type capable of representing the specified precision. "PIC S9999", for example, would require a signed variable of four decimal digits precision. If specified as a binary field, this would select a 16-bit signed type on most platforms.
^iSmalltalk automatically chooses an appropriate representation for integral numbers. Typically, two representations are present, one for integers fitting the native word size minus any tag bit (SmallInteger) and one supporting arbitrary sized integers (LargeInteger). Arithmetic operations support polymorphic arguments and return the result in the most appropriate compact representation.
^jAda range types are checked for boundary violations at run-time (as well as at compile-time for static expressions). Run-time boundary violations raise a "constraint error" exception. Ranges are not restricted to powers of two. Commonly predefined Integer subtypes are: Positive (range 1 .. Integer'Last) and Natural (range 0 .. Integer'Last). Short_Short_Integer (8 bits), Short_Integer (16 bits) and Long_Integer (64 bits) are also commonly predefined, but not required by the Ada standard. Runtime checks can be disabled if performance is more important than integrity checks.
^kAda modulo types implement modulo arithmetic in all operations, i.e. no range violations are possible. Modulos are not restricted to powers of two.
^mint in PHP has the same width as long type in C has on that system.[c]
^nErlang is dynamically typed. The type identifiers are usually used to specify types of record fields and the argument and return types of functions.[5]
^a The standard constants real shorts and real lengths can be used to determine how many shorts and longs can be usefully prefixed to short real and long real. The actual sizes of short real, real, and long real are available as the constants short max real, max real and long max real etc. With the constants short small real, small real and long small real available for each type's machine epsilon.
^b declarations of single precision often are not honored
^c The value of n is provided by the SELECTED_REAL_KIND[8] intrinsic function.
^dALGOL 68G's runtime option --precision "number" can set precision for long long reals to the required "number" significant digits. The standard constants long long real width and long long max real can be used to determine actual precision.
^e These IEEE floating-point types will be introduced in the next COBOL standard.
level-number type OCCURS min-size TO max-size «TIMES» DEPENDING «ON» size.[e]
—
^aIn most expressions (except the sizeof and & operators), values of array types in C are automatically converted to a pointer of its first argument. See C syntax#Arrays for further details of syntax and pointer operations.
^b The C-like type x[] works in Java, however type[] x is the preferred form of array declaration.
^c Subranges are used to define the bounds of the array.
^d JavaScript's array are a special kind of object.
^e The DEPENDING ON clause in COBOL does not create a true variable length array and will always allocate the maximum size of the array.
type name is «abstract» «tagged» «limited» [record field1: type; field2: type; ... end record | null record]
—
Any combination of records, unions, and enumerations (as well as references to those, enabling recursive types).
type name (variation: discrete_type) is record case variation is when choice_list1 => fieldname1: type; ... when choice_list2 => fieldname2: type; ... ... end case; end record
abstract class name case class Foo(«parameters») extends name case class Bar(«parameters») extends name ... or abstract class name case object Foo extends name case object Bar extends name ... or a combination of case classes and case objects
^bstructs in C++ are actually classes, but have default public visibility and are also POD objects. C++11 extended this further, to make classes act identically to POD objects in many more cases.
^d Although Perl doesn't have records, because Perl's type system allows different data types to be in an array, "hashes" (associative arrays) that don't have a variable index would effectively be the same as records.
^e Enumerations in this language are algebraic types with only nullary constructors
valid declaration statements are of the form Dim declarator_list, where, for the purpose of semantic analysis, to convert the declarator_list to a list of only single declarators:
The As clauses of each multiple declarator is distributed over its modified_identifier_list
The As New type... of each object initializer declarator is replaced with As type = New type...
and for which, for each identifier,
a type_character and As clause do not both appear;
if an As clause is present,
an array_rank_specifier does not appear both as a modification of the identifier and on the type of the As clause;
an unmodified_type can be determined, by the rule that,
if a type_character or As clause is present,
unmodified_type is that specified by such construct,
and that otherwise,
either Option Infer must be on and the identifier must have an initializer, in which case unmodified_type is that of the initializer, or
Option Strict must be off, in which case unmodified_type is Object;
its final_type is its unmodified_type prepended before its modifiers;
its final_type is a valid type; and
if an initial_value is present,
either Option Strict is on and initial_value has a widening conversion to final_type, or
Option Strict is off and initial_value has a narrowing conversion to final_type.
If Option Explicit is off, variables do not require explicit declaration; they are declared implicitly when used: name = initial_value
^bTypes are just regular objects, so you can just assign them.
^c In Perl, the "my" keyword scopes the variable into the block.
^d Technically, this does not declare name to be a mutable variable—in ML, all names can only be bound once; rather, it declares name to point to a "reference" data structure, which is a simple mutable cell. The data structure can then be read and written to using the ! and := operators, respectively.
^e If no initial value is given, an invalid value is automatically assigned (which will trigger a run-time exception if it used before a valid value has been assigned). While this behaviour can be suppressed it is recommended in the interest of predictability. If no invalid value can be found for a type (for example in case of an unconstraint integer type), a valid, yet predictable value is chosen instead.
^f In Rust, if no initial value is given to a let or let mut variable and it is never assigned to later, there is an "unused variable" warning. If no value is provided for a const or static or static mut variable, there is an error. There is a "non-upper-case globals" error for non-uppercase const variables. After it is defined, a static mut variable can only be assigned to in an unsafe block or function.
if condition then statements «else statements» end if
if condition1 then statements elsif condition2 then statements ... «else statements» end if
case expression is when value_list1 => statements when value_list2 => statements ... «when others => statements» end case
(if condition1 then expression1 «elsif condition2 then expression2» ... else expressionn ) or (case expression is when value_list1 => expression1 when value_list2 => expression2 ... «when others => expressionn» )
if (condition) instructions «else instructions» instructions can be a single statement or a block in the form of: { statements }
if (condition) instructions else if (condition) instructions ... «else instructions» or if (condition) instructions else { if (condition) instructions }
All non-empty cases must end with a break or goto case statement (that is, they are not allowed to fall-through to the next case). The default case is not required to come last.
if condition {instructions} else if condition {instructions} ... «else {instructions}» or switch { case condition: instructions ... «default: instructions» }
switch variable { case case1: instructions ... «default: instructions» }
If condition Then instructions «Else instructions» End If Single-line, when instructions are instruction1: instruction2: ...: If condition Then instructions «Else instructions»
If condition Then instructions ElseIf condition Then instructions ... «Else instructions» End If Single-line: See note about C-like languages; the Else clause of a single-line If statement can contain another single-line If statement.
Select«Case» variable Case case_pattern1 instructions ... «Case Else instructions» End Select
Either on a single line or with indentation as shown below: if condition then Tab ↹instructions «else Tab ↹instructions» Verbose syntax mode: Same as Standard ML.
Lightweight syntax mode: Either on a single line or with indentation as shown below: if condition then Tab ↹instructions elif condition then Tab ↹instructions ... «else Tab ↹instructions» Verbose syntax mode: Same as Standard ML.
if condition then expression «else expression» or if condition expression «else expression» or expression if condition or unless condition expression «else expression» or expression unless condition
if condition then expression else if condition then expression «else expression» or if condition expression else if condition expression «else expression» or unless condition expression else unless condition expression «else expression»
switch expression when condition then expression else expression or switch expression when condition expression «else expression»
^a A single instruction can be written on the same line following the colon. Multiple instructions are grouped together in a block which starts on a newline (The indentation is required). The conditional expression syntax does not follow this rule.
^c In languages of the Pascal family, the semicolon is not part of the statement. It is a separator between statements, not a terminator.
^dEND-IF may be used instead of the period at the end.
^e In Rust, the comma (,) at the end of a match arm can be omitted after the last match arm, or after any match arm in which the expression is a block (ends in possibly empty matching brackets {}).
(loop while condition do instructions) or (do () (notcondition) instructions)
(loop do instructions while condition)
(loop for i from first to last «by 1» do instructions) or (dotimes (i N) instructions) or (do ((i first (1+ i))) ((>=i last))
instructions)
(loop for item in list do instructions) or (loop for item across vector do instructions) or (dolist (item list) instructions) or (mapc function list) or (map type function sequence)
Do While condition instructions Loop or Do Until notcondition instructions Loop or While condition instructions Wend (Visual Basic .NET uses End While instead)
Do instructions Loop While condition or Do instructions Loop Until notcondition
i must be declared beforehand.
For i = first To last «Step 1» instructions Next i
while condition: Tab ↹instructions «else: Tab ↹instructions»
—
Python 3.x: for i in range(first, last+1): Tab ↹instructions «else: Tab ↹instructions» Python 2.x: for i in xrange(first, last+1): Tab ↹instructions «else: Tab ↹instructions»
for item in set: Tab ↹instructions «else: Tab ↹instructions»
while condition expression or expression while condition or while condition then expression or until condition expression or expression until condition or until expression then condition
—
for i in [first..last] expression or for i in [first..last] then expression or expression for i in [first..last]
for item in set expression or for item in set then expression or expression for item in set
PERFORM procedure-1 «THROUGH procedure-2» ««WITH» TEST BEFORE» UNTIL condition[c] or PERFORM ««WITH» TEST BEFORE» UNTIL condition expression END-PERFORM
PERFORM procedure-1 «THROUGH procedure-2» «WITH» TEST AFTER UNTIL condition[c] or PERFORM «WITH» TEST AFTER UNTIL condition expression END-PERFORM
PERFORM procedure-1 «THROUGH procedure-2» VARYING i FROM first BY increment UNTIL i > last[d] or PERFORM VARYING i FROM first BY increment UNTIL i > last expression END-PERFORM[d]
With New Try: On Error Resume Next OneInstruction .Catch: On Error GoTo 0: Select Case .Number Case SOME_ERRORNUMBER instructions End Select: End With
'*** Try class ***PrivatemstrDescriptionAsStringPrivatemlngNumberAsLongPublicSubCatch()mstrDescription=Err.DescriptionmlngNumber=Err.NumberEndSubPublicPropertyGetNumber()AsLongNumber=mlngNumberEndPropertyPublicPropertyGetDescription()AsStringDescription=mstrDescriptionEndProperty
USE «AFTER» EXCEPTION OBJECT class-name. or USE «AFTER» EO class-name. or USE «AFTER» EXCEPTION CONDITION exception-name «FILE file-name». or USE «AFTER» EC exception-name «FILE file-name».
^a Common Lisp allows with-simple-restart, restart-case and restart-bind to define restarts for use with invoke-restart. Unhandled conditions may cause the implementation to show a restarts menu to the user before unwinding the stack.
^b Uncaught exceptions are propagated to the innermost dynamically enclosing execution. Exceptions are not propagated across tasks (unless these tasks are currently synchronised in a rendezvous).
int main(«char[][] args») { instructions} or int main(«string[] args») { instructions} or void main(«char[][] args») { instructions} or void main(«string[] args») { instructions}
function foo(«parameters») { instructions } or var foo = function («parameters») { instructions } or var foo = new Function ("«parameter»", ..., "«last parameter»" "instructions");
function foo(«parameters») { instructions ... return value; }
procedure foo«(parameters)»; «forward;»[a] «label label declarations» «const constant declarations» «type type declarations» «var variable declarations» «local function declarations» begin instructions end;
function foo«(parameters)»: type; «forward;»[a] «label label declarations» «const constant declarations» «type type declarations» «var variable declarations» «local function declarations» begin instructions; foo:= value end;
program name; «label label declarations» «const constant declarations» «type type declarations» «var variable declarations» «function declarations» begin instructions end.
Function Foo«(parameters)»«As type» instructions Return value End Function The As clause is not required if Option Strict is off. A type character may be used instead of the As clause. If control exits the function without a return value having been explicitly specified, the function returns the default value for the return type.
Sub Main(««ByVal »args() As String») instructions End Subor Function Main(««ByVal »args() As String») As Integer instructions End Function
^b Eiffel allows the specification of an application's root class and feature.
^c In Fortran, function/subroutine parameters are called arguments (since PARAMETER is a language keyword); the CALL keyword is required for subroutines.
^d Instead of using "foo", a string variable may be used instead containing the same value.
^a JavaScript only uses floating point numbers so there are some technicalities.[7]
^b Perl doesn't have separate types. Strings and numbers are interchangeable.
^cNUMVAL-C or NUMVAL-F may be used instead of NUMVAL.
^str::parse is available to convert any type that has an implementation of the std::str::FromStr trait. Both str::parse and FromStr::from_str return a Result that contains the specified type if there is no error. The turbofish (::<_>) on str::parse can be omitted if the type can be inferred from context.
^a In Rust, std::env::args and std::env::args_os return iterators, std::env::Args and std::env::ArgsOs respectively. Args converts each argument to a String and it panics if it reaches an argument that cannot be converted to UTF-8. ArgsOs returns a non-lossy representation of the raw strings from the operating system (std::ffi::OsString), which can be invalid UTF-8.
^b In Visual Basic, command-line arguments are not separated. Separating them requires a split function Split(string).
^c The COBOL standard includes no means to access command-line arguments, but common compiler extensions to access them include defining parameters for the main program or using ACCEPT statements.
In computer science and computer programming, a data type is a collection or grouping of data values, usually specified by a set of possible values, a set of allowed operations on these values, and/or a representation of these values as machine types. A data type specification in a program constrains the possible values that an expression, such as a variable or a function call, might take. On literal data, it tells the compiler or interpreter how the programmer intends to use the data. Most programming languages support basic data types of integer numbers, floating-point numbers, characters and Booleans.
In object-oriented (OO) and functional programming, an immutable object is an object whose state cannot be modified after it is created. This is in contrast to a mutable object, which can be modified after it is created. In some cases, an object is considered immutable even if some internally used attributes change, but the object's state appears unchanging from an external point of view. For example, an object that uses memoization to cache the results of expensive computations could still be considered an immutable object.
In mathematics and computer science, a higher-order function (HOF) is a function that does at least one of the following:
In computer science, a type signature or type annotation defines the inputs and outputs of a function, subroutine or method. A type signature includes the number, types, and order of the function's arguments. One important use of a type signature is for function overload resolution, where one particular definition of a function to be called is selected among many overloaded forms.
In computer science, primitive data types are a set of basic data types from which all other data types are constructed. Specifically it often refers to the limited set of data representations in use by a particular processor, which all compiled programs must use. Most processors support a similar set of primitive data types, although the specific representations vary. More generally, "primitive data types" may refer to the standard data types built into a programming language. Data types which are not primitive are referred to as derived or composite.
The syntax of the C programming language is the set of rules governing writing of software in C. It is designed to allow for programs that are extremely terse, have a close relationship with the resulting object code, and yet provide relatively high-level data abstraction. C was the first widely successful high-level language for portable operating-system development.
In computer science, a pointer is an object in many programming languages that stores a memory address. This can be that of another value located in computer memory, or in some cases, that of memory-mapped computer hardware. A pointer references a location in memory, and obtaining the value stored at that location is known as dereferencing the pointer. As an analogy, a page number in a book's index could be considered a pointer to the corresponding page; dereferencing such a pointer would be done by flipping to the page with the given page number and reading the text found on that page. The actual format and content of a pointer variable is dependent on the underlying computer architecture.
In computer science, a union is a value that may have any of several representations or formats within the same position in memory; that consists of a variable that may hold such a data structure. Some programming languages support special data types, called union types, to describe such values and variables. In other words, a union type definition will specify which of a number of permitted primitive types may be stored in its instances, e.g., "float or long integer". In contrast with a record, which could be defined to contain both a float and an integer; in a union, there is only one value at any given time.
In computer programming, a function object is a construct allowing an object to be invoked or called as if it were an ordinary function, usually with the same syntax. In some languages, particularly C++, function objects are often called functors.
In computer programming, the ternary conditional operator is a ternary operator that is part of the syntax for basic conditional expressions in several programming languages. It is commonly referred to as the conditional operator, ternary if, or inline if. An expression a ? b : c evaluates to b if the value of a is true, and otherwise to c. One can read it aloud as "if a then b otherwise c". The form a ? b : c is by far and large the most common, but alternative syntaxes do exist; for example, Raku uses the syntax a ?? b !! c to avoid confusion with the infix operators ? and !, whereas in Visual Basic .NET, it instead takes the form If(a, b, c).
In mathematics and in computer programming, a variadic function is a function of indefinite arity, i.e., one which accepts a variable number of arguments. Support for variadic functions differs widely among programming languages.
The computer programming languages C and Pascal have similar times of origin, influences, and purposes. Both were used to design their own compilers early in their lifetimes. The original Pascal definition appeared in 1969 and a first compiler in 1970. The first version of C appeared in 1972.
In the C programming language, data types constitute the semantics and characteristics of storage of data elements. They are expressed in the language syntax in form of declarations for memory locations or variables. Data types also determine the types of operations or methods of processing of data elements.
String functions are used in computer programming languages to manipulate a string or query information about a string.
A class in C++ is a user-defined type or data structure declared with any of the keywords class, struct or union that has data and functions as its members whose access is governed by the three access specifiers private, protected or public. By default access to members of a C++ class declared with the keyword class is private. The private members are not accessible outside the class; they can be accessed only through member functions of the class. The public members form an interface to the class and are accessible outside the class.
sizeof is a unary operator in the programming languages C and C++. It generates the storage size of an expression or a data type, measured in the number of char-sized units. Consequently, the construct sizeof (char) is guaranteed to be 1. The actual number of bits of type char is specified by the preprocessor macro CHAR_BIT, defined in the standard include file limits.h. On most modern computing platforms this is eight bits. The result of sizeof has an unsigned integer type that is usually denoted by size_t.
C++11 is a version of the ISO/IEC 14882 standard for the C++ programming language. C++11 replaced the prior version of the C++ standard, called C++03, and was later replaced by C++14. The name follows the tradition of naming language versions by the publication year of the specification, though it was formerly named C++0x because it was expected to be published before 2010.
This is an overview of Fortran 95 language features. Included are the additional features of TR-15581:Enhanced Data Type Facilities, which have been universally implemented. Old features that have been superseded by new ones are not described – few of those historic features are used in modern programs although most have been retained in the language to maintain backward compatibility. The current standard is Fortran 2023; many of its new features are still being implemented in compilers.
In computer programming, an anonymous function is a function definition that is not bound to an identifier. Anonymous functions are often arguments being passed to higher-order functions or used for constructing the result of a higher-order function that needs to return a function. If the function is only used once, or a limited number of times, an anonymous function may be syntactically lighter than using a named function. Anonymous functions are ubiquitous in functional programming languages and other languages with first-class functions, where they fulfil the same role for the function type as literals do for other data types.
SUPER BASIC, sometimes SBASIC for short, is an advanced dialect of the BASIC programming language offered on Tymshare's SDS 940 systems starting in 1968 and available well into the 1970s.
This page is based on this Wikipedia article Text is available under the CC BY-SA 4.0 license; additional terms may apply. Images, videos and audio are available under their respective licenses.
