Skip to content
Find file
Fetching contributors…
Cannot retrieve contributors at this time
1940 lines (1604 sloc) 50 KB
Ddoc
$(SPEC_S Expressions,
$(P C and C++ programmers will find the D expressions very familiar,
with a few interesting additions.
)
$(P Expressions are used to compute values with a resulting type.
These values can then be assigned,
tested, or ignored. Expressions can also have side effects.
)
<h2><a name="order-of-evaluation">Order Of Evaluation</a></h2>
$(P The following binary expressions are evaluated in strictly
left-to-right order:)
$(P
$(V2
$(GLINK OrExpression),
$(GLINK XorExpression),
$(GLINK AndExpression),
$(GLINK CmpExpression),
$(GLINK ShiftExpression),
$(GLINK AddExpression),
$(GLINK CatExpression),
$(GLINK MulExpression),
$(GLINK PowExpression),
)
$(GLINK CommaExpression),
$(GLINK OrOrExpression),
$(GLINK AndAndExpression)
)
$(P The following binary expressions are evaluated in an
implementation-defined order:)
$(P
$(GLINK AssignExpression),
$(V1
$(GLINK OrExpression),
$(GLINK XorExpression),
$(GLINK AndExpression),
$(GLINK CmpExpression),
$(GLINK ShiftExpression),
$(GLINK AddExpression),
$(GLINK CatExpression),
$(GLINK MulExpression),
)
function parameters
)
$(P It is an error
to depend on order of evaluation when it is not specified.
For example, the following are illegal:
)
-------------
i = i++;
c = a + (a = b);
func(++i, ++i);
-------------
$(P If the compiler can determine that the result of an expression
is illegally dependent on the order of evaluation, it can issue
an error (but is not required to). The ability to detect these kinds
of errors is a quality of implementation issue.
)
<h2><a name="Expression">Expressions</a></h2>
$(GRAMMAR
$(GNAME Expression):
$(GLINK AssignExpression)
$(GLINK AssignExpression) $(B ,) $(I Expression)
)
The left operand of the $(B ,) is evaluated, then the right operand
is evaluated. The type of the expression is the type of the right
operand, and the result is the result of the right operand.
<h2>Assign Expressions</h2>
$(GRAMMAR
$(GNAME AssignExpression):
$(GLINK ConditionalExpression)
$(GLINK ConditionalExpression) $(B =) $(I AssignExpression)
$(GLINK ConditionalExpression) $(B +=) $(I AssignExpression)
$(GLINK ConditionalExpression) $(B -=) $(I AssignExpression)
$(GLINK ConditionalExpression) $(B *=) $(I AssignExpression)
$(GLINK ConditionalExpression) $(B /=) $(I AssignExpression)
$(GLINK ConditionalExpression) $(B %=) $(I AssignExpression)
$(GLINK ConditionalExpression) $(B &=) $(I AssignExpression)
$(GLINK ConditionalExpression) $(B |=) $(I AssignExpression)
$(GLINK ConditionalExpression) $(B ^=) $(I AssignExpression)
$(GLINK ConditionalExpression) $(B ~=) $(I AssignExpression)
$(GLINK ConditionalExpression) $(B &lt;&lt;=) $(I AssignExpression)
$(GLINK ConditionalExpression) $(B &gt;&gt;=) $(I AssignExpression)
$(GLINK ConditionalExpression) $(B &gt;&gt;&gt;=) $(I AssignExpression)
$(V2
$(GLINK ConditionalExpression) $(B ^^=) $(I AssignExpression))
)
The right operand is implicitly converted to the type of the
left operand, and assigned to it. The result type is the type
of the lvalue, and the result value is the value of the lvalue
after the assignment.
<p>
The left operand must be an lvalue.
<h3>Assignment Operator Expressions</h3>
Assignment operator expressions, such as:
--------------
$(I a op= b)
--------------
are semantically equivalent to:
--------------
$(I a = a op b)
--------------
except that operand $(I a) is only evaluated once.
<h2>Conditional Expressions</h2>
$(GRAMMAR
$(GNAME ConditionalExpression):
$(GLINK OrOrExpression)
$(GLINK OrOrExpression) $(B ?) $(GLINK Expression) $(B :) $(I ConditionalExpression)
)
The first expression is converted to bool, and is evaluated.
If it is true, then the second expression is evaluated, and
its result is the result of the conditional expression.
If it is false, then the third expression is evaluated, and
its result is the result of the conditional expression.
If either the second or third expressions are of type void,
then the resulting type is void. Otherwise, the second and third
expressions are implicitly converted to a common type which becomes
the result type of the conditional expression.
<h2>OrOr Expressions</h2>
$(GRAMMAR
$(GNAME OrOrExpression):
$(GLINK AndAndExpression)
$(I OrOrExpression) $(B ||) $(GLINK AndAndExpression)
)
The result type of an $(I OrOrExpression) is bool,
unless the right operand
has type void, when the result is type void.
<p>
The $(I OrOrExpression) evaluates its left operand.
If the left operand, converted to type bool, evaluates to
true, then the right operand is not evaluated. If the result type of
the $(I OrOrExpression) is bool then the result of the
expression is true.
If the left operand is false, then the right
operand is evaluated.
If the result type of
the $(I OrOrExpression) is bool then the result of the
expression is the right operand converted to type bool.
<h2>AndAnd Expressions</h2>
$(V1
$(GRAMMAR
$(GNAME AndAndExpression):
$(GLINK OrExpression)
$(I AndAndExpression) $(B &&) $(GLINK OrExpression)
)
)
$(V2
$(GRAMMAR
$(GNAME AndAndExpression):
$(GLINK OrExpression)
$(I AndAndExpression) $(B &&) $(GLINK OrExpression)
$(GLINK CmpExpression)
$(I AndAndExpression) $(B &&) $(GLINK CmpExpression)
)
)
$(P The result type of an $(I AndAndExpression) is bool, unless the right operand
has type void, when the result is type void.
)
$(P The $(I AndAndExpression) evaluates its left operand.
)
$(P If the left operand, converted to type bool, evaluates to
false, then the right operand is not evaluated. If the result type of
the $(I AndAndExpression) is bool then the result of the
expression is false.
)
$(P If the left operand is true, then the right
operand is evaluated.
If the result type of
the $(I AndAndExpression) is bool then the result of the
expression is the right operand converted to type bool.
)
<h2>Bitwise Expressions</h2>
Bit wise expressions perform a bitwise operation on their operands.
Their operands must be integral types.
First, the default integral promotions are done. Then, the bitwise
operation is done.
<h3>Or Expressions</h3>
$(GRAMMAR
$(GNAME OrExpression):
$(GLINK XorExpression)
$(I OrExpression) $(B |) $(GLINK XorExpression)
)
The operands are OR'd together.
<h3>Xor Expressions</h3>
$(GRAMMAR
$(GNAME XorExpression):
$(GLINK AndExpression)
$(I XorExpression) $(B ^) $(GLINK AndExpression)
)
The operands are XOR'd together.
<h3>And Expressions</h3>
$(V1
$(GRAMMAR
$(GNAME AndExpression):
$(GLINK CmpExpression)
$(I AndExpression) $(B &) $(GLINK CmpExpression)
)
)
$(V2
$(GRAMMAR
$(GNAME AndExpression):
$(GLINK ShiftExpression)
$(I AndExpression) $(B &) $(GLINK ShiftExpression)
)
)
The operands are AND'd together.
<h2><a name="CmpExpression">Compare Expressions</a></h2>
$(GRAMMAR
$(GNAME CmpExpression):
$(GLINK ShiftExpression)
$(GLINK EqualExpression)
$(GLINK IdentityExpression)
$(GLINK RelExpression)
$(GLINK InExpression)
)
<h2><a name="EqualExpression">Equality Expressions</a></h2>
$(GRAMMAR
$(GNAME EqualExpression):
$(GLINK ShiftExpression) $(B ==) $(GLINK ShiftExpression)
$(GLINK ShiftExpression) $(B !=) $(GLINK ShiftExpression)
)
Equality expressions compare the two operands for equality ($(B ==))
or inequality ($(B !=)).
The type of the result is bool. The operands
go through the usual conversions to bring them to a common type before
comparison.
<p>
If they are integral values or pointers, equality
is defined as the bit pattern of the type matches exactly.
Equality for struct objects means the bit patterns of the objects
match exactly (the existence of alignment holes in the objects
is accounted for, usually by setting them all to 0 upon
initialization).
Equality for floating point types is more complicated. -0 and
+0 compare as equal. If either or both operands are NAN, then
both the == returns false and != returns true. Otherwise, the bit
patterns are compared for equality.
<p>
For complex numbers, equality is defined as equivalent to:
<pre>
x.re == y.re && x.im == y.im
</pre>
and inequality is defined as equivalent to:
<pre>
x.re != y.re || x.im != y.im
</pre>
$(P For class and struct objects, the expression $(TT (a == b))
is rewritten as
$(TT a.opEquals(b)), and $(TT (a != b)) is rewritten as
$(TT !a.opEquals(b)).
)
$(P For class objects, the $(CODE ==) and $(CODE !=)
operators compare the
contents of the objects. Therefore, comparing against
$(CODE null) is invalid, as $(CODE null) has no contents.
Use the $(CODE is) and $(CODE !is) operators instead.
)
---
class C;
C c;
if (c == null) // error
...
if (c is null) // ok
...
---
$(P For static and dynamic arrays, equality is defined as the
lengths of the arrays
matching, and all the elements are equal.
)
<h3><a name="IdentityExpression">Identity Expressions</a></h3>
$(GRAMMAR
$(GNAME IdentityExpression):
$(GLINK ShiftExpression) $(B is) $(GLINK ShiftExpression)
$(GLINK ShiftExpression) $(B !is) $(GLINK ShiftExpression)
)
$(P The $(B is) compares for identity.
To compare for not identity, use $(TT $(I e1) $(B !is) $(I e2)).
The type of the result is bool. The operands
go through the usual conversions to bring them to a common type before
comparison.
)
$(P For class objects, identity is defined as the object references
are for the same object. Null class objects can be compared with
$(B is).
)
$(P For struct objects, identity is defined as the bits in the
struct being identical.
)
$(P For static and dynamic arrays, identity is defined as referring
to the same array elements and the same number of elements.
)
$(P For other operand types, identity is defined as being the same
as equality.
)
$(P The identity operator $(B is) cannot be overloaded.
)
<h2>Relational Expressions</h2>
$(GRAMMAR
$(GNAME RelExpression):
$(GLINK ShiftExpression) $(B &lt;) $(GLINK ShiftExpression)
$(GLINK ShiftExpression) $(B &lt;=) $(GLINK ShiftExpression)
$(GLINK ShiftExpression) $(B &gt;) $(GLINK ShiftExpression)
$(GLINK ShiftExpression) $(B &gt;=) $(GLINK ShiftExpression)
$(GLINK ShiftExpression) $(B !&lt;&gt;=) $(GLINK ShiftExpression)
$(GLINK ShiftExpression) $(B !&lt;&gt;) $(GLINK ShiftExpression)
$(GLINK ShiftExpression) $(B &lt;&gt;) $(GLINK ShiftExpression)
$(GLINK ShiftExpression) $(B &lt;&gt;=) $(GLINK ShiftExpression)
$(GLINK ShiftExpression) $(B !&gt;) $(GLINK ShiftExpression)
$(GLINK ShiftExpression) $(B !&gt;=) $(GLINK ShiftExpression)
$(GLINK ShiftExpression) $(B !&lt;) $(GLINK ShiftExpression)
$(GLINK ShiftExpression) $(B !&lt;=) $(GLINK ShiftExpression)
)
First, the integral promotions are done on the operands.
The result type of a relational expression is bool.
<p>
For class objects, the result of Object.opCmp() forms the left
operand, and 0 forms the right operand. The result of the
relational expression (o1 op o2) is:
<pre>
(o1.opCmp(o2) op 0)
</pre>
It is an error to compare objects if one is $(B null).
<p>
For static and dynamic arrays, the result of the relational
op is the result of the operator applied to the first non-equal
element of the array. If two arrays compare equal, but are of
different lengths, the shorter array compares as "less" than the
longer array.
<h3>Integer comparisons</h3>
$(P Integer comparisons happen when both operands are integral
types.
)
$(TABLE1
<caption>Integer comparison operators</caption>
$(TR
$(TH Operator)$(TH Relation)
)$(TR
$(TD &lt;) $(TD less)
)$(TR
$(TD &gt;) $(TD greater)
)$(TR
$(TD &lt;=) $(TD less or equal)
)$(TR
$(TD &gt;=) $(TD greater or equal)
)$(TR
$(TD ==) $(TD equal)
)$(TR
$(TD !=) $(TD not equal)
)
)
$(P It is an error to have one operand be signed and the other
unsigned for a &lt;, &lt;=, &gt; or &gt;= expression.
Use casts to make both operands signed or both operands unsigned.
)
<h3><a name="floating_point_comparisons">Floating point comparisons</a></h3>
If one or both operands are floating point, then a floating
point comparison is performed.
<p>
Useful floating point operations must take into account NAN values.
In particular, a relational operator can have NAN operands.
The result of a relational operation on float
values is less, greater, equal, or unordered (unordered means
either or both of the
operands is a NAN). That means there are 14 possible comparison
conditions to test for:
<p>
$(TABLE1
<caption>Floating point comparison operators</caption>
$(TR
$(TH Operator)
$(TH Greater Than)
$(TH Less Than)
$(TH Equal)
$(TH Unordered)
$(TH Exception)
$(TH Relation)
)
$(TR
$(TD ==) $(TD F)$(TD F)$(TD T)$(TD F)$(TD no) $(TD equal)
)
$(TR
$(TD !=) $(TD T)$(TD T)$(TD F)$(TD T)$(TD no) $(TD unordered, less, or greater)
)
$(TR
$(TD &gt;) $(TD T)$(TD F)$(TD F)$(TD F)$(TD yes) $(TD greater)
)
$(TR
$(TD &gt;=) $(TD T)$(TD F)$(TD T)$(TD F)$(TD yes) $(TD greater or equal)
)
$(TR
$(TD &lt;) $(TD F)$(TD T)$(TD F)$(TD F)$(TD yes) $(TD less)
)
$(TR
$(TD &lt;=) $(TD F)$(TD T)$(TD T)$(TD F)$(TD yes) $(TD less or equal)
)
$(TR
$(TD !&lt;&gt;=) $(TD F)$(TD F)$(TD F)$(TD T)$(TD no) $(TD unordered)
)
$(TR
$(TD &lt;&gt;) $(TD T)$(TD T)$(TD F)$(TD F)$(TD yes) $(TD less or greater)
)
$(TR
$(TD &lt;&gt;=) $(TD T)$(TD T)$(TD T)$(TD F)$(TD yes) $(TD less, equal, or greater)
)
$(TR
$(TD !&lt;=) $(TD T)$(TD F)$(TD F)$(TD T)$(TD no) $(TD unordered or greater)
)
$(TR
$(TD !&lt;) $(TD T)$(TD F)$(TD T)$(TD T)$(TD no) $(TD unordered, greater, or equal)
)
$(TR
$(TD !&gt;=) $(TD F)$(TD T)$(TD F)$(TD T)$(TD no) $(TD unordered or less)
)
$(TR
$(TD !&gt;) $(TD F)$(TD T)$(TD T)$(TD T)$(TD no) $(TD unordered, less, or equal)
)
$(TR
$(TD !&lt;&gt;) $(TD F)$(TD F)$(TD T)$(TD T)$(TD no) $(TD unordered or equal)
)
)
<h4>Notes:</h4>
$(OL
$(LI For floating point comparison operators,
$(CODE ($(I a) !$(I op) $(I b)))
is not the same as $(CODE !($(I a op b))).)
$(LI "Unordered" means one or both of the operands is a NAN.)
$(LI "Exception" means the $(I Invalid Exception) is raised if one
of the operands is a NAN. It does not mean an exception
is thrown. The $(I Invalid Exception) can be checked
using the functions in $(LINK2 phobos/std_c_fenv.html, std.c.fenv).
)
)
<h3><a name="class_comparisons">Class comparisons</a></h3>
$(P For class objects, the relational
operators compare the
contents of the objects. Therefore, comparing against
$(CODE null) is invalid, as $(CODE null) has no contents.
)
---
class C;
C c;
if (c < null) // error
...
---
<h2><a name="InExpression">In Expressions</a></h2>
$(GRAMMAR
$(GNAME InExpression):
$(GLINK ShiftExpression) $(B in) $(GLINK ShiftExpression)
$(GLINK ShiftExpression) $(B !in) $(GLINK ShiftExpression)
)
$(P An associative array can be tested to see if an element is in the array:
)
-------------
int foo[char[]];
...
if ("hello" in foo)
...
-------------
$(P The $(B in) expression has the same precedence as the
relational expressions $(B &lt;), $(B &lt;=),
etc.
The return value of the $(I InExpression) is $(B null)
if the element is not in the array;
if it is in the array it is a pointer to the element.
)
$(P The $(B !in) expression is the logical negation of the $(B in)
operation.
)
<h2>Shift Expressions</h2>
$(GRAMMAR
$(GNAME ShiftExpression):
$(GLINK AddExpression)
$(I ShiftExpression) $(B &lt;&lt;) $(GLINK AddExpression)
$(I ShiftExpression) $(B &gt;&gt;) $(GLINK AddExpression)
$(I ShiftExpression) $(B &gt;&gt;&gt;) $(GLINK AddExpression)
)
The operands must be integral types, and undergo the usual integral
promotions. The result type is the type of the left operand after
the promotions. The result value is the result of shifting the bits
by the right operand's value.
<p>
$(B &lt;&lt;) is a left shift.
$(B &gt;&gt;) is a signed right shift.
$(B &gt;&gt;&gt;) is an unsigned right shift.
<p>
It's illegal to shift by more bits than the size of the
quantity being shifted:
-------------
int c;
c << 33; // error
-------------
<h2>Add Expressions</h2>
$(GRAMMAR
$(GNAME AddExpression):
$(GLINK MulExpression)
$(I AddExpression) $(B +) $(GLINK MulExpression)
$(I AddExpression) $(B -) $(GLINK MulExpression)
$(GLINK CatExpression)
)
$(P If the operands are of integral types, they undergo integral
promotions, and then are brought to a common type using the
usual arithmetic conversions.
)
$(P If either operand is a floating point type, the other is implicitly
converted to floating point and they are brought to a common type
via the usual arithmetic conversions.
)
$(P If the operator is $(B +) or $(B -), and
the first operand is a pointer, and the second is an integral type,
the resulting type is the type of the first operand, and the resulting
value is the pointer plus (or minus) the second operand multiplied by
the size of the type pointed to by the first operand.
)
$(P If the second operand is a pointer, and the first is an integral type,
and the operator is $(B +),
the operands are reversed and the pointer arithmetic just described
is applied.
)
$(P If both operands are pointers, and the operator is $(B +),
then it is illegal. For $(B -), the pointers are subtracted and the
result is divided by the size of the type pointed to by the
operands. It is an error if the pointers point to different types.
)
$(P Add expressions for floating point operands are not associative.
)
<h2>Cat Expressions</h2>
$(GRAMMAR
$(GNAME CatExpression):
$(I AddExpression) $(B ~) $(GLINK MulExpression)
)
$(P A $(I CatExpression) concatenates arrays, producing
a dynmaic array with the result. The arrays must be
arrays of the same element type. If one operand is an array
and the other is of that array's element type, that element
is converted to an array of length 1 of that element,
and then the concatenation is performed.
)
<h2>Mul Expressions</h2>
$(V1
$(GRAMMAR
$(GNAME MulExpression):
$(GLINK UnaryExpression)
$(I MulExpression) $(B *) $(GLINK UnaryExpression)
$(I MulExpression) $(B /) $(GLINK UnaryExpression)
$(I MulExpression) $(B %) $(GLINK UnaryExpression)
)
)
$(P The operands must be arithmetic types. They undergo integral
promotions, and then are brought to a common type using the
usual arithmetic conversions.
)
$(P For integral operands, the $(B *), $(B /), and $(B %)
correspond to multiply, divide, and modulus operations.
For multiply, overflows are ignored and simply chopped to fit
into the integral type.
)
$(P For integral operands of the $(B /) and $(B %) operators,
the quotient rounds towards zero and the remainder has the
same sign as the dividend.
If the divisor is zero, an Exception is thrown.
)
$(P For floating point operands, the * and / operations correspond
to the IEEE 754 floating point equivalents. % is not the same as
the IEEE 754 remainder. For example, 15.0 % 10.0 == 5.0, whereas
for IEEE 754, remainder(15.0,10.0) == -5.0.
)
$(P Mul expressions for floating point operands are not associative.
)
<h2><a name="UnaryExpression">Unary Expressions</a></h2>
$(GRAMMAR
$(GNAME UnaryExpression):
$(V1 $(GLINK PostfixExpression))$(V2 $(GLINK PowExpression))
$(B &amp;) $(I UnaryExpression)
$(B ++) $(I UnaryExpression)
$(B --) $(I UnaryExpression)
$(B *) $(I UnaryExpression)
$(B -) $(I UnaryExpression)
$(B +) $(I UnaryExpression)
$(B !) $(I UnaryExpression)
$(B ~) $(I UnaryExpression)
$(B $(LPAREN)) $(GLINK2 declaration, Type) $(B $(RPAREN) .) $(I Identifier)
$(GLINK NewExpression)
$(GLINK DeleteExpression)
$(GLINK CastExpression)
$(LINK2 class.html#anonymous, $(I NewAnonClassExpression))
)
<h3>New Expressions</h3>
$(GRAMMAR
$(GNAME NewExpression):
$(I NewArguments) $(LINK2 declaration.html#Type, $(I Type)) $(B [) $(GLINK AssignExpression) $(B ])
$(I NewArguments) $(LINK2 declaration.html#Type, $(I Type)) $(B $(LPAREN)) $(GLINK ArgumentList) $(B $(RPAREN))
$(I NewArguments) $(LINK2 declaration.html#Type, $(I Type))
$(I NewArguments) $(I ClassArguments) $(GLINK BaseClasslist)$(OPT) $(B {) $(GLINK DeclDefs) $(B } )
$(GNAME NewArguments):
$(B new $(LPAREN)) $(GLINK ArgumentList) $(B $(RPAREN))
$(B new ( ))
$(B new)
$(GNAME ClassArguments):
$(B class $(LPAREN)) $(GLINK ArgumentList) $(B $(RPAREN))
$(B class ( ))
$(B class)
$(GNAME ArgumentList):
$(GLINK AssignExpression)
$(V2 $(GLINK AssignExpression) $(B ,)
) $(GLINK AssignExpression) $(B ,) $(I ArgumentList)
)
$(P $(I NewExpression)s are used to allocate memory on the garbage
collected heap (default) or using a class or struct specific allocator.
)
$(P To allocate multidimensional arrays, the declaration reads
in the same order as the prefix array declaration order.
)
-------------
char[][] foo; // dynamic array of strings
...
foo = new char[][30]; // allocate array of 30 strings
-------------
$(P The above allocation can also be written as:)
-------------
foo = new char[][](30); // allocate array of 30 strings
-------------
$(P To allocate the nested arrays, multiple arguments can be used:)
---------------
int[][][] bar;
...
bar = new int[][][](5,20,30);
---------------
$(P Which is equivalent to:)
----------
bar = new int[][][5];
foreach (ref a; bar)
{
a = new int[][20];
foreach (ref b; a)
{
b = new int[30];
}
}
-----------
$(P If there is a $(B new $(LPAREN)) $(GLINK ArgumentList) $(B $(RPAREN)),
then
those arguments are passed to the class or struct specific allocator
function after the size argument.
)
$(P If a $(I NewExpression) is used as an initializer for
a function local variable with $(B scope) storage class,
and the $(GLINK ArgumentList) to $(B new) is empty, then
the instance is allocated on the stack rather than the heap
or using the class specific allocator.
)
<h3>Delete Expressions</h3>
$(GRAMMAR
$(GNAME DeleteExpression):
$(B delete) $(GLINK UnaryExpression)
)
$(P If the $(I UnaryExpression) is a class object reference, and
there is a destructor for that class, the destructor
is called for that object instance.
)
$(P Next, if the $(I UnaryExpression) is a class object reference, or
a pointer to a struct instance, and the class or struct
has overloaded operator delete, then that operator delete is called
for that class object instance or struct instance.
)
$(P Otherwise, the garbage collector is called to immediately free the
memory allocated for the class instance or struct instance.
If the garbage collector was not used to allocate the memory for
the instance, undefined behavior will result.
)
$(P If the $(I UnaryExpression) is a pointer or a dynamic array,
the garbage collector is called to immediately release the
memory.
If the garbage collector was not used to allocate the memory for
the instance, undefined behavior will result.
)
$(P The pointer, dynamic array, or reference is set to $(B null)
after the delete is performed.
)
$(P If $(I UnaryExpression) is a variable allocated
on the stack, the class destructor (if any) is called for that
instance. Neither the garbage collector nor any class deallocator
is called.
)
<h3>Cast Expressions</h3>
$(GRAMMAR
$(GNAME CastExpression):
$(B cast $(LPAREN)) $(LINK2 declaration.html#Type, $(I Type)) $(B $(RPAREN)) $(GLINK UnaryExpression)
$(B cast $(LPAREN)) $(I CastParam) $(B $(RPAREN)) $(GLINK UnaryExpression)
$(GNAME CastParam):
$(LINK2 declaration.html#Type, $(I Type))
$(B const)
$(B const shared)
$(B shared const)
$(B inout)
$(B inout shared)
$(B shared inout)
$(B immutable)
$(B shared)
)
$(P A $(I CastExpression) converts the $(I UnaryExpression)
to $(LINK2 declaration.html#Type, $(I Type)).
)
-------------
$(B cast)(foo) -p; // cast (-p) to type foo
(foo) - p; // subtract p from foo
-------------
$(P Any casting of a class reference to a
derived class reference is done with a runtime check to make sure it
really is a downcast. $(B null) is the result if it isn't.
$(B Note:) This is equivalent to the behavior of the
dynamic_cast operator in C++.
)
-------------
class A { ... }
class B : A { ... }
void test(A a, B b)
{
B bx = a; // error, need cast
B bx = cast(B) a; // bx is null if a is not a B
A ax = b; // no cast needed
A ax = cast(A) b; // no runtime check needed for upcast
}
-------------
$(P In order to determine if an object $(TT o) is an instance of
a class $(TT B) use a cast:
)
-------------
if ($(B cast)(B) o)
{
// o is an instance of B
}
else
{
// o is not an instance of B
}
-------------
$(P Casting a floating point literal from one type to another
changes its type, but internally it is retained at full
precision for the purposes of constant folding.
)
---
void test()
{
real a = 3.40483L;
real b;
b = 3.40483; // literal is not truncated to double precision
assert(a == b);
assert(a == 3.40483);
assert(a == 3.40483L);
assert(a == 3.40483F);
double d = 3.40483; // truncate literal when assigned to variable
assert(d != a); // so it is no longer the same
const double x = 3.40483; // assignment to const is not
assert(x == a); // truncated if the initializer is visible
}
---
$(P Casting a value $(I v) to a struct $(I S), when value is not a struct
of the same type, is equivalent to:
)
---
S(v)
---
$(V2
<h2><a name="PowExpression">Pow Expressions</a></h2>
$(GRAMMAR
$(GNAME PowExpression):
$(GLINK PostfixExpression)
$(GLINK PostfixExpression) ^^ $(GLINK UnaryExpression)
)
$(P $(I PowExpression) raises its left operand to the power of its
right operand.
)
)
<h2>Postfix Expressions</h2>
$(GRAMMAR
$(GNAME PostfixExpression):
$(GLINK PrimaryExpression)
$(I PostfixExpression) $(B .) $(I Identifier)
$(I PostfixExpression) $(B .) $(GLINK2 template, TemplateInstance)
$(I PostfixExpression) $(B .) $(GLINK NewExpression)
$(I PostfixExpression) $(B ++)
$(I PostfixExpression) $(B --)
$(I PostfixExpression) $(B ( ))
$(I PostfixExpression) $(B $(LPAREN)) $(GLINK ArgumentList) $(B $(RPAREN))
$(GLINK IndexExpression)
$(GLINK SliceExpression)
)
<h2>Index Expressions</h2>
$(GRAMMAR
$(GNAME IndexExpression):
$(GLINK PostfixExpression) $(B [) $(GLINK ArgumentList) $(B ])
)
$(P $(I PostfixExpression) is evaluated.
If $(I PostfixExpression) is an expression of type
static array or dynamic array, the symbol $(DOLLAR) is
set to be the the number of elements in the array.
If $(I PostfixExpression) is an $(I ExpressionTuple),
the symbol $(DOLLAR) is
set to be the the number of elements in the tuple.
A new declaration scope is created for the evaluation of the
$(GLINK ArgumentList) and $(DOLLAR) appears in that scope only.
)
$(P If $(I PostfixExpression) is an $(I ExpressionTuple),
then the $(GLINK ArgumentList) must consist of only one argument,
and that must be statically evaluatable to an integral constant.
That integral constant $(I n) then selects the $(I n)th
expression in the $(I ExpressionTuple), which is the result
of the $(I IndexExpression).
It is an error if $(I n) is out of bounds of the $(I ExpressionTuple).
)
<h2>Slice Expressions</h2>
$(GRAMMAR
$(GNAME SliceExpression):
$(GLINK PostfixExpression) $(B [ ])
$(GLINK PostfixExpression) $(B [) $(GLINK AssignExpression) $(B ..) $(GLINK AssignExpression) $(B ])
)
$(P $(I PostfixExpression) is evaluated.
if $(I PostfixExpression) is an expression of type
static array or dynamic array, the variable $(B length)
(and the special variable $(DOLLAR))
is declared and set to be the length of the array.
A new declaration scope is created for the evaluation of the
$(GLINK AssignExpression)..$(GLINK AssignExpression)
and $(B length) (and $(DOLLAR)) appears in that scope only.
)
$(P The first $(I AssignExpression) is taken to be the inclusive
lower bound
of the slice, and the second $(I AssignExpression) is the
exclusive upper bound.
The result of the expression is a slice of the $(I PostfixExpression)
array.
)
$(P If the $(B [ ]) form is used, the slice is of the entire
array.
)
$(P The type of the slice is a dynamic array of the element
type of the $(I PostfixExpression).
)
$(P If $(I PostfixExpression) is an $(I ExpressionTuple), then
the result of the slice is a new $(I ExpressionTuple) formed
from the upper and lower bounds, which must statically evaluate
to integral constants.
It is an error if those
bounds are out of range.
)
<h2>Primary Expressions</h2>
$(GRAMMAR
$(GNAME PrimaryExpression):
$(I Identifier)
$(B .)$(I Identifier)
$(LINK2 template.html#TemplateInstance, $(I TemplateInstance))
$(LINK2 #this, $(B this))
$(LINK2 #super, $(B super))
$(LINK2 #null, $(B null))
$(B true)
$(B false)
$(B $)
$(V2 $(B __FILE__)
$(B __LINE__))
$(GLINK2 lex, IntegerLiteral)
$(GLINK2 lex, FloatLiteral)
$(GLINK CharacterLiteral)
$(GLINK StringLiterals)
$(GLINK ArrayLiteral)
$(GLINK AssocArrayLiteral)
$(GLINK FunctionLiteral)
$(GLINK AssertExpression)
$(GLINK MixinExpression)
$(GLINK ImportExpression)
$(LINK2 declaration.html#BasicTypeX, $(I BasicType)) $(B .) $(I Identifier)
$(LINK2 declaration.html#Typeof, $(I Typeof))
$(GLINK TypeidExpression)
$(GLINK IsExpression)
$(B $(LPAREN)) $(I Expression) $(B $(RPAREN))
$(V2 $(LINK2 traits.html#TraitsExpression, $(I TraitsExpression)))
)
<h3>.Identifier</h3>
$(I Identifier) is looked up at module scope, rather than the current
lexically nested scope.
<h3>$(LNAME2 this, this)</h3>
$(P Within a non-static member function, $(B this) resolves to
a reference to the object for which the function was called.
If the object is an instance of a struct, $(B this) will
be a pointer to that instance.
If a member function is called with an explicit reference
to $(B typeof(this)), a non-virtual call is made:
)
-------------
class A
{
char get() { return 'A'; }
char foo() { return $(B typeof(this)).get(); }
char bar() { return $(B this).get(); }
}
class B : A
{
char get() { return 'B'; }
}
void main()
{
B b = new B();
b.foo(); // returns 'A'
b.bar(); // returns 'B'
}
-------------
<h3>$(LNAME2 super, super)</h3>
$(P $(B super) is identical to $(B this), except that it is
cast to $(B this)'s base class.
It is an error if there is no base class.
It is an error to use $(B super) within a struct member function.
(Only class $(TT Object) has no base class.)
If a member function is called with an explicit reference
to $(B super), a non-virtual call is made.
)
<h3>$(LNAME2 null, null)</h3>
$(P $(B null) represents the null value for
pointers, pointers to functions, delegates,
dynamic arrays, associative arrays,
and class objects.
If it has not already been cast to a type,
it is given the type (void *) and it is an exact conversion
to convert it to the null value for pointers, pointers to
functions, delegates, etc.
After it is cast to a type, such conversions are implicit,
but no longer exact.
)
<h3>true, false</h3>
These are of type $(B bool) and when cast to another integral
type become the values 1 and 0,
respectively.
<h3><a name="CharacterLiteral">Character Literals</a></h3>
Character literals are single characters and resolve to one
of type $(B char), $(B wchar), or $(B dchar).
If the literal is a \u escape sequence, it resolves to type $(B wchar).
If the literal is a \U escape sequence, it resolves to type $(B dchar).
Otherwise, it resolves to the type with the smallest size it
will fit into.
<h3>String Literals</h3>
$(GRAMMAR
$(GNAME StringLiterals):
$(LINK2 lex.html#StringLiteral, $(I StringLiteral))
$(I StringLiterals) $(LINK2 lex.html#StringLiteral, $(I StringLiteral))
)
$(P String literals can implicitly convert to any
of the following types, they have equal weight:
)
$(V1
$(TABLE1
$(TR $(TD char*))
$(TR $(TD wchar*))
$(TR $(TD dchar*))
$(TR $(TD char[]))
$(TR $(TD wchar[]))
$(TR $(TD dchar[]))
)
)
$(V2
$(TABLE1
$(TR $(TD immutable(char)*))
$(TR $(TD immutable(wchar)*))
$(TR $(TD immutable(dchar)*))
$(TR $(TD immutable(char)[]))
$(TR $(TD immutable(wchar)[]))
$(TR $(TD immutable(dchar)[]))
)
)
$(P String literals have a 0 appended to them, which makes
them easy to pass to C or C++ functions expecting a $(CODE const char*)
string.
The 0 is not included in the $(CODE .length) property of the
string literal.
)
<h3>Array Literals</h3>
$(GRAMMAR
$(GNAME ArrayLiteral):
$(B [) $(GLINK ArgumentList) $(B ])
)
$(P Array literals are a comma-separated list of $(GLINK AssignExpression)s
between square brackets [ and ].
The $(I AssignExpression)s form the elements of a static array,
the length of the array is the number of elements.
The type of the first element is taken to be the type of
all the elements, and all elements are implicitly converted
to that type.
If that type is a static array, it is converted to a dynamic
array.
)
---
[1,2,3]; // type is int[3], with elements 1, 2 and 3
[1u,2,3]; // type is uint[3], with elements 1u, 2u, and 3u
---
$(P If any of the arguments in the $(GLINK ArgumentList) are
an $(I ExpressionTuple), then the elements of the $(I ExpressionTuple)
are inserted as arguments in place of the tuple.
)
$(P Array literals are allocated on the memory managed heap.
Thus, they can be returned safely from functions:)
---
int[] foo()
{
return [1, 2, 3];
}
---
$(P When array literals are cast to another array type, each
element of the array is cast to the new element type.
When arrays that are not literals are cast, the array is
reinterpreted as the new type, and the length is recomputed:
)
---
import std.stdio;
void main()
{
// cast array literal
const short[] ct = cast(short[]) [cast(byte)1, 1];
writeln(ct); // writes [1 1]
// cast other array expression
short[] rt = cast(short[]) [cast(byte)1, 1].dup;
writeln(rt); // writes [257]
}
---
<h3>Associative Array Literals</h3>
$(GRAMMAR
$(GNAME AssocArrayLiteral):
$(B [) $(I KeyValuePairs) $(B ])
$(GNAME KeyValuePairs):
$(I KeyValuePair)
$(I KeyValuePair) $(B ,) $(I KeyValuePairs)
$(GNAME KeyValuePair):
$(I KeyExpression) $(B :) $(I ValueExpression)
$(GNAME KeyExpression):
$(GLINK AssignExpression)
$(GNAME ValueExpression):
$(GLINK AssignExpression)
)
$(P Associative array literals are a comma-separated list of
$(I key):$(I value) pairs
between square brackets [ and ].
The list cannot be empty.
The type of the first key is taken to be the type of
all the keys, and all subsequent keys are implicitly converted
to that type.
The type of the first value is taken to be the type of
all the values, and all subsequent values are implicitly converted
to that type.
An $(I AssocArrayLiteral) cannot be used to statically initialize
anything.
)
---
[21u:"he",38:"ho",2:"hi"]; // type is char[2][uint], with keys 21u, 38u and 2u
// and values "he", "ho", and "hi"
---
$(P If any of the keys or values in the $(I KeyValuePairs) are
an $(I ExpressionTuple), then the elements of the $(I ExpressionTuple)
are inserted as arguments in place of the tuple.
)
<h3>Function Literals</h3>
$(GRAMMAR
$(GNAME FunctionLiteral):
$(B function) $(LINK2 declaration.html#Type, $(I Type))$(OPT) $(I ParameterAttributes) $(OPT) $(LINK2 function.html#FunctionBody, $(I FunctionBody))
$(B delegate) $(LINK2 declaration.html#Type, $(I Type))$(OPT) $(I ParameterAttributes) $(OPT) $(LINK2 function.html#FunctionBody, $(I FunctionBody))
$(I ParameterAttributes) $(LINK2 function.html#FunctionBody, $(I FunctionBody))
$(LINK2 function.html#FunctionBody, $(I FunctionBody))
$(GNAME ParameterAttributes):
$(LINK2 declaration.html#Parameters, $(I Parameters))
$(V2 $(LINK2 declaration.html#Parameters, $(I Parameters)) $(LINK2 declaration.html#FunctionAttributes, $(I FunctionAttributes)))
)
$(I FunctionLiteral)s enable embedding anonymous functions
and anonymous delegates directly into expressions.
$(I Type) is the return type of the function or delegate,
if omitted it is inferred from any $(I ReturnStatement)s
in the $(I FunctionBody).
$(B $(LPAREN)) $(GLINK ArgumentList) $(B $(RPAREN))
forms the arguments to the function.
If omitted it defaults to the empty argument list $(B ()).
The type of a function literal is pointer to function or
pointer to delegate.
If the keywords $(B function) or $(B delegate) are omitted,
it defaults to being a delegate.
<p>
For example:
-------------
int function(char c) fp; // declare pointer to a function
void test()
{
static int foo(char c) { return 6; }
fp = &foo;
}
-------------
is exactly equivalent to:
-------------
int function(char c) fp;
void test()
{
fp = $(B function int(char c) { return 6;}) ;
}
-------------
And:
-------------
int abc(int delegate(long i));
void test()
{ int b = 3;
int foo(long c) { return 6 + b; }
abc(&foo);
}
-------------
is exactly equivalent to:
-------------
int abc(int delegate(long i));
void test()
{ int b = 3;
abc( $(B delegate int(long c) { return 6 + b; }) );
}
-------------
$(P and the following where the return type $(B int) is
inferred:)
-------------
int abc(int delegate(long i));
void test()
{ int b = 3;
abc( $(B (long c) { return 6 + b; }) );
}
-------------
Anonymous delegates can behave like arbitrary statement literals.
For example, here an arbitrary statement is executed by a loop:
-------------
double test()
{ double d = 7.6;
float f = 2.3;
void loop(int k, int j, void delegate() statement)
{
for (int i = k; i < j; i++)
{
statement();
}
}
loop(5, 100, $(B { d += 1; }) );
loop(3, 10, $(B { f += 3; }) );
return d + f;
}
-------------
When comparing with <a href="function.html#nested">nested
functions</a>, the $(B function) form is analogous to static
or non-nested functions, and the $(B delegate) form is
analogous to non-static nested functions. In other words,
a delegate literal can access stack variables in its enclosing
function, a function literal cannot.
<h3>Assert Expressions</h3>
$(GRAMMAR
$(GNAME AssertExpression):
$(B assert $(LPAREN)) $(GLINK AssignExpression) $(B $(RPAREN))
$(B assert $(LPAREN)) $(GLINK AssignExpression) $(B ,) $(GLINK AssignExpression) $(B $(RPAREN))
)
$(P Asserts evaluate the $(I expression). If the result is false,
an $(B AssertError) is thrown. If the result is true, then no
exception is thrown.
It is an error if the $(I expression) contains any side effects
that the program depends on. The compiler may optionally not
evaluate assert expressions at all.
The result type of an assert expression is $(TT void).
Asserts are a fundamental part of the
<a href="dbc.html">Contract Programming</a>
support in D.
)
$(P The expression $(TT assert(0)) is a special case; it
signifies that it is unreachable code.
Either $(B AssertError) is thrown at runtime if it is reachable,
or the execution is halted
(on the x86 processor, a $(B HLT) instruction can be used to halt
execution).
The optimization and code generation phases of compilation may
assume that it is unreachable code.
)
$(P The second $(I Expression), if present, must be implicitly
convertible to type $(V1 $(TT char[]))$(V2 $(TT const(char)[])).
It is evaluated if the
result is false, and the string result is appended to the
$(B AssertError)'s message.
)
----
void main()
{
assert(0, "an" ~ " error message");
}
----
$(P When compiled and run, it will produce the message:)
$(CONSOLE
Error: AssertError Failure test.d(3) an error message
)
<h3><a name="MixinExpression">Mixin Expressions</a></h3>
$(GRAMMAR
$(GNAME MixinExpression):
$(B mixin $(LPAREN)) $(GLINK AssignExpression) $(B $(RPAREN))
)
$(P The $(I AssignExpression) must evaluate at compile time
to a constant string.
The text contents of the string must be compilable as a valid
$(I AssignExpression), and is compiled as such.
)
---
int foo(int x)
{
return mixin("x + 1") * 7; // same as ((x + 1) * 7)
}
---
<h3><a name="ImportExpression">Import Expressions</a></h3>
$(GRAMMAR
$(GNAME ImportExpression):
$(B import $(LPAREN)) $(GLINK AssignExpression) $(B $(RPAREN))
)
$(P The $(I AssignExpression) must evaluate at compile time
to a constant string.
The text contents of the string are interpreted as a file
name. The file is read, and the exact contents of the file
become a string literal.
)
$(P Implementations may restrict the file name in order to avoid
directory traversal security vulnerabilities.
A possible restriction might be to disallow any path components
in the file name.
)
---
void foo()
{
// Prints contents of file foo.txt
writefln( import("foo.txt") );
}
---
<h3><a name="typeidexpression">Typeid Expressions</a></h3>
$(GRAMMAR
$(GNAME TypeidExpression):
$(B typeid $(LPAREN)) $(LINK2 declaration.html#Type, $(I Type)) $(B $(RPAREN))
$(V2 $(B typeid $(LPAREN)) $(GLINK Expression) $(B $(RPAREN)))
)
$(V1
$(P Returns an instance of class
$(LINK2 phobos/object.html, $(B TypeInfo))
corresponding
to $(I Type).
)
)
$(V2
$(P If $(I Type), returns an instance of class
$(LINK2 phobos/object.html, $(B TypeInfo))
corresponding
to $(I Type).
)
$(P If $(I Expression), returns an instance of class
$(LINK2 phobos/object.html, $(B TypeInfo))
corresponding
to the type of the $(I Expression).
If the type is a class, it returns the $(B TypeInfo)
of the dynamic type (i.e. the most derived type).
The $(I Expression) is always executed.
)
---
class A { }
class B : A { }
void main()
{
writeln(typeid(int)); // int
uint i;
writeln(typeid(i++)); // uint
writeln(i); // 1
A a = new B();
writeln(typeid(a)); // B
writeln(typeid(typeof(a))); // A
}
---
)
<h3><a name="IsExpression">IsExpression</a></h3>
$(GRAMMAR
$(GNAME IsExpression):
$(B is $(LPAREN)) $(LINK2 declaration.html#Type, $(I Type)) $(B $(RPAREN))
$(B is $(LPAREN)) $(LINK2 declaration.html#Type, $(I Type)) $(B :) $(I TypeSpecialization) $(B $(RPAREN))
$(B is $(LPAREN)) $(LINK2 declaration.html#Type, $(I Type)) $(B ==) $(I TypeSpecialization) $(B $(RPAREN))
$(B is $(LPAREN)) $(LINK2 declaration.html#Type, $(I Type)) $(I Identifier) $(B $(RPAREN))
$(B is $(LPAREN)) $(LINK2 declaration.html#Type, $(I Type)) $(I Identifier) $(B :) $(I TypeSpecialization) $(B $(RPAREN))
$(B is $(LPAREN)) $(LINK2 declaration.html#Type, $(I Type)) $(I Identifier) $(B ==) $(I TypeSpecialization) $(B $(RPAREN))
$(V2 $(B is $(LPAREN)) $(LINK2 declaration.html#Type, $(I Type)) $(I Identifier) $(B :) $(I TypeSpecialization) $(B ,) $(I TemplateParameterList) $(B $(RPAREN))
$(B is $(LPAREN)) $(LINK2 declaration.html#Type, $(I Type)) $(I Identifier) $(B ==) $(I TypeSpecialization) $(B ,) $(I TemplateParameterList) $(B $(RPAREN))
)
$(GNAME TypeSpecialization):
$(LINK2 declaration.html#Type, $(I Type))
$(V1 $(B typedef)
) $(B struct)
$(B union)
$(B class)
$(B interface)
$(B enum)
$(B function)
$(B delegate)
$(B super)
$(V2 $(B const)
$(B immutable)
$(B inout)
$(B shared)
$(B return)
))
$(I IsExpression)s are evaluated at compile time and are
used for checking for valid types, comparing types for equivalence,
determining if one type can be implicitly converted to another,
and deducing the subtypes of a type.
The result of an $(I IsExpression) is an int of type 0
if the condition is not satisified, 1 if it is.
<p>
$(I Type) is the type being tested. It must be syntactically
correct, but it need not be semantically correct.
If it is not semantically correct, the condition is not satisfied.
<p>
$(I Identifier) is declared to be an alias of the resulting
type if the condition is satisfied. The $(I Identifier) forms
can only be used if the $(I IsExpression) appears in a
<a href="version.html#staticif">$(I StaticIfCondition)</a>.
<p>
$(I TypeSpecialization) is the type that $(I Type) is being
compared against.
<p>
The forms of the $(I IsExpression) are:
$(OL
$(LI $(B is $(LPAREN)) $(I Type) $(B $(RPAREN))$(BR)
The condition is satisfied if $(I Type) is semantically
correct (it must be syntactically correct regardless).
-------------
alias int func(int); // func is a alias to a function type
void foo()
{
if ( $(B is)(func[]) ) // not satisfied because arrays of
// functions are not allowed
writefln("satisfied");
else
writefln("not satisfied");
if ($(B is)([][])) // error, [][] is not a syntactically valid type
...
}
-------------
)
$(LI $(B is $(LPAREN)) $(I Type) $(B :) $(I TypeSpecialization) $(B $(RPAREN))<br>
The condition is satisfied if $(I Type) is semantically
correct and it is the same as
or can be implicitly converted to $(I TypeSpecialization).
$(I TypeSpecialization) is only allowed to be a $(I Type).
-------------
alias short bar;
void foo(bar x)
{
if ( $(B is)(bar : int) ) // satisfied because short can be
// implicitly converted to int
writefln("satisfied");
else
writefln("not satisfied");
}
-------------
)
$(LI $(B is $(LPAREN)) $(I Type) $(B ==) $(I TypeSpecialization) $(B $(RPAREN))<br>
The condition is satisfied if $(I Type) is semantically
correct and is the same type as $(I TypeSpecialization).
<p>
If $(I TypeSpecialization) is one of
$(V1 $(B typedef)
) $(B struct)
$(B union)
$(B class)
$(B interface)
$(B enum)
$(B function)
$(B delegate)
$(V2 $(B const)
$(B immutable)
$(B shared)
)
then the condition is satisifed if $(I Type) is one of those.
-------------
alias short bar;
$(V1 typedef char foo;)
void test(bar x)
{
if ( $(B is)(bar == int) ) // not satisfied because short is not
// the same type as int
writefln("satisfied");
else
writefln("not satisfied");
$(V1
if ( $(B is)(foo == typedef) ) // satisfied because foo is a typedef
writefln("satisfied");
else
writefln("not satisfied");
)}
-------------
)
$(LI $(B is $(LPAREN)) $(I Type) $(I Identifier) $(B $(RPAREN))<br>
The condition is satisfied if $(I Type) is semantically
correct. If so, $(I Identifier)
is declared to be an alias of $(I Type).
-------------
alias short bar;
void foo(bar x)
{
static if ( $(B is)(bar T) )
alias T S;
else
alias long S;
writefln(typeid(S)); // prints "short"
if ( $(B is)(bar T) ) // error, $(I Identifier) T form can
// only be in $(LINK2 version.html#staticif, $(I StaticIfCondition))s
...
}
-------------
)
$(LI $(B is $(LPAREN)) $(I Type) $(I Identifier) $(B :) $(I TypeSpecialization) $(B $(RPAREN))<br>
$(P
The condition is satisfied if $(I Type) is the same as
$(I TypeSpecialization), or if $(I Type) is a class and
$(I TypeSpecialization) is a base class or base interface
of it.
The $(I Identifier) is declared to be either an alias of the
$(I TypeSpecialization) or, if $(I TypeSpecialization) is
dependent on $(I Identifier), the deduced type.
)
-------------
alias int bar;
alias long* abc;
void foo(bar x, abc a)
{
static if ( $(B is)(bar T : int) )
alias T S;
else
alias long S;
writefln(typeid(S)); // prints "int"
static if ( $(B is)(abc U : U*) )
U u;
writefln(typeid(typeof(u))); // prints "long"
}
-------------
$(P The way the type of $(I Identifier) is determined is analogous
to the way template parameter types are determined by
$(I TemplateTypeParameterSpecialization).
)
)
$(LI $(B is $(LPAREN)) $(I Type) $(I Identifier) $(B ==) $(I TypeSpecialization) $(B $(RPAREN))<br>
$(P The condition is satisfied if $(I Type) is semantically
correct and is the same as $(I TypeSpecialization).
The $(I Identifier) is declared to be either an alias of the
$(I TypeSpecialization) or, if $(I TypeSpecialization) is
dependent on $(I Identifier), the deduced type.
)
$(P If $(I TypeSpecialization) is one of
$(V1 $(B typedef)
) $(B struct)
$(B union)
$(B class)
$(B interface)
$(B enum)
$(B function)
$(B delegate)
$(V2 $(B const)
$(B immutable)
$(B shared)
)
then the condition is satisifed if $(I Type) is one of those.
Furthermore, $(I Identifier) is set to be an alias of the type:
)
$(TABLE1
$(TR
$(TH keyword)
$(TH alias type for $(I Identifier))
)
$(V1 $(TR
$(TD $(CODE typedef))
$(TD the type that $(I Type) is a typedef of)
)
)
$(TR
$(TD $(CODE struct))
$(TD $(I Type))
)
$(TR
$(TD $(CODE union))
$(TD $(I Type))
)
$(TR
$(TD $(CODE class))
$(TD $(I Type))
)
$(TR
$(TD $(CODE interface))
$(TD $(I Type))
)
$(TR
$(TD $(CODE super))
$(TD $(I TypeTuple) of base classes and interfaces)
)
$(TR
$(TD $(CODE enum))
$(TD the base type of the enum)
)
$(TR
$(TD $(CODE function))
$(TD $(I TypeTuple) of the function parameter types)
)
$(TR
$(TD $(CODE delegate))
$(TD the function type of the delegate)
)
$(TR
$(TD $(CODE return))
$(TD the return type of the function, delegate, or function pointer)
)
$(V2
$(TR
$(TD $(CODE const))
$(TD $(I Type))
)
$(TR
$(TD $(CODE immutable))
$(TD $(I Type))
)
$(TR
$(TD $(CODE shared))
$(TD $(I Type))
)
)
)
-------------
alias short bar;
enum E : byte { Emember }
void foo(bar x)
{
static if ( $(B is)(bar T == int) ) // not satisfied, short is not int
alias T S;
alias T U; // error, T is not defined
static if ( $(B is)(E V == enum) ) // satisified, E is an enum
V v; // v is declared to be a byte
}
-------------
$(V1
$(P For example, to test to see if $(CODE X) is a typedef and
its base type is int:
)
---
typedef int X;
static if (is(X base == typedef))
{
static assert(is(base == int), "base of typedef X is not int");
}
else
{
static assert(0, "X is not a typedef");
}
---
)
)
$(V2
$(LI $(B is $(LPAREN)) $(I Type) $(I Identifier) $(B :) $(I TypeSpecialization) $(B ,) $(I TemplateParameterList) $(B $(RPAREN))$(BR)
$(B is $(LPAREN)) $(I Type) $(I Identifier) $(B ==) $(I TypeSpecialization) $(B ,) $(I TemplateParameterList) $(B $(RPAREN))
$(P More complex types can be pattern matched; the
$(I TemplateParameterList) declares symbols based on the
parts of the pattern that are matched, analogously to the
way implied template parameters are matched.
)
---
import std.stdio;
void main()
{
alias long[char[]] AA;
static if (is(AA T : T[U], U : const char[]))
{
writefln(typeid(T)); // long
writefln(typeid(U)); // const char[]
}
static if (is(AA A : A[B], B : int))
{
assert(0); // should not match, as B is not an int
}
static if (is(int[10] W : W[V], int V))
{
writefln(typeid(W)); // int
writefln(V); // 10
}
static if (is(int[10] X : X[Y], int Y : 5))
{
assert(0); // should not match, Y should be 10
}
}
---
)
)
)
<h2><a name="associativity">Associativity and Commutativity</a></h2>
$(P An implementation may rearrange the evaluation of expressions
according to arithmetic associativity and commutativity rules
as long as, within that thread of execution, no observable
difference is possible.
)
$(P This rule precludes any associative or commutative reordering of
floating point expressions.)
)
Macros:
TITLE=Expressions
WIKI=Expression
CATEGORY_SPEC=$0
GLINK=$(LINK2 #$0, $(I $0))
GNAME=<a name=$0>$(I $0)</a>
DOLLAR=$
FOO=
Jump to Line
Something went wrong with that request. Please try again.