expression.dd

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=