Difference between revisions of "Category:Types"
m (7 revisions imported) |
|||
(5 intermediate revisions by the same user not shown) | |||
Line 1: | Line 1: | ||
+ | <metadesc>Mesham is a type oriented programming language allowing the writing of high performance parallel codes which are efficient yet simple to write and maintain</metadesc> | ||
== Overview == | == Overview == | ||
− | A type can follow a number of different syntactic forms. The abstract syntax of a type is detailed in the table below. Where ''elementtype'' is defined in the type library, ''varname'' represents a variable | + | A type can follow a number of different syntactic forms. The abstract syntax of a type is detailed in the table below. Where ''elementtype'' is defined in the type library, ''varname'' represents the current type of a variable and ''type :: type'' represents type combination to coerce into a new supertype. |
type = elementtype | type = elementtype | ||
Line 8: | Line 9: | ||
| varname | | varname | ||
− | Compound types | + | All element types start with a capitalised first letter and there must be at least one element type per type chain. Compound types start with a small case and contain a number of different subcategories of type |
compoundtype = attribute | compoundtype = attribute | ||
Line 18: | Line 19: | ||
| distribution | | distribution | ||
| composition | | composition | ||
− | + | ||
+ | Types may be referred to with or without arguments, it is therefore optional to specify square braces, ''[]'' after a type with or without data in. | ||
== Declarations == | == Declarations == | ||
Line 28: | Line 30: | ||
Where ''type'', as explained, is an ''elementtype'', a ''compoundtype'', variable name or ''type :: type''. The operator '':'' sets the type and ''::'' is type combination (coercion). | Where ''type'', as explained, is an ''elementtype'', a ''compoundtype'', variable name or ''type :: type''. The operator '':'' sets the type and ''::'' is type combination (coercion). | ||
− | === Semantics == | + | === Semantics === |
This will declare a variable to be a specific type. Type combination is subject to a number of semantic rules. If no type information is given, then the type will be found via inference where possible. | This will declare a variable to be a specific type. Type combination is subject to a number of semantic rules. If no type information is given, then the type will be found via inference where possible. | ||
Line 34: | Line 36: | ||
=== Examples === | === Examples === | ||
− | var i:Int :: allocated[multiple[]]; | + | function void main() { |
+ | var i:Int :: allocated[multiple[]]; | ||
+ | }; | ||
Here the variable ''i'' is declared to be integer, allocated to all processes. There are three types included in this declaration, the element type [[Int]] and the compound types [[allocated]] and [[multiple]]. The type [[multiple]] is provided as an argument to the allocation type [[allocated]], which is then combined with the [[Int]] type. | Here the variable ''i'' is declared to be integer, allocated to all processes. There are three types included in this declaration, the element type [[Int]] and the compound types [[allocated]] and [[multiple]]. The type [[multiple]] is provided as an argument to the allocation type [[allocated]], which is then combined with the [[Int]] type. | ||
− | var m:String; | + | function void main() { |
+ | var m:String; | ||
+ | }; | ||
In this example, variable ''m'' is declared to be of type [[String]]. For programmer convenience, by default, the language will automatically assume to combine this with ''allocated[multiple]'' if such allocation type is missing. | In this example, variable ''m'' is declared to be of type [[String]]. For programmer convenience, by default, the language will automatically assume to combine this with ''allocated[multiple]'' if such allocation type is missing. | ||
− | + | == Statements == | |
=== Syntax === | === Syntax === | ||
Line 50: | Line 56: | ||
=== Semantics === | === Semantics === | ||
− | Will modify the type of an already declared variable via the '':'' operator. Note, allocation information may not be changed. | + | Will modify the type of an already declared variable via the '':'' operator. Note, allocation information (via the ''allocation'' type) may not be changed. Type modification such as this binds to the current block, the type is reverted back to its previous value once that block has been left. |
=== Examples === | === Examples === | ||
− | var i:Int :: allocated[multiple[]]; | + | function void main() { |
− | + | var i:Int :: allocated[multiple[]]; | |
− | + | i:=23; | |
+ | i:i :: const[]; | ||
+ | }; | ||
Here the variable ''i'' is declared to be [[Int|integer]], [[allocated]] to all processes and its value is set to 23. Later on in the code the type is modified to set it also to be [[const|constant]] (so from this point on the programmer may not change the variable's value.) In this third line ''i:i :: const[];'' sets the type of ''i'' to be that of ''i'' combined with the [[const]] type.\twolines{} | Here the variable ''i'' is declared to be [[Int|integer]], [[allocated]] to all processes and its value is set to 23. Later on in the code the type is modified to set it also to be [[const|constant]] (so from this point on the programmer may not change the variable's value.) In this third line ''i:i :: const[];'' sets the type of ''i'' to be that of ''i'' combined with the [[const]] type.\twolines{} | ||
Line 70: | Line 78: | ||
=== Semantics === | === Semantics === | ||
− | When used as an expression, a variable's type can be coerced with additional types just for that expression. | + | When used as an expression, a variable's current type can be coerced with additional types just for that expression. |
=== Example === | === Example === | ||
− | var i:Int :: allocated[multiple[]]; | + | function void main() { |
− | + | var i:Int :: allocated[multiple[]]; | |
− | + | (i :: channel[1,2]):=82; | |
+ | i:=12; | ||
+ | }; | ||
This code will declare ''i'' to be an [[Int|integer]], [[allocated]] on all processes. On line 2 ''i :: channel[1,2]'' will combine the [[channel]] type (primitive communication) just for that assignment and then on line 3 the assignment happens as a normal integer. This is because on line 2 we have not set the type of ''i'', just modified it for that assignment. | This code will declare ''i'' to be an [[Int|integer]], [[allocated]] on all processes. On line 2 ''i :: channel[1,2]'' will combine the [[channel]] type (primitive communication) just for that assignment and then on line 3 the assignment happens as a normal integer. This is because on line 2 we have not set the type of ''i'', just modified it for that assignment. | ||
[[Category:Core Mesham]] | [[Category:Core Mesham]] |
Latest revision as of 15:44, 15 April 2019
Contents
Overview
A type can follow a number of different syntactic forms. The abstract syntax of a type is detailed in the table below. Where elementtype is defined in the type library, varname represents the current type of a variable and type :: type represents type combination to coerce into a new supertype.
type = elementtype | compoundtype | type :: type | varname
All element types start with a capitalised first letter and there must be at least one element type per type chain. Compound types start with a small case and contain a number of different subcategories of type
compoundtype = attribute | allocation | collection | primitive communication | communication mode | partition | distribution | composition
Types may be referred to with or without arguments, it is therefore optional to specify square braces, [] after a type with or without data in.
Declarations
Syntax
var name:type;
Where type, as explained, is an elementtype, a compoundtype, variable name or type :: type. The operator : sets the type and :: is type combination (coercion).
Semantics
This will declare a variable to be a specific type. Type combination is subject to a number of semantic rules. If no type information is given, then the type will be found via inference where possible.
Examples
function void main() { var i:Int :: allocated[multiple[]]; };
Here the variable i is declared to be integer, allocated to all processes. There are three types included in this declaration, the element type Int and the compound types allocated and multiple. The type multiple is provided as an argument to the allocation type allocated, which is then combined with the Int type.
function void main() { var m:String; };
In this example, variable m is declared to be of type String. For programmer convenience, by default, the language will automatically assume to combine this with allocated[multiple] if such allocation type is missing.
Statements
Syntax
name:type;
Semantics
Will modify the type of an already declared variable via the : operator. Note, allocation information (via the allocation type) may not be changed. Type modification such as this binds to the current block, the type is reverted back to its previous value once that block has been left.
Examples
function void main() { var i:Int :: allocated[multiple[]]; i:=23; i:i :: const[]; };
Here the variable i is declared to be integer, allocated to all processes and its value is set to 23. Later on in the code the type is modified to set it also to be constant (so from this point on the programmer may not change the variable's value.) In this third line i:i :: const[]; sets the type of i to be that of i combined with the const type.\twolines{}
Important Rule - Changing the type will not have any runtime code generation in itself, although the modified semantics will affect how the variable behaves from that point on.
Expressions
Syntax
name::type
Semantics
When used as an expression, a variable's current type can be coerced with additional types just for that expression.
Example
function void main() { var i:Int :: allocated[multiple[]]; (i :: channel[1,2]):=82; i:=12; };
This code will declare i to be an integer, allocated on all processes. On line 2 i :: channel[1,2] will combine the channel type (primitive communication) just for that assignment and then on line 3 the assignment happens as a normal integer. This is because on line 2 we have not set the type of i, just modified it for that assignment.
Pages in category ‘Types’
The following 3 pages are in this category, out of 3 total.