Typecast

To convert the type of a value a typecast is required. There are two types of typecasting, explicit and implicit. Explicit typecasts must be provided by the programmer, but implicit typecasts are put in place by the compiler. LSL implicitly typecasts strings to keys and integers to floats where the latter type is required but the former is provided.
Supported Typecasts	Supported Typecasts	Supported Typecasts	Supported Typecasts	Supported Typecasts	Supported Typecasts	Supported Typecasts	Supported Typecasts	Supported Typecasts
 	 	To 	To 	To 	To 	To 	To 	To
 	 	integer 	float 	string 	key 	list 	vector 	rotation
From 	integer 	x 	x 	x 	 	x 	 	
From 	float 	x 	x 	x 	 	x 	 	
From 	string 	x 	x 	x 	x 	x 	x 	x
From 	key 	 	 	x 	x 	x 	 	
From 	list 	 	 	x 	 	x 	 	
From 	vector 	 	 	x 	 	x 	x 	
From 	rotation 	 	 	x 	 	x 	 	x
== Syntax: () ==
Converts to .
If is a complex expression, it may be beneficial to wrap it in parentheses. ()()
== Examples ==
string a = "1.5";
float b = (float)a;
integer c = (integer)a;
integer i;
i = (integer) 1.23; // 1
i = (integer) -1.23; // -1
i = (integer) "0123"; // 123
i = (integer) "0x12A"; // 298
i = (integer) " -5 "; // -5; leading white space is ignored
i = (integer) "105 degrees here, it is a nice day"; // 105; non-numeric text which follows numeric text is ignored
i = (integer) "String with no numbers"; // 0
float f;
f = (float) "6.2e1"; // 62.0
f = (float) " -16.2°C is seriously cold!"; // -16.2; (float)string also ignores leading whitespace and trailing non-numeric characters
// "6.2e1", "6.2e+1", "6.2E1", "6.2E+1" are all equivalent.
f = (float) "0x1.f"; // 1.9375; hexadecimal floats in style of the C99 standard are accepted
f = (float) "0x0.3p-2"; // 0.046875 = 0.1875 * 2^-2; the "p" exponent uses base 2, and unlike C99 is not mandatory
f = (float) "Nancy"; // any string beginning with "nan" (case insensitive) --
 // Mono only: NaN (not a number); LSO: causes a math error
f = (float) "infallible LSL!"; // any string beginning with "inf" (case insensitive) --
 // Mono only: Infinity; LSO: causes a math error
string s;
s = (string) -PI; // "-3.141593" with precision set to 6 decimal places by zero padding or rounding
s = (string) [1, 2.3, "a"]; // "12.300000a" again 6 decimal places, but ...
s = (string) <1.0, 2.3, 4.56>; // "<1.00000, 2.30000, 4.56000>" .. now with precision set to 5 decimal places
s = (string) <2, 4, 0.0, PI >; // "<2.00000, 4.00000, 0.00000, 3.14159>"
list l;
l = (list) ""; // [""]
l = (list) <1.0, 2.3, 4.56>; // ["<1.00000, 2.30000, 4.56000>"]
vector v;
v = (vector) "<1.0, 2.3, 4.56>"; // <1.0, 2.3, 4.56>
v = (vector) "<1.0, 2.3>"; // ZERO_VECTOR (Due to insufficient value)
rotation r;
r = (rotation) "<1.0, 2.3, 4.56, 1.0>"; // <1.0, 2.3, 4.56, 1.0>
r = (rotation) "<1.0, 2.3, 4.56>"; // ZERO_ROTATION (Due to insufficient value)
===Applied===
default
{
 state_entry()
 {
 integer iUnixTime = llGetUnixTime(); 
 string sUnixTime = (string)unixTime;
 string sRegionTime = (string)llGetTimeOfDay();
 llSetObjectDesc(sUnixTime);
 llSetText(sRegionTime, <1.0, 0.0 ,0.0>, 1.0);
 }
}
== Caveats ==
*The compiler allows explicit typecasting where it is not needed and does not optimize it out. Unnecessary typecasts will bloat code and slow it down.
== Notes ==
*Typecasting from a float to an integer merely removes the portion of the number following the decimal point. To round to the nearest whole integer, use llRound.
*For getting at the elements of a list use the functions.
*For casting a variable myVar to a single-item list, the syntax (list)myVar is about 30% more efficient under LSL Mono than the syntax [myVar]. The same (list)myVar syntax is also slightly more efficient under LSL-LSO.