The following table lists all Qore operators in order of precedence, starting with the highest precedence. The lower the precedence number, the higher the precedence, therefore the operators with precedence level 1 ({\ttfamily \char`\"{}\{\}\char`\"{}}, {\ttfamily \char`\"{}\mbox{[}$\,$\mbox{]}\char`\"{}}, {\ttfamily \char`\"{}.\char`\"{}}) have the highest precedence of all Qore operators. The precedence levels in Qore are roughly equal to the precedence levels of C language operators. To explicitly specify the precedence for expression evaluation, use parentheses {\ttfamily ()}. Note that all examples are given in \mbox{\hyperlink{parse_directives_new-style}{\%new-\/style}}.

{\bfseries{Operators}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{4}{|X[-1]}|}
\hline
{\bfseries{Operator}} &{\bfseries{Prec.}} &{\bfseries{Description}} &{\bfseries{Example}}  \\\cline{1-4}
\mbox{\hyperlink{operators_backquote_operator}{\`{}\`{}}} &{\ttfamily 1}  &\mbox{\hyperlink{operators_backquote_operator}{backquote/backtick operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{`ls -\/l`}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_hash_element_operator}{\{\}}} &{\ttfamily 1}  &\mbox{\hyperlink{operators_hash_element_operator}{hash element or object member expression dereference operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{hash\{\textcolor{stringliteral}{"{}na"{}} + \textcolor{stringliteral}{"{}me"{}}\}}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_dot_operator}{.}} &{\ttfamily 1}  &\mbox{\hyperlink{operators_dot_operator}{hash element or object member literal dereference operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{hash.name}

\end{DoxyCode}

\begin{DoxyCode}{0}
\DoxyCodeLine{obj.method()}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_list_element_operator}{\mbox{[}\mbox{]}}} &{\ttfamily 1}  &\mbox{\hyperlink{operators_list_element_operator}{list element, string, and binary dereference operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{list[1]; string[3]; binary[2];}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_pre_increment_operator}{++}} &{\ttfamily 2}  &\mbox{\hyperlink{operators_pre_increment_operator}{pre-\/increment operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{++a}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_post_increment_operator}{++}} &{\ttfamily 2}  &\mbox{\hyperlink{operators_post_increment_operator}{post-\/increment operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a++}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_pre_decrement_operator}{-\/-\/}} &{\ttfamily 2}  &\mbox{\hyperlink{operators_pre_decrement_operator}{pre-\/decrement operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{-\/-\/a}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_post_decrement_operator}{-\/-\/}} &{\ttfamily 2}  &\mbox{\hyperlink{operators_post_decrement_operator}{post-\/decrement operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a-\/-\/}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_new}{new}} &{\ttfamily 3}  &\mbox{\hyperlink{operators_new}{value instantiation/new operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{new Socket()}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_background}{background}} &{\ttfamily 3}  &\mbox{\hyperlink{operators_background}{background/thread creation operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{background mainThread()}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_delete}{delete}} &{\ttfamily 3}  &\mbox{\hyperlink{operators_delete}{delete operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{delete var}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_remove}{remove}} &{\ttfamily 3}  &\mbox{\hyperlink{operators_remove}{remove operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{remove var}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_cast}{cast$<$$>$()}} &{\ttfamily 3}  &\mbox{\hyperlink{operators_cast}{cast$<$$>$() operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{cast<SubClass>(var)}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_logical_negation_operator}{!}} &{\ttfamily 4}  &\mbox{\hyperlink{operators_logical_negation_operator}{logical negation operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (!(a > 10)) \{\}}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_binary_not_operator}{$\sim$}} &{\ttfamily 5}  &\mbox{\hyperlink{operators_binary_not_operator}{binary not/bit inversion operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var = \string~var}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_unary_plus_operator}{+ (unary plus)}} &{\ttfamily 6}  &\mbox{\hyperlink{operators_unary_plus_operator}{unary plus operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var = +var}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_unary_minus_operator}{-\/ (unary minus)}} &{\ttfamily 6}  &\mbox{\hyperlink{operators_unary_minus_operator}{unary minus operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var = -\/var}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_shift}{shift}} &{\ttfamily 7}  &\mbox{\hyperlink{operators_shift}{shift list element operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{shift list}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_pop}{pop}} &{\ttfamily 7}  &\mbox{\hyperlink{operators_pop}{pop list element operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{pop list}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_chomp}{chomp}} &{\ttfamily 7}  &\mbox{\hyperlink{operators_chomp}{chomp end-\/of-\/line character operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{chomp string}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_trim}{trim}} &{\ttfamily 7}  &\mbox{\hyperlink{operators_trim}{trim characters operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{trim string}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_elements}{elements}} &{\ttfamily 8}  &\mbox{\hyperlink{operators_elements}{number of elements operator (list, hash, string, binary)}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{elements list}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_keys}{keys}} &{\ttfamily 8}  &\mbox{\hyperlink{operators_keys}{hash key list operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{keys hash}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_multiplication_operator}{$\ast$}} &{\ttfamily 9}  &\mbox{\hyperlink{operators_multiplication_operator}{multiplication operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var = a * 10}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_division_operator}{/}} &{\ttfamily 9}  &\mbox{\hyperlink{operators_division_operator}{division operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var = a / 10}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_modulo_operator}{\%}} &{\ttfamily 10}  &\mbox{\hyperlink{operators_modulo_operator}{modulo operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var = a \% 10}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_plus_operator}{+}} &{\ttfamily 11}  &\mbox{\hyperlink{operators_plus_operator}{plus operator\+: string, binary, list, and hash concatenation, integer and float addition}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a + 10}

\end{DoxyCode}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{stringliteral}{"{}hello"{}} + \textcolor{stringliteral}{"{}there"{}}}

\end{DoxyCode}

\begin{DoxyCode}{0}
\DoxyCodeLine{list + \textcolor{stringliteral}{"{}new value"{}}}

\end{DoxyCode}

\begin{DoxyCode}{0}
\DoxyCodeLine{hash + ( \textcolor{stringliteral}{"{}newkey"{}} : 100 )}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_minus_operator}{-\/}} &{\ttfamily 11}  &\mbox{\hyperlink{operators_minus_operator}{minus operator (arithmetic subtraction, hash key removal)}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a -\/ 10}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_shift_right_operator}{$>$$>$}} &{\ttfamily 12}  &\mbox{\hyperlink{operators_shift_right_operator}{bitwise shift right operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{0xff00 >> 8}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_shift_left_operator}{$<$$<$}} &{\ttfamily 12}  &\mbox{\hyperlink{operators_shift_left_operator}{bitwise shift left operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{0xff00 << 8}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_exists}{exists}} &{\ttfamily 13}  &\mbox{\hyperlink{operators_exists}{exists value operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{exists var}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_instanceof}{instanceof}} &{\ttfamily 13}  &\mbox{\hyperlink{operators_instanceof}{instanceof operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{instanceof Qore::Mutex}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_logical_less_than_operator}{$<$}} &{\ttfamily 14}  &\mbox{\hyperlink{operators_logical_less_than_operator}{Logical less than operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a < 10}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_logical_greater_than_operator}{$>$}} &{\ttfamily 14}  &\mbox{\hyperlink{operators_logical_greater_than_operator}{Logical greater than operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a > 10}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_logical_equality_operator}{==}} &{\ttfamily 14}  &\mbox{\hyperlink{operators_logical_equality_operator}{Logical equality operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a == 10}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_logical_inequality_operator}{!=}} &{\ttfamily 14}  &\mbox{\hyperlink{operators_logical_inequality_operator}{logical inequality operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a != 10}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_logical_less_than_or_equals_operator}{$<$=}} &{\ttfamily 14}  &\mbox{\hyperlink{operators_logical_less_than_or_equals_operator}{Logical less then or equals operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a <= 10}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_logical_greater_than_or_equals_operator}{$>$=}} &{\ttfamily 14}  &\mbox{\hyperlink{operators_logical_greater_than_or_equals_operator}{logical greater than or equals operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a >= 10}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_logical_comparison_operator}{$<$=$>$}} &{\ttfamily 14}  &\mbox{\hyperlink{operators_logical_comparison_operator}{logical comparison operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a <=> b}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_logical_absolute_equality_operator}{===}} &{\ttfamily 14}  &\mbox{\hyperlink{operators_logical_absolute_equality_operator}{absolute logical equality operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a === 10}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_logical_absolute_inequality_operator}{!==}} &{\ttfamily 14}  &\mbox{\hyperlink{operators_logical_absolute_inequality_operator}{absolute logical inequality operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a !== 10}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_regex_match_operator}{=$\sim$ //}} &{\ttfamily 14}  &\mbox{\hyperlink{operators_regex_match_operator}{regular expression match operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a =\string~ /text/}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_regex_no_match_operator}{!$\sim$ //}} &{\ttfamily 14}  &\mbox{\hyperlink{operators_regex_no_match_operator}{regular expression no match operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a !\string~ /text/}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_regex_subst_operator}{=$\sim$ s///}} &{\ttfamily 14}  &\mbox{\hyperlink{operators_regex_subst_operator}{regular expression substitution operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a =\string~ s/text/text/}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_regex_extract_operator}{=$\sim$ x//}} &{\ttfamily 14}  &\mbox{\hyperlink{operators_regex_extract_operator}{regular expression pattern extraction operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a =\string~ x/(\(\backslash\)w+):(\(\backslash\)w+)/}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_transliteration_operator}{=$\sim$ tr}} &{\ttfamily 14}  &\mbox{\hyperlink{operators_transliteration_operator}{transliteration operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a =\string~ tr/a-\/z/A-\/Z/}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_bitwise_and_operator}{\&}} &{\ttfamily 15}  &\mbox{\hyperlink{operators_bitwise_and_operator}{bitwise/binary AND operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a \& 0xff}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_bitwise_xor_operator}{$^\wedge$}} &{\ttfamily 16}  &\mbox{\hyperlink{operators_bitwise_xor_operator}{bitwise/binary XOR operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a \string^ 0xff}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_bitwise_or_operator}{$\vert$}} &{\ttfamily 17}  &\mbox{\hyperlink{operators_bitwise_or_operator}{bitwise/binary OR operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a | 0xff}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_logical_and_operator}{\&\&}} &{\ttfamily 18}  &\mbox{\hyperlink{operators_logical_and_operator}{logical AND operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{(a = 1) \&\& (b < 10)}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_logical_or_operator}{$\vert$$\vert$}} &{\ttfamily 19}  &\mbox{\hyperlink{operators_logical_or_operator}{logical OR operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{(a = 1) || (b < 10)}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_range_operator}{.. (range)}} &{\ttfamily 20}  &\mbox{\hyperlink{operators_range_operator}{range operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{3..7}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_conditional_operator}{? \+:}} &{\ttfamily 21}  &\mbox{\hyperlink{operators_conditional_operator}{conditional operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{a == 2 ? \textcolor{stringliteral}{"{}yes"{}} : \textcolor{stringliteral}{"{}no"{}}}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_null_coalescing_operator}{??}} &{\ttfamily 21}  &\mbox{\hyperlink{operators_null_coalescing_operator}{null coalescing operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{any var = a ?? b}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_value_coalescing_operator}{?$\ast$}} &{\ttfamily 21}  &\mbox{\hyperlink{operators_value_coalescing_operator}{value coalescing operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{any var = a ?* b}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_comma_operator}{,}} &{\ttfamily 22}  &\mbox{\hyperlink{operators_comma_operator}{comma operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{1, 2, 3, 4, 5}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_unshift}{unshift}} &{\ttfamily 23}  &\mbox{\hyperlink{operators_unshift}{unshift list element operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{unshift list, val}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_push}{push}} &{\ttfamily 23}  &\mbox{\hyperlink{operators_push}{push list element operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{push list, val}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_splice}{splice}} &{\ttfamily 23}  &\mbox{\hyperlink{operators_splice}{splice list or string operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{splice list, 2, 2, (1, 2, 3)}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_extract}{extract}} &{\ttfamily 23}  &\mbox{\hyperlink{operators_extract}{extract list or string operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{my sublist = extract list, 2, 2, (1, 2, 3)}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_map}{map}} &{\ttfamily 23}  &\mbox{\hyperlink{operators_map}{map operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{map closure(\$1), list}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_hmap}{hash map}} &{\ttfamily 23}  &\mbox{\hyperlink{operators_hmap}{hash map operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{map \{expr(\$1) : expr(\$1)\}, list}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_foldl}{foldl}} &{\ttfamily 23}  &\mbox{\hyperlink{operators_foldl}{fold left to right operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{foldl closure(\$1 -\/ \$2), list}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_foldr}{foldr}} &{\ttfamily 23}  &\mbox{\hyperlink{operators_foldr}{fold right to left operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{foldr closure(\$1 -\/ \$2), list}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_select}{select}} &{\ttfamily 23}  &\mbox{\hyperlink{operators_select}{select elements from list operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{select list, \$1 > 1}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_assignment_operator}{=}} &{\ttfamily 24}  &\mbox{\hyperlink{operators_assignment_operator}{assignment operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var = 1}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_weak_assignment_operator}{\+:=}} &{\ttfamily 24}  &\mbox{\hyperlink{operators_weak_assignment_operator}{weak assignment operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var := obj}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_plus_equals_operator}{+=}} &{\ttfamily 24}  &\mbox{\hyperlink{operators_plus_equals_operator}{plus-\/equals (add-\/to) operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var += 5}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_minus_equals_operator}{-\/=}} &{\ttfamily 24}  &\mbox{\hyperlink{operators_minus_equals_operator}{minus-\/equals (subtract-\/from) operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var -\/= 5}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_and_equals_operator}{\&=}} &{\ttfamily 24}  &\mbox{\hyperlink{operators_and_equals_operator}{and-\/equals operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var \&= 0x2000}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_or_equals_operator}{$\vert$=}} &{\ttfamily 24}  &\mbox{\hyperlink{operators_or_equals_operator}{or-\/equals operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var |= 0x2000}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_modulo_equals_operator}{\%=}} &{\ttfamily 24}  &\mbox{\hyperlink{operators_modulo_equals_operator}{modulo-\/equals operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var \%= 100}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_multiply_equals_operator}{$\ast$=}} &{\ttfamily 24}  &\mbox{\hyperlink{operators_multiply_equals_operator}{multiply-\/equals operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var *= 10}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_divide_equals_operator}{/=}} &{\ttfamily 24}  &\mbox{\hyperlink{operators_divide_equals_operator}{divide-\/equals operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var /= 10}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_xor_equals_operator}{$^\wedge$=}} &{\ttfamily 24}  &\mbox{\hyperlink{operators_xor_equals_operator}{xor-\/equals operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var \string^= 0x2000}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_shift_left_equals_operator}{$<$$<$=}} &{\ttfamily 24}  &\mbox{\hyperlink{operators_shift_left_equals_operator}{shift-\/left-\/equals operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var <<= 0x2000}

\end{DoxyCode}
  \\\cline{1-4}
\mbox{\hyperlink{operators_shift_right_equals_operator}{$>$$>$=}} &{\ttfamily 24}  &\mbox{\hyperlink{operators_shift_right_equals_operator}{shift-\/right-\/equals operator}} &
\begin{DoxyCode}{0}
\DoxyCodeLine{var >>= 0x2000}

\end{DoxyCode}
  \\\cline{1-4}
\end{longtabu}
\hypertarget{operators_op_atomicity}{}\doxysection{Operator Atomicity}\label{operators_op_atomicity}
All Qore operators perform thread-\/atomic actions with respect to the immediate arguments of the operator.

If more than one operator is used in an expression, the entire expression is not thread-\/atomic unless explicit user-\/level locking is used. For example\+: {\ttfamily a += 5} is a thread-\/atomic action, but {\ttfamily a += b--} is not atomic, but rather made up of two atomic actions.\hypertarget{operators_op_args}{}\doxysection{Operator Arguments}\label{operators_op_args}
When an operator taking more than one argument is used with arguments of different data types, Qore automatically converts one or both data types to a data type supported by the operator in order to evaluate the result, according to the precedence lists given for each operator. That is; when an operator operates on mixed types, the types listed first in the following sections have precedence over types listed farther down in the lists. The result type will always be equal to the final operation type after any conversions due to type precedence per operator. If no type of either argument matches a supported data type for the operator, both types will be converted to the highest precedence data type for the operator and then the operator will evaluate the result. For explicit type conversion, please see the \mbox{\hyperlink{group__type__conversion__functions_ga22c89291d4105fcb558f49fe49aeae44}{boolean()}}, \mbox{\hyperlink{group__type__conversion__functions_gacf16b4126b795f4b6933ef3425cadae3}{string()}}, \mbox{\hyperlink{group__date__and__time__functions_gaa80ee453b6a5653ac685d7e290c74e3f}{date()}}, \mbox{\hyperlink{group__type__conversion__functions_ga2de8717e92c5f97ccc6511f6062d6502}{int()}}, \mbox{\hyperlink{group__type__conversion__functions_ga113d18216af1bdb70545081b6a9892ef}{float()}}, etc functions.\hypertarget{operators_op_functional}{}\doxysection{Lazy Evalution of Functional Operators}\label{operators_op_functional}
Qore supports lazy evaluation of functional operators where possible in order to provide an efficient solution for processing large lists or nested functional operators.

The following operators support lazy evaluation directly\+:
\begin{DoxyItemize}
\item \mbox{\hyperlink{operators_map}{map}} (non-\/hash version)\+: allows the \mbox{\hyperlink{expressions}{map expression}} to be evaluated in place when nested with other functional operators or used with a \mbox{\hyperlink{statements_foreach}{foreach statement}}
\item \mbox{\hyperlink{operators_select}{select}}\+: allows the filtered result list to be created and iterated in place when nested with other functional operators or used with a \mbox{\hyperlink{statements_foreach}{foreach statement}} rather than returning a temporary list
\item \mbox{\hyperlink{operators_keys}{keys}}\+: allows the \mbox{\hyperlink{container_data_types_hash}{hash}} or \mbox{\hyperlink{container_data_types_object}{object}} to be iterated in place when nested with other functional operators or used with a \mbox{\hyperlink{statements_foreach}{foreach statement}} rather than returning a temporary list of hash keys or accessible object members
\item \mbox{\hyperlink{operators_range_operator}{.. (range operator)}} and \mbox{\hyperlink{operators_list_element_operator}{\mbox{[}\mbox{]}}} with a range or multiple values\+: allow the operand to be iterated in place when nested with other functional operators or used with a \mbox{\hyperlink{statements_foreach}{foreach statement}} rather than returning a temporary list/string/binary object
\end{DoxyItemize}

The following operators and statements support lazy evaluation for iteration\+:
\begin{DoxyItemize}
\item \mbox{\hyperlink{operators_map}{map}} (non-\/hash version)\+: supports lazy evaluation in the \mbox{\hyperlink{expressions}{iterator expression}} (and therefore nested lazy evaluation)
\item \mbox{\hyperlink{operators_select}{select}}\+: supports lazy evaluation in the \mbox{\hyperlink{expressions}{iterator expression}} (and therefore nested lazy evaluation)
\item \mbox{\hyperlink{operators_foldl}{foldl}}\+: supports lazy evaluation in the \mbox{\hyperlink{expressions}{iterator expression}}
\item \mbox{\hyperlink{operators_foldr}{foldr}}\+: supports lazy evaluation in the \mbox{\hyperlink{expressions}{iterator expression}}
\item \mbox{\hyperlink{statements_foreach}{foreach}}\+: supports lazy evaluation in the \mbox{\hyperlink{expressions}{iterator expression}}
\end{DoxyItemize}

\begin{DoxyParagraph}{Example}
With lazy functional evaluation, the following code does not create a potentially long itermediate list with the \mbox{\hyperlink{operators_map}{map}} expression, but rather the \mbox{\hyperlink{operators_foldl}{foldl}} expression will operate directly on the expressions generated when iterating the value returned by {\ttfamily get\+\_\+iterator()}\+: 
\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{comment}{\# build a comma-\/separated string from an iterated expression}}
\DoxyCodeLine{string str = foldl \$1 + \textcolor{stringliteral}{"{}, "{}} + \$2, (map \$1.desc, get\_iterator(), \$1.type == External);}

\end{DoxyCode}

\end{DoxyParagraph}
\hypertarget{operators_op_details}{}\doxysection{Operator Details}\label{operators_op_details}
\DoxyHorRuler{0}
 \hypertarget{operators_backquote_operator}{}\doxysubsection{Backquote Operator (\`{}\`{})}\label{operators_backquote_operator}
\begin{DoxyParagraph}{Sandbox Restrictions}
\mbox{\hyperlink{group__parse__options_gaab2d8faa88f066837e100152187e6368}{Qore\+::\+PO\+\_\+\+NO\+\_\+\+EXTERNAL\+\_\+\+PROCESS}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Synopsis}
Executes the shell command in a separate process and returns the stdout as a string. To perform the same action using a Qore expression, see the \mbox{\hyperlink{group__misc__functions_gaee11d366f841cd34c9aa6ac8c7c49577}{backquote()}} function.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily \`{}}{\itshape shell\+\_\+command}{\ttfamily \`{}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_string_type}{string}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{string dir = `ls -\/l`}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by \`{}\`{}}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{3}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Returns}} &{\bfseries{Processing}}  \\\cline{1-3}
unquoted \mbox{\hyperlink{basic_data_types_string}{string}} {\itshape shell\+\_\+command}  &\mbox{\hyperlink{data_type_declarations_string_type}{string}} &The shell command will be executed and the {\ttfamily stdout} is returned as a string  \\\cline{1-3}
\end{longtabu}



\begin{DoxyExceptions}{Exceptions}
{\em BACKQUOTE-\/\+ERROR} & An error occurred in fork() or creating the output pipe\\
\hline
\end{DoxyExceptions}
\DoxyHorRuler{0}
 \hypertarget{operators_hash_element_operator}{}\doxysubsection{Hash Element or Object Member Expression Dereference Operator (\{\})}\label{operators_hash_element_operator}
\begin{DoxyParagraph}{Synopsis}
Retrieves the value of hash key or object member by evaulating an expression.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape \mbox{\hyperlink{expressions}{container\+\_\+expression}}} {\ttfamily \{} {\itshape \mbox{\hyperlink{expressions}{expression}}} {\ttfamily \}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%s\(\backslash\)n"{}}, hash\{getName()\});}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by \{\}}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{container\+\_\+expression}}} &This expression must evaluate to a \mbox{\hyperlink{container_data_types_hash}{hash}} or an \mbox{\hyperlink{container_data_types_object}{object}}; if not, the operator returns no value (\mbox{\hyperlink{basic_data_types_nothing}{NOTHING}})  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{expression}}} &-\/ \mbox{\hyperlink{container_data_types_list}{list}}\+: if the expression evaluates to a list, then a slice of the hash or object is returned as a hash containing keys given in the list that are present in the hash or object. If the key as given in the list (converted to a string if necessary) is not present in the hash or object, then it is also not present in the hash returned; if none of the given keys exist in the hash, an empty hash is returned.~\newline
-\/ anything other than \mbox{\hyperlink{container_data_types_list}{list}}\+: the expression is converted to a string (if necessary); the value of the hash key corresponding to this string will be returned; if the key or member does not exist, then no value is returned  \\\cline{1-2}
\end{longtabu}



\begin{DoxyExceptions}{Exceptions}
{\em PRIVATE-\/\+MEMBER} & Attempt to access a private member outside the class\\
\hline
\end{DoxyExceptions}
\DoxyHorRuler{0}
 \hypertarget{operators_dot_operator}{}\doxysubsection{Hash Element or Object Member Literal Dereference Operator (.)}\label{operators_dot_operator}
\begin{DoxyParagraph}{Synopsis}
Retrieves the value of a hash key or object member using a literal identifier or an expression.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape \mbox{\hyperlink{expressions}{hash\+\_\+or\+\_\+object\+\_\+expression}}} {\ttfamily .} {\itshape identifier} ~\newline
 {\itshape \mbox{\hyperlink{expressions}{object\+\_\+expression}}} {\ttfamily .} {\itshape method\+\_\+name{\ttfamily }(}{\itshape \mbox{[}args ...\mbox{]}}{\ttfamily )}~\newline
 {\itshape \mbox{\hyperlink{expressions}{hash\+\_\+or\+\_\+object\+\_\+expression}}} {\ttfamily .} {\itshape expression} ~\newline
 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%s\(\backslash\)n"{}}, hash.name);}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{obj.method(\textcolor{stringliteral}{"{}argument"{}});}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by . (hash key or object member literal dereference)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{hash\+\_\+or\+\_\+object\+\_\+expression}}} &This expression must evaluate to a hash or an object; if not, then the operator returns no value  \\\cline{1-2}
{\itshape identifier}  &An unquoted string taken as the literal name of the hash key or object member. If no such key exists, then no value is returned. In order to use hash keys that are not valid Qore identifiers, please use the \{\} operator. If the member is a private member and access is made outside the class, a run-\/time exception will be thrown. Also note that constants or static class member names will not be resolved, in this case the string given is used as the literal name of the hash key or object member  \\\cline{1-2}
\end{longtabu}


{\bfseries{Arguments Processed by . (object method call)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{object\+\_\+expression}}} &The {\itshape object\+\_\+expression} must evaluate to an object or a run-\/time exception is thrown  \\\cline{1-2}
{\itshape method\+\_\+name}{\ttfamily (\mbox{[}}{\itshape args}{\ttfamily \mbox{]})} &If the method does not exist in the class a run-\/time exception is thrown. Otherwise the method is called with any optional arguments given and the return value of the method is returned.  \\\cline{1-2}
\end{longtabu}


{\bfseries{Arguments Processed by . (hash key or object member expression dereference)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{hash\+\_\+or\+\_\+object\+\_\+expression}}} &This expression must evaluate to a hash or an object; if not, then the operator returns no value  \\\cline{1-2}
{\itshape expression}  &-\/ \mbox{\hyperlink{container_data_types_list}{list}}\+: if the expression evaluates to a list, then a slice of the hash or object is returned as a hash containing keys given in the list that are present in the hash or object. If the key as given in the list (converted to a string if necessary) is not present in the hash or object, then it is also not present in the hash returned; if none of the given keys exist in the hash, an empty hash is returned.~\newline
-\/ anything other than \mbox{\hyperlink{container_data_types_list}{list}}\+: the expression is converted to a string (if necessary); the value of the hash key corresponding to this string will be returned; if the key or member does not exist, then no value is returned  \\\cline{1-2}
\end{longtabu}



\begin{DoxyExceptions}{Exceptions}
{\em PRIVATE-\/\+MEMBER} & Attempt to access a private member outside the class \\
\hline
{\em METHOD-\/\+DOES-\/\+NOT-\/\+EXIST} & Attempt to access a method not defined for this class \\
\hline
{\em METHOD-\/\+IS-\/\+PRIVATE} & Attempt to access a private method from outside the class \\
\hline
{\em BASE-\/\+CLASS-\/\+IS-\/\+PRIVATE} & Attempt to access a method of a privately-\/inherited base class from outside the class \\
\hline
{\em OBJECT-\/\+METHOD-\/\+EVAL-\/\+ON-\/\+NON-\/\+OBJECT} & Attempt to execute a method on a non-\/object\\
\hline
\end{DoxyExceptions}
\DoxyHorRuler{0}
 \hypertarget{operators_list_element_operator}{}\doxysubsection{List, String, and Binary Dereference Operator (\mbox{[}$\,$\mbox{]})}\label{operators_list_element_operator}
\begin{DoxyParagraph}{Synopsis}
Retrieves given list element(s), given character(s) of a string, or the integer value of given byte for a binary object or the binary object composed of given bytes of a binary object. If the index value is neither a list nor an integer it is converted to an integer. If the index is an integer and out of range, \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}} is returned. If the index is a list and completely out of range, empty list/string/binary is returned. Note that this operator is not supported with multiple values and/or ranges between the square brackets on the left-\/hand side of an assignment expression.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape \mbox{\hyperlink{expressions}{list\+\_\+expression}}}{\ttfamily \mbox{[}}{\itshape \mbox{\hyperlink{expressions}{index\+\_\+expression}}}{\ttfamily \mbox{]}}~\newline
 {\itshape \mbox{\hyperlink{expressions}{string\+\_\+expression}}}{\ttfamily \mbox{[}}{\itshape \mbox{\hyperlink{expressions}{index\+\_\+expression}}}{\ttfamily \mbox{]}}~\newline
 {\itshape \mbox{\hyperlink{expressions}{binary\+\_\+expression}}}{\ttfamily \mbox{[}}{\itshape \mbox{\hyperlink{expressions}{index\+\_\+expression}}}{\ttfamily \mbox{]}}~\newline
 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{int n = (6,2,7,4)[2];}
\DoxyCodeLine{list l = (6,2,7,4)[3,1];}
\DoxyCodeLine{list l = (6,2,7,4)[2..0];}
\DoxyCodeLine{string s = \textcolor{stringliteral}{"{}asdf"{}}[2];}
\DoxyCodeLine{string s = \textcolor{stringliteral}{"{}asdf"{}}[3,1];}
\DoxyCodeLine{string s = \textcolor{stringliteral}{"{}asdf"{}}[1..];}
\DoxyCodeLine{int hex = <4e8a23fe>[2];}
\DoxyCodeLine{binary b = <4e8a23fe>[3,1];}
\DoxyCodeLine{binary b = <4e8a23fe>[..2];}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by \mbox{[}\mbox{]}}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{list\+\_\+expression}}} &If the expression evaluates to a list, then the {\itshape \mbox{\hyperlink{expressions}{index\+\_\+expression}}} will be used to return the given element(s) from the list.  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{string\+\_\+expression}}} &If the expression evaluates to a string, then the {\itshape \mbox{\hyperlink{expressions}{index\+\_\+expression}}} will be used to return the given character(s) from the string; note that multi-\/byte characters with UTF-\/8 are properly respected with this operator.  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{binary\+\_\+expression}}} &If the expression evaluates to a binary, then the {\itshape \mbox{\hyperlink{expressions}{index\+\_\+expression}}} will be used to return the integer value of the given byte from the binary object or the binary object composed of the given bytes.  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{index\+\_\+expression}}} &If the expression does not evaluate to a list or to an integer it is converted to an integer. Then the value(s) of the given element(s) are returned according to the type of the first expression (as listed above; elements start at position 0). If the expression is in the range form (e.\+g. \mbox{[}1..3\mbox{]}, \mbox{[}2..\mbox{]}) then the dereference operator supports \mbox{\hyperlink{operators_op_functional}{lazy functional evaluation}}.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions; if the first expression does not evaluate to either a list, string, or binary, then no value (\mbox{\hyperlink{basic_data_types_nothing}{NOTHING}}) is returned.

\begin{DoxyNote}{Note}
this operator cannot be used on the left-\/hand side of an assignment expression with multiple values between square brackets
\end{DoxyNote}
\begin{DoxySince}{Since}
Qore 0.\+8.\+13 this operator accepts list expressions inside the square brackets
\end{DoxySince}
\DoxyHorRuler{0}
 \hypertarget{operators_pre_increment_operator}{}\doxysubsection{Pre-\/\+Increment Operator (++)}\label{operators_pre_increment_operator}
\begin{DoxyParagraph}{Synopsis}
Increments an lvalue and returns the incremented value; only works on integer and floating-\/point values.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily ++}{\itshape lvalue}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} or \mbox{\hyperlink{data_type_declarations_float_type}{float}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{++i;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by ++ (pre-\/increement)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_float}{Float}} &increments {\itshape lvalue} and returns the result  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_integer}{Integer}} (or any other type) &First converts the value of {\itshape lvalue} to an integer if necessary, then increments {\itshape lvalue} and returns the result  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_post_increment_operator}{}\doxysubsection{Integer Post-\/\+Increment Operator (++)}\label{operators_post_increment_operator}
\begin{DoxyParagraph}{Synopsis}
Increments an integer or floating-\/point lvalue and returns the value before the increment; if the {\itshape lvalue} is neither a floating-\/point value or an integer, it will be converted to an integer
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue}{\ttfamily ++}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{i++;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by ++ (post-\/increment)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_float}{Float}} &saves the value of the {\itshape lvalue} as the result, then increments {\itshape lvalue}, then returns the saved original value of {\itshape lvalue}   \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_integer}{Integer}} (or any other type) &saves the value of the {\itshape lvalue} as the result, then converts the value of {\itshape lvalue} to an integer if necessary and increments it, then returns the saved original value of {\itshape lvalue}   \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_pre_decrement_operator}{}\doxysubsection{Integer Pre-\/\+Decrement Operator (-\/-\/)}\label{operators_pre_decrement_operator}
\begin{DoxyParagraph}{Synopsis}
Decrements an lvalue and returns the incremented value; only works on integer and floating-\/point values.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily --}{\itshape lvalue}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} or \mbox{\hyperlink{data_type_declarations_float_type}{float}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{-\/-\/i;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by -- (pre-\/decrement)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_float}{Float}} &increments {\itshape lvalue} and returns the result  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_integer}{Integer}} (or any other type) &First converts the value of {\itshape lvalue} to an integer if necessary, then increments {\itshape lvalue} and returns the result  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_post_decrement_operator}{}\doxysubsection{Integer Post-\/\+Decrement Operator (-\/-\/)}\label{operators_post_decrement_operator}
\begin{DoxyParagraph}{Synopsis}
Decrements an integer or floating-\/point lvalue and returns the value before the decrement; if the {\itshape lvalue} is neither a floating-\/point value or an integer, it will be converted to an integer
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue}{\ttfamily --}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}
i--;
\end{DoxyParagraph}
{\bfseries{Arguments Processed by -- (post-\/decrement)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_float}{Float}} &saves the value of the {\itshape lvalue} as the result, then decrements {\itshape lvalue}, then returns the saved original value of {\itshape lvalue}   \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_integer}{Integer}} (or any other type) &saves the value of the {\itshape lvalue} as the result, then converts the value of {\itshape lvalue} to an integer if necessary and decrements it, then returns the saved original value of {\itshape lvalue}   \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_new}{}\doxysubsection{New Value Operator (new)}\label{operators_new}
\begin{DoxyParagraph}{Sandbox Restrictions}
\mbox{\hyperlink{group__parse__options_ga9736251c76726706da64426d899b4033}{Qore\+::\+PO\+\_\+\+NO\+\_\+\+NEW}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Synopsis}
This operator instantiates values according to the type and any argument(s) given.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}

\begin{DoxyItemize}
\item {\ttfamily {\bfseries{new}}} {\itshape \mbox{\hyperlink{qore_classes}{class\+\_\+identifier}}}{\ttfamily (}\mbox{[}{\itshape constructor\+\_\+args, ...}\mbox{]}{\ttfamily )}
\item {\ttfamily {\bfseries{new}}} {\ttfamily \mbox{\hyperlink{data_type_declarations_object_type}{object}}$<$}{\itshape \mbox{\hyperlink{qore_classes}{class\+\_\+identifier}}}{\ttfamily $>$(}\mbox{[}{\itshape constructor\+\_\+args, ...}\mbox{]}{\ttfamily )}
\item {\ttfamily {\bfseries{new}}} {\ttfamily \mbox{\hyperlink{data_type_declarations_hash_type}{hash}}$<$}{\itshape \mbox{\hyperlink{hashdecl}{hashdecl\+\_\+identifier}}}{\ttfamily $>$(}\mbox{[}{\itshape hash\+\_\+initializer\+\_\+arg}\mbox{]}{\ttfamily )}
\item {\ttfamily {\bfseries{new}}} {\ttfamily \mbox{\hyperlink{data_type_declarations_hash_type}{hash}}$<$string, }{\itshape \mbox{\hyperlink{data_type_declarations}{type}}}{\ttfamily $>$(}\mbox{[}{\itshape hash\+\_\+initializer\+\_\+arg}\mbox{]}{\ttfamily )}
\item {\ttfamily {\bfseries{new}}} {\ttfamily \mbox{\hyperlink{data_type_declarations_list_type}{list}}$<$}{\itshape \mbox{\hyperlink{data_type_declarations}{type}}}{\ttfamily $>$(}\mbox{[}{\itshape list\+\_\+initializer\+\_\+args, ...}\mbox{]}{\ttfamily )}
\end{DoxyItemize}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}

\begin{DoxyItemize}
\item If the type given is a \mbox{\hyperlink{qore_classes}{class name}} or complex object type with a class name, then this operator returns an object of the specific class given
\item If the type given is a \mbox{\hyperlink{data_type_declarations_hash_hashdecl_type}{hashdecl hash type}}, then this operator returns a type-\/safe hash of the given type.
\item If the type given is a \mbox{\hyperlink{data_type_declarations_hash_complex_type}{complex hash type}}, then this operator returns a hash with type-\/safe key values of the given type.
\item If the type given is a \mbox{\hyperlink{data_type_declarations_list_complex_type}{complex list type}}, then this operator returns a list with type-\/safe element values of the given type.
\end{DoxyItemize}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Examples}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{comment}{\# create an object}}
\DoxyCodeLine{Mutex obj = new Qore::Mutex();}
\DoxyCodeLine{}
\DoxyCodeLine{\textcolor{comment}{\# instantiate a new type-\/safe hash}}
\DoxyCodeLine{hash<MyHash> h1 = new hash<MyHash>();}
\DoxyCodeLine{}
\DoxyCodeLine{\textcolor{comment}{\# instantiate a new hash with type-\/safe key values}}
\DoxyCodeLine{hash<string, int> h2 = new hash<string, int>((\textcolor{stringliteral}{"{}string"{}}: 2));}
\DoxyCodeLine{}
\DoxyCodeLine{\textcolor{comment}{\# instantiate a new list with type-\/safe element values}}
\DoxyCodeLine{list<int> l1 = new list<int>(2);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by new}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape \mbox{\hyperlink{qore_classes}{class\+\_\+identifier}}}{\ttfamily (}\mbox{[}{\itshape constructor\+\_\+args, ...}\mbox{]}{\ttfamily )} &The {\itshape class\+\_\+identifier} must be an existing class name or a namespace-\/prefixed path to an existing class; if so, the operator instantiates an object of this class, executes the constructor for the class (if any exists, along with any base class constructors, if applicable) on the new object, and returns the object (for constructor execution order in an inherited class, see \mbox{\hyperlink{qore_classes_inheritance}{Class Inheritance}}). If an exception is thrown in the constructor, the object is deleted immediately.  \\\cline{1-2}
{\ttfamily \mbox{\hyperlink{data_type_declarations_object_type}{object}}$<$}{\itshape \mbox{\hyperlink{qore_classes}{class\+\_\+identifier}}}{\ttfamily $>$(}\mbox{[}{\itshape constructor\+\_\+args, ...}\mbox{]}{\ttfamily )} &same as above  \\\cline{1-2}
{\ttfamily \mbox{\hyperlink{data_type_declarations_hash_type}{hash}}$<$}{\itshape \mbox{\hyperlink{hashdecl}{hashdecl\+\_\+identifier}}}{\ttfamily $>$(}\mbox{[}{\itshape hash\+\_\+initializer\+\_\+arg}\mbox{]}{\ttfamily )} &The {\itshape hashdecl\+\_\+identifier} must be an existing declared type-\/safe hash name or a namespace-\/prefixed path to an existing type-\/safe hash; if so, the operator instantiates a hash of this type (see \mbox{\hyperlink{hashdecl_hashdecl_creation}{Type-\/\+Safe Hash Creation}} for more info).  \\\cline{1-2}
{\ttfamily \mbox{\hyperlink{data_type_declarations_hash_type}{hash}}$<$string, }{\itshape \mbox{\hyperlink{data_type_declarations}{type}}}{\ttfamily $>$(}\mbox{[}{\itshape hash\+\_\+initializer\+\_\+arg}\mbox{]}{\ttfamily )} &A value of the declared hash with type-\/safe key values is instantiated and returned  \\\cline{1-2}
{\ttfamily \mbox{\hyperlink{data_type_declarations_list_type}{list}}$<$}{\itshape \mbox{\hyperlink{data_type_declarations}{type}}}{\ttfamily $>$(}\mbox{[}{\itshape list\+\_\+initializer\+\_\+args, ...}\mbox{]}{\ttfamily )} &A value of the declared list with type-\/safe key values is instantiated and returned  \\\cline{1-2}
\end{longtabu}


\begin{DoxyNote}{Note}

\begin{DoxyItemize}
\item When instantiating a class, see the class\textquotesingle{}s documentation for possible exceptions
\end{DoxyItemize}
\end{DoxyNote}
\begin{DoxySeeAlso}{See also}
\mbox{\hyperlink{variables_variable_implicit_construction}{Variable Implicit Construction}} for a more concise way to declare and initialize variables.
\end{DoxySeeAlso}
\DoxyHorRuler{0}
 \hypertarget{operators_background}{}\doxysubsection{Background Operator (background)}\label{operators_background}
\begin{DoxyParagraph}{Sandbox Restrictions}
\mbox{\hyperlink{group__parse__options_ga16d8c2b85171b6673b60b5f7d0eaf5eb}{Qore\+::\+PO\+\_\+\+NO\+\_\+\+THREAD\+\_\+\+CONTROL}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Synopsis}
Start a background thread and return the TID (thread ID).
\end{DoxyParagraph}
\begin{DoxyNote}{Note}

\begin{DoxyItemize}
\item expressions that have no effect cannot be used with the background operator (a parse exception will be thrown)
\item it is illegal to make changes to a local variable anywhere in a background expression (a parse exception will be thrown)
\item local variables and find expressions are evaluated before the new thread is started and the result of the evaluation is used in the expression in the new thread
\item it is not possible to pass local variables by reference anywhere in a background expression (a parse exception will be thrown)
\end{DoxyItemize}
\end{DoxyNote}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{background}}} {\itshape \mbox{\hyperlink{expressions}{expression}}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{int tid = background startThread();}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by background}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{expression}}} &The {\itshape \mbox{\hyperlink{expressions}{expression}}} given as an argument will be executed in a new thread. The TID of the new thread will be returned as the return value of the operator  \\\cline{1-2}
\end{longtabu}



\begin{DoxyExceptions}{Exceptions}
{\em THREAD-\/\+CREATION-\/\+FAILURE} & If the thread table is full or if the operating system returns an error while starting the thread, this exception is thrown\\
\hline
\end{DoxyExceptions}
\DoxyHorRuler{0}
 \hypertarget{operators_delete}{}\doxysubsection{Delete Operator (delete)}\label{operators_delete}
\begin{DoxyParagraph}{Synopsis}
The delete operator deletes the contents of an lvalue. If the delete operator is called on an object, the object will be destroyed unconditionally. The delete operator does not return any value.~\newline
~\newline
 When called on a hash key, the key is removed from the hash entirely; when called on a list element, the element is assigned \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}} (i.\+e. the list size does not change).~\newline
~\newline
 The delete operator will delete multiple keys from a hash (i.\+e. delete a slice from a hash) when called on a hash dereferenced by a list of strings, giving the keys to delete (see example below).~\newline
~\newline
 The delete operator will also remove characters from strings, bytes from binary objects, and elements from lists as well.~\newline
~\newline
 In the case the delete operator operates on an object, any exception can be thrown that is thrown by the class\textquotesingle{} destructor.~\newline
~\newline
 For a similar operator that returns the value that is removed from the data structure, and does not delete objects, see the \mbox{\hyperlink{operators_remove}{remove operator}}.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{delete}}} {\itshape lvalue} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
Does not return any value
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{comment}{\# delete a single key from a hash}}
\DoxyCodeLine{delete value;}
\DoxyCodeLine{\textcolor{comment}{\# delete multiple values from a hash}}
\DoxyCodeLine{delete h.(\textcolor{stringliteral}{"{}a"{}}, \textcolor{stringliteral}{"{}b"{}}, \textcolor{stringliteral}{"{}c"{}});}
\DoxyCodeLine{\textcolor{comment}{\# delete characters from a string}}
\DoxyCodeLine{delete str[1,2,5..7];}
\DoxyCodeLine{\textcolor{comment}{\# delete bytes from a binary object}}
\DoxyCodeLine{delete bin[2..4,10,12];}
\DoxyCodeLine{\textcolor{comment}{\# delete elements from a list (if any of the referenced list elements are objects, they will be deleted as well)}}
\DoxyCodeLine{delete l[2,5..7,8];}

\end{DoxyCode}

\end{DoxyParagraph}
This operator does not throw any exceptions, however exceptions could be thrown in an object\textquotesingle{}s destructor method when deleted by this operator.

\DoxyHorRuler{0}
 \hypertarget{operators_remove}{}\doxysubsection{Remove Operator (remove)}\label{operators_remove}
\begin{DoxyParagraph}{Synopsis}
The remove operator removes a value from a data structure, or, in the case the operand of the remove operator is a simple value, the value itself is removed from the variable and returned. The remove operator returns the value removed from the {\itshape lvalue}.~\newline
~\newline
 When called on a hash key, the key is removed from the hash entirely, and the value returned is the value of the key removed from the hash; when called on a list element, the element is assigned \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}} (i.\+e. the list size does not change).~\newline
~\newline
 The remove operator will remove and return a slice from a hash when called on a hash dereferenced by a list of strings, giving the keys to remove (see example below).~\newline
~\newline
 The remove operator will also remove characters from strings, bytes from binary objects, and elements from lists as well; when removing invalid or non-\/existant indices from strings and binary objects, no data is written to the output value, however in the case of a list lvalue, \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}} is written to the output list in these cases. In case the same index is referenced multiple times, the value is repeated in the output value.~\newline
~\newline
 The remove operator does not call destructors when operating on objects, but if removing an object from an lvalue or from a data structure within the {\itshape lvalue} causes the object to go out of scope, it will be destroyed, and then its destructor could throw an exception.~\newline
~\newline
 For a similar operator that deletes the value that is removed from the data structure, see the \mbox{\hyperlink{operators_delete}{delete operator}}.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{remove}}} {\itshape lvalue} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{comment}{\# remove a single value from a hash}}
\DoxyCodeLine{auto var = remove hash.value;}
\DoxyCodeLine{\textcolor{comment}{\# remove a slice from a hash}}
\DoxyCodeLine{hash nh = remove h.(\textcolor{stringliteral}{"{}a"{}}, \textcolor{stringliteral}{"{}b"{}}, \textcolor{stringliteral}{"{}c"{}});}
\DoxyCodeLine{\textcolor{comment}{\# remove a slice from a string}}
\DoxyCodeLine{string nstr = remove str[1,2,5..7];}
\DoxyCodeLine{\textcolor{comment}{\# remove a slice of bytes from a binary object}}
\DoxyCodeLine{binary nbin = remove bin[2..4,10,12];}
\DoxyCodeLine{\textcolor{comment}{\# remove a slice from a list (if any of the referenced list elements are objects, they will be deleted as well)}}
\DoxyCodeLine{list nlist = remove l[2,5..7,8];}

\end{DoxyCode}

\end{DoxyParagraph}
This operator does not throw any exceptions, however exception could be thrown in an object\textquotesingle{}s destructor if it goes out of scope due to the action of this operator.

\DoxyHorRuler{0}
 \hypertarget{operators_cast}{}\doxysubsection{Cast Operator (cast$<$$>$())}\label{operators_cast}
\begin{DoxyParagraph}{Synopsis}
The cast$<$$>$() operator provides a way to tell the parser that the type value is not actually the declared type but rather another compatible type as given between the angle brackets. Parse-\/time and runtime checks are performed for compatibility. Casts to \mbox{\hyperlink{hashdecl}{hashdecl}} types, to the \mbox{\hyperlink{data_type_declarations_hash_type}{hash}}, and to the \mbox{\hyperlink{data_type_declarations_list_type}{list}} types can result in data conversions; see below for more information.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}

\begin{DoxyItemize}
\item {\ttfamily {\bfseries{cast}}$<$}{\itshape \mbox{\hyperlink{qore_classes}{class\+\_\+identifier}}}{\ttfamily $>$(}{\itshape \mbox{\hyperlink{expressions}{object\+\_\+expression}}}{\ttfamily )}
\item {\ttfamily {\bfseries{cast}}$<$\mbox{\hyperlink{data_type_declarations_object_type}{object}}$<$}{\itshape \mbox{\hyperlink{qore_classes}{class\+\_\+identifier}}}{\ttfamily $>$$>$(}{\itshape \mbox{\hyperlink{expressions}{object\+\_\+expression}}}{\ttfamily )}
\item {\ttfamily {\bfseries{cast}}$<$\mbox{\hyperlink{data_type_declarations_hash_type}{hash}}$<$}{\itshape \mbox{\hyperlink{hashdecl}{hashdecl\+\_\+identifier}}}{\ttfamily $>$$>$(}{\itshape \mbox{\hyperlink{expressions}{hash\+\_\+expression}}}{\ttfamily )}
\item {\ttfamily {\bfseries{cast}}$<$\mbox{\hyperlink{data_type_declarations_hash_type}{hash}}$<$string, }{\itshape \mbox{\hyperlink{data_type_declarations}{data\+\_\+type}}}{\ttfamily $>$$>$(}{\itshape \mbox{\hyperlink{expressions}{hash\+\_\+expression}}}{\ttfamily )}
\item {\ttfamily {\bfseries{cast}}$<$\mbox{\hyperlink{data_type_declarations_hash_type}{hash}}$>$(}{\itshape \mbox{\hyperlink{expressions}{hash\+\_\+expression}}}{\ttfamily )}
\item {\ttfamily {\bfseries{cast}}$<$\mbox{\hyperlink{data_type_declarations_list_type}{list}}$<$}{\itshape \mbox{\hyperlink{data_type_declarations}{data\+\_\+type}}}{\ttfamily $>$$>$(}{\itshape list\+\_\+elements, ...}{\ttfamily )}
\item {\ttfamily {\bfseries{cast}}$<$\mbox{\hyperlink{data_type_declarations_list_type}{list}}$>$(}{\itshape list\+\_\+elements, ...}{\ttfamily )}
\end{DoxyItemize}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}

\begin{DoxyItemize}
\item If a \mbox{\hyperlink{qore_classes}{class name}} is given as the target type, then this operator returns an object of the specific class given at runtime.
\item If \mbox{\hyperlink{data_type_declarations_object_type}{object}} is given as the target type, the runtime type must be a valid object or a runtime exception will be raised; no conversion is performed on the object.
\item If a \mbox{\hyperlink{hashdecl}{type-\/safe hash}} type is given as the target type, then this operator returns a hash of the given type at runtime; in this case the hash also undergoes conversion and initialization to the specified type; see \mbox{\hyperlink{hashdecl_hashdecl_creation}{Type-\/\+Safe Hash Creation}} for more information.
\item If a complex type is given as the target type, then this operator will convert the expression\textquotesingle{}s value to the declared type at runtime if possible.
\item If \mbox{\hyperlink{data_type_declarations_hash_type}{hash}} is given as the target type, the runtime type must be a valid hash or a runtime exception will be raised, additionally, any type-\/safe information is removed and an untyped hash is returned
\item If \mbox{\hyperlink{data_type_declarations_list_type}{list}} is given as the target type, the runtime type must be a valid list or a runtime exception will be raised, additionally, any type-\/safe information is removed and an untyped list is returned
\end{DoxyItemize}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Data Conversions with cast$<$$>$(...)}

\begin{DoxyItemize}
\item {\ttfamily {\bfseries{cast}}$<$\mbox{\hyperlink{data_type_declarations_hash_type}{hash}}$<$}{\itshape \mbox{\hyperlink{hashdecl}{hashdecl\+\_\+identifier}}}{\ttfamily $>$$>$(}{\itshape \mbox{\hyperlink{expressions}{hash\+\_\+expression}}}{\ttfamily )}\+: performs initialization of \mbox{\hyperlink{hashdecl}{hashdecl}} keys with initializer expressions for keys not present in the output evaluated hash expression
\item {\ttfamily {\bfseries{cast}}$<$\mbox{\hyperlink{data_type_declarations_hash_type}{hash}}$>$(}{\itshape \mbox{\hyperlink{expressions}{hash\+\_\+expression}}}{\ttfamily )}\+: removes any type-\/safe information from the output evaluated hash expression
\item {\ttfamily {\bfseries{cast}}$<$\mbox{\hyperlink{data_type_declarations_list_type}{list}}$>$(}{\itshape list\+\_\+elements, ...}{\ttfamily )}\+: removes any type-\/safe information from the output evaluated list expression
\end{DoxyItemize}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Examples}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{comment}{\# simple class cast}}
\DoxyCodeLine{cast<SubClass>(obj).method();}
\DoxyCodeLine{}
\DoxyCodeLine{\textcolor{comment}{\# cast with complex object type (class cast)}}
\DoxyCodeLine{cast<object<SubClass>>(obj).method();}
\DoxyCodeLine{}
\DoxyCodeLine{\textcolor{comment}{\# cast to object; ensures a valid object at runtime}}
\DoxyCodeLine{cast<object>(obj);}
\DoxyCodeLine{}
\DoxyCodeLine{\textcolor{comment}{\# hashdecl cast with type conversion}}
\DoxyCodeLine{hash<MyType1> h = cast<hash<MyType1>>(h2);}
\DoxyCodeLine{}
\DoxyCodeLine{\textcolor{comment}{\# complex hash cast}}
\DoxyCodeLine{hash<string, MyClass>h = cast<hash<string, MyClass>(get\_untyped\_hash());}
\DoxyCodeLine{}
\DoxyCodeLine{\textcolor{comment}{\# removes key type information from a type-\/safe hash}}
\DoxyCodeLine{any h = cast<hash>(new hash<MyHashdecl>());}
\DoxyCodeLine{}
\DoxyCodeLine{\textcolor{comment}{\# removes element type information from a type-\/safe list}}
\DoxyCodeLine{any l = cast<list>(new list<int>(1));}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Target Type Argument Processed by cast$<$$>$()}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape \mbox{\hyperlink{qore_classes}{class\+\_\+identifier}}} &This must be a literal unquoted string giving a class name or a namespace-\/qualified path to a class (ex\+: {\ttfamily Namespace\+::\+My\+Class}); a runtime check for compatibility with the target class is performed on the evaluated expression  \\\cline{1-2}
{\ttfamily \mbox{\hyperlink{data_type_declarations_object_type}{object}}$<$}{\itshape \mbox{\hyperlink{qore_classes}{class\+\_\+identifier}}}{\ttfamily $>$} &this is equivalent to {\itshape \mbox{\hyperlink{qore_classes}{class\+\_\+identifier}}} alone; a runtime check for compatibility with the target class is performed on the evaluated expression  \\\cline{1-2}
{\itshape \mbox{\hyperlink{hashdecl}{hashdecl\+\_\+identifier}}} &This must be a literal unquoted string giving a \mbox{\hyperlink{hashdecl}{type-\/safe hash}} name or a namespace-\/qualified path to a type-\/safe hash (ex\+: {\ttfamily Namespace\+::\+My\+Hash}); a runtime check for compatibility with the target \mbox{\hyperlink{hashdecl}{hashdecl}} is performed on the evaluated expression; any keys missing from the expression that have default initializer expressions in the \mbox{\hyperlink{hashdecl}{hashdecl}} are initialized accordingly  \\\cline{1-2}
{\ttfamily \mbox{\hyperlink{data_type_declarations_hash_type}{hash}}$<$string, }{\itshape \mbox{\hyperlink{data_type_declarations}{data\+\_\+type}}}{\ttfamily $>$} &The second type in the type parameter list gives the hash key value type; runtime type compatibility checks are performed but no conversions are made; a runtime exception will be thrown if the evaluated expression does not correspond to the declared type  \\\cline{1-2}
{\ttfamily \mbox{\hyperlink{data_type_declarations_list_type}{list}}$<$}{\itshape \mbox{\hyperlink{data_type_declarations}{data\+\_\+type}}}{\ttfamily $>$} &The single type in the type parameter list gives the list element value type; runtime type compatibility checks are performed but no conversions are made; a runtime exception will be thrown if the evaluated expression does not correspond to the declared type  \\\cline{1-2}
\end{longtabu}



\begin{DoxyExceptions}{Exceptions}
{\em RUNTIME-\/\+CAST-\/\+ERROR} & The expression given does not evaluate to a value that can be converted to the given type\\
\hline
\end{DoxyExceptions}
\DoxyHorRuler{0}
 \hypertarget{operators_logical_negation_operator}{}\doxysubsection{Logical Not Operator (!)}\label{operators_logical_negation_operator}
\begin{DoxyParagraph}{Synopsis}
Reverses the logical sense of an expression (\mbox{\hyperlink{basic_data_types_True}{True}} becomes \mbox{\hyperlink{basic_data_types_False}{False}} and \mbox{\hyperlink{basic_data_types_False}{False}} becomes \mbox{\hyperlink{basic_data_types_True}{True}}).
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily !}{\itshape expression}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (!exists error\_code)}
\DoxyCodeLine{    do\_something();}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by !}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape expression}  &The expression is evaluated and converted to a \mbox{\hyperlink{basic_data_types_boolean}{bool}}, if necessary. Then the value is logically reversed (\mbox{\hyperlink{basic_data_types_True}{True}} becomes \mbox{\hyperlink{basic_data_types_False}{False}}, \mbox{\hyperlink{basic_data_types_False}{False}} becomes \mbox{\hyperlink{basic_data_types_True}{True}})  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_binary_not_operator}{}\doxysubsection{Binary Not Operator ($\sim$)}\label{operators_binary_not_operator}
\begin{DoxyParagraph}{Synopsis}
The value of each bit in an integer is reversed (0 becomes 1, 1 becomes 0).
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily $\sim$}{\itshape \mbox{\hyperlink{expressions}{expression}}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a = \string~b;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $\sim$}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{expression}}} &The argument is converted to an integer (if necessary), and bitwise negation is performed on the argument (ex\+: {\ttfamily 666 \& $\sim$27} results in {\ttfamily 640})  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions

\DoxyHorRuler{0}
 \hypertarget{operators_unary_minus_operator}{}\doxysubsection{Unary Minus Operator (-\/)}\label{operators_unary_minus_operator}
\begin{DoxyParagraph}{Synopsis}
Changes the sign of numeric values.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
-\/expression
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}, \mbox{\hyperlink{data_type_declarations_number_type}{number}}, \mbox{\hyperlink{data_type_declarations_float_type}{float}} or \mbox{\hyperlink{data_type_declarations_date_type}{date}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a = -\/b;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by -\/ (unary minus)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_float}{Float}} &Gives the negative of its argument as a \mbox{\hyperlink{basic_data_types_float}{Float}}, ex\+: {\ttfamily -\/(-\/1.\+1) = 1.\+1, -\/(1.\+1) = -\/1.\+1}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_integer}{Integer}} &Gives the negative of its argument as an \mbox{\hyperlink{basic_data_types_integer}{Integer}}, ex\+: {\ttfamily -\/(-\/1) = 1, -\/(1) = -\/1}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_number}{Number}} &Gives the negative of its argument as a \mbox{\hyperlink{basic_data_types_number}{Number}}, ex\+: {\ttfamily -\/(-\/1.\+1n) = 1.\+1n, -\/(1.\+1n) = -\/1.\+1n}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_date}{Date}} &Gives the negative of its argument as a \mbox{\hyperlink{basic_data_types_date}{Date}}, ex\+: {\ttfamily -\/(-\/1s) = 1s, -\/(1s) = -\/1s}  \\\cline{1-2}
other &Returns 0  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions

\DoxyHorRuler{0}
 \hypertarget{operators_unary_plus_operator}{}\doxysubsection{Unary Plus Operator (+)}\label{operators_unary_plus_operator}
\begin{DoxyParagraph}{Synopsis}
Does nothing with numeric values, converts others to 0.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
+{\itshape \mbox{\hyperlink{expressions}{expression}}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}, \mbox{\hyperlink{data_type_declarations_number_type}{number}}, \mbox{\hyperlink{data_type_declarations_float_type}{float}} or \mbox{\hyperlink{data_type_declarations_date_type}{date}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a = +b;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by + (unary minus)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_float}{Float}} &Gives the value of its argument as a \mbox{\hyperlink{basic_data_types_float}{Float}}, ex\+: {\ttfamily +1.\+1 = 1.\+1}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_integer}{Integer}} &Gives the value of its argument as an \mbox{\hyperlink{basic_data_types_integer}{Integer}}, ex\+: {\ttfamily +1 = 1}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_number}{Number}} &Gives the value of its argument as a \mbox{\hyperlink{basic_data_types_number}{Number}}, ex\+: {\ttfamily +1.\+1n = 1.\+1n}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_date}{Date}} &Gives the value of its argument as a \mbox{\hyperlink{basic_data_types_date}{Date}}, ex\+: {\ttfamily +1s = 1s}  \\\cline{1-2}
other &Returns 0  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions

\DoxyHorRuler{0}
 \hypertarget{operators_shift}{}\doxysubsection{Shift Operator (shift)}\label{operators_shift}
\begin{DoxyParagraph}{Synopsis}
Removes the first element from a list and returns that element. Throws a parse-\/time exception if the {\itshape lvalue} is known not to be a list at parse time, otherwise throws a runtime exception if the {\itshape lvalue} is not a list if \mbox{\hyperlink{parse_directives_strict-args}{\%strict-\/args}} is in effect.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{shift}}} {\itshape lvalue} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{*string a = shift ARGV;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by shift}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape lvalue}  &Returns the first element of the list, and the list is modified by having the first element removed from the list. If the {\itshape lvalue} is an empty list, the operator returns no value (\mbox{\hyperlink{basic_data_types_nothing}{NOTHING}}).  \\\cline{1-2}
\end{longtabu}


This operator throws an exception if the {\itshape lvalue} is not a list.

\DoxyHorRuler{0}
 \hypertarget{operators_pop}{}\doxysubsection{Pop Operator (pop)}\label{operators_pop}
\begin{DoxyParagraph}{Synopsis}
Removes the last element from a list and returns that element. Throws a parse-\/time exception if the {\itshape lvalue} is known not to be a list at parse time, otherwise throws a runtime exception if the {\itshape lvalue} is not a list if \mbox{\hyperlink{parse_directives_strict-args}{\%strict-\/args}} is in effect.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{pop}}} {\itshape lvalue} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a = pop list;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by pop}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape lvalue}  &Returns the last element of the list, and the list is modified, having the last element removed from the list. If the {\itshape lvalue} is an empty list, the operator returns no value (\mbox{\hyperlink{basic_data_types_nothing}{NOTHING}}).  \\\cline{1-2}
\end{longtabu}


This operator throws an exception if the {\itshape lvalue} is not a list.

\DoxyHorRuler{0}
 \hypertarget{operators_chomp}{}\doxysubsection{Chomp Operator (chomp)}\label{operators_chomp}
\begin{DoxyParagraph}{Synopsis}
Removes the end-\/of-\/line marker(s) ({\ttfamily \textquotesingle{}\textbackslash{}n\textquotesingle{}} or {\ttfamily \textquotesingle{}\textbackslash{}r\textbackslash{}n\textquotesingle{}}) from a string, or each string element in a list, or each hash key value in a hash (if the value is a string) and returns the number of characters removed.~\newline
~\newline
 To perform this operation on a non-\/lvalue expression, see the \mbox{\hyperlink{group__string__functions_ga802f2d1c8deb1b120b649bb1e3652095}{chomp()}} function.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{chomp}}}{\itshape lvalue}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{chomp str;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by chomp}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{basic_data_types_string}{String}}) &Removes any EOL characters from a string and returns the number of characters removed.  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{container_data_types_list}{List}}) &Removes any EOL characters from each string element of the list passed and returns the number of characters removed.  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{container_data_types_hash}{Hash}}) &Removes any EOL characters from each hash key\textquotesingle{}s value (where the value is a string) and returns the number of characters removed.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_trim}{}\doxysubsection{Trim Operator (trim)}\label{operators_trim}
\begin{DoxyParagraph}{Synopsis}
Removes whitespace characters from the beginning and end of a string, or each string element in a list, or each hash key value in a hash (if the value is a string) and returns the value processed (string, list, or hash).~\newline
~\newline
 To perform this operation on a non-\/lvalue expression, see the \mbox{\hyperlink{group__string__functions_gae8d314e819a299d46d181696600d4293}{trim()}} function.~\newline
~\newline
 The following whitespace characters are removed from the beginning and end of strings\+: {\ttfamily \textquotesingle{} \textquotesingle{}} (blank spaces), {\ttfamily \textquotesingle{}\textbackslash{}n\textquotesingle{}}, {\ttfamily \textquotesingle{}\textbackslash{}r\textquotesingle{}}, {\ttfamily \textquotesingle{}\textbackslash{}t\textquotesingle{}}, {\ttfamily \textquotesingle{}\textbackslash{}v\textquotesingle{}} (vertical tab, ASCII 11), and {\ttfamily \textquotesingle{}\textbackslash{}0\textquotesingle{}} (null character).
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{trim}}} {\itshape lvalue} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_string_type}{string}}, \mbox{\hyperlink{data_type_declarations_list_type}{list}}, or \mbox{\hyperlink{data_type_declarations_hash_type}{hash}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{trim str;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by trim}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{basic_data_types_string}{String}}) &Removes whitespace characters from the beginning and end of a string and returns the value processed.  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{container_data_types_list}{List}}) &Removes whitespace characters from the beginning and end of each string element of the list passed and returns the list.  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{container_data_types_hash}{Hash}}) &Removes whitespace characters from the beginning and end of each string value of the hash passed and returns the hash.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_map}{}\doxysubsection{Map Operator (map)}\label{operators_map}
\begin{DoxyParagraph}{Synopsis}
Executes (or maps) an expression on a list and returns the result. An optional select expression can be given to filter elements out from the result list.~\newline
~\newline
 If the first argument is a single element hash expression using curly brackets, then the \mbox{\hyperlink{operators_hmap}{hash variant of the map operator}} is used instead.~\newline
~\newline
 If the second argument ({\itshape \mbox{\hyperlink{expressions}{iterator\+\_\+expression}}}) is an object inheriting the \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}} class, the {\bfseries{{\ttfamily map}}} operator iterates the object by calling \mbox{\hyperlink{class_qore_1_1_abstract_iterator_ab10d5694cc2fcd3b6689ea7494da79de}{Abstract\+Iterator\+::next()}}, and the implicit argument {\ttfamily \$1} in the {\itshape \mbox{\hyperlink{expressions}{map\+\_\+expression}}} and any optional {\itshape \mbox{\hyperlink{expressions}{select\+\_\+expression}}} is the value returned by \mbox{\hyperlink{class_qore_1_1_abstract_iterator_aa01374b285003faa21b045082063ac12}{Abstract\+Iterator\+::get\+Value()}}.~\newline
~\newline
 If the second argument is not a list or an object inheriting \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}}, then {\itshape \mbox{\hyperlink{expressions}{map\+\_\+expression}}} is executed on the single value and the result is returned (assuming that any {\itshape \mbox{\hyperlink{expressions}{select\+\_\+expression}}} accepts the value).~\newline
~\newline
 If possible, {\itshape \mbox{\hyperlink{expressions}{iterator\+\_\+expression}}} is evaluated using \mbox{\hyperlink{operators_op_functional}{lazy functional evaluation}}.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{map}}} {\itshape \mbox{\hyperlink{expressions}{map\+\_\+expression}}}{\ttfamily ,} {\itshape \mbox{\hyperlink{expressions}{iterator\+\_\+expression}} \mbox{[}, \mbox{\hyperlink{expressions}{select\+\_\+expression}}\mbox{]}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Examples}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{comment}{\# returns (2, 4, 6)}}
\DoxyCodeLine{list l = map \$1 * 2, (1, 2, 3);}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{comment}{\# prints out the keys of a hash; one to a line}}
\DoxyCodeLine{map \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%s\(\backslash\)n"{}}, \$1), hash.keyIterator();}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by map}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{map\+\_\+expression}}} &The expression to map on the list; the implicit argument {\ttfamily \$1} represents the current element being processed  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{iterator\+\_\+expression}}} &The data to process; if this is not a list then the {\itshape \mbox{\hyperlink{expressions}{map\+\_\+expression}}} is run on the single argument passed, unless the {\itshape \mbox{\hyperlink{expressions}{iterator\+\_\+expression}}} is an object inheriting the \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}} class; in this case the {\bfseries{{\ttfamily map}}} operator iterates the object by calling \mbox{\hyperlink{class_qore_1_1_abstract_iterator_ab10d5694cc2fcd3b6689ea7494da79de}{Abstract\+Iterator\+::next()}}; if supported, this expression is evaluated using \mbox{\hyperlink{operators_op_functional}{lazy functional evaluation}}  \\\cline{1-2}
{\itshape \mbox{[}\mbox{\hyperlink{expressions}{select\+\_\+expression}}\mbox{]}} &An optional expression than can be used to filter out elements of the list before the {\itshape \mbox{\hyperlink{expressions}{map\+\_\+expression}}} is applied; if this expression evaluates to \mbox{\hyperlink{basic_data_types_False}{False}} on an element, then the element will be skipped and the {\itshape \mbox{\hyperlink{expressions}{map\+\_\+expression}}} will not be applied on that element.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions (however note that exceptions could be thrown by expressions executed by this operator).

\begin{DoxySeeAlso}{See also}
\mbox{\hyperlink{operators_hmap}{Hash Map Operator (map)}} for a variant of this operator that creates and returns a hash rather than a list
\end{DoxySeeAlso}
\begin{DoxySince}{Since}
Qore 0.\+8.\+6.\+2 the map operator when used with an \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}} object instantiates the value returned by \mbox{\hyperlink{class_qore_1_1_abstract_iterator_aa01374b285003faa21b045082063ac12}{Abstract\+Iterator\+::get\+Value()}} instead of the iterator itself
\end{DoxySince}
\begin{DoxyNote}{Note}
the non-\/hash version of the {\bfseries{{\ttfamily map}}} operator supports \mbox{\hyperlink{operators_op_functional}{lazy functional evaluation}} of itself and also of the {\itshape \mbox{\hyperlink{expressions}{iterator\+\_\+expression}}}
\end{DoxyNote}
\DoxyHorRuler{0}
 \hypertarget{operators_hmap}{}\doxysubsection{Hash Map Operator (map)}\label{operators_hmap}
\begin{DoxyParagraph}{Synopsis}
This variant of the map operator builds a hash from a list or iterator argument and can be differentiated from the standard list \mbox{\hyperlink{operators_map}{map}} operator by the use of curly brackets in the initial expression; in this case the hash version of the map operator is used. This operator executes (or maps) an expression on a list and returns the result in form of a hash. An optional select expression can be given to filter elements out from the result hash.~\newline
~\newline
 If the first argument is anything other than a single element hash expression using curly brackets, then the \mbox{\hyperlink{operators_map}{list variant of the map operator}} is used instead.~\newline
~\newline
 If the third argument ({\itshape \mbox{\hyperlink{expressions}{iterator\+\_\+expression}}}) is an object inheriting the \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}} class, the {\bfseries{{\ttfamily map}}} operator iterates the object by calling \mbox{\hyperlink{class_qore_1_1_abstract_iterator_ab10d5694cc2fcd3b6689ea7494da79de}{Abstract\+Iterator\+::next()}}, and the implicit argument {\ttfamily \$1} in the {\itshape \mbox{\hyperlink{expressions}{key\+\_\+expression}}} and {\itshape \mbox{\hyperlink{expressions}{value\+\_\+expression}}} and any optional {\itshape \mbox{\hyperlink{expressions}{select\+\_\+expression}}} is the value returned by \mbox{\hyperlink{class_qore_1_1_abstract_iterator_aa01374b285003faa21b045082063ac12}{Abstract\+Iterator\+::get\+Value()}}.~\newline
~\newline
 If the third argument is not a list or an object inheriting \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}}, then {\itshape \mbox{\hyperlink{expressions}{key\+\_\+expression}}} and {\itshape \mbox{\hyperlink{expressions}{value\+\_\+expression}}} are executed on the single value and the result is returned as a single element hash (assuming that any {\itshape \mbox{\hyperlink{expressions}{select\+\_\+expression}}} accepts the value).~\newline
~\newline
 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{container_data_types_hash}{Hash}} in case of a {\itshape \mbox{\hyperlink{expressions}{iterator\+\_\+expression}}} with a value, otherwise \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{map}} \{}{\itshape \mbox{\hyperlink{expressions}{key\+\_\+expression}}} {\ttfamily \+:} {\itshape \mbox{\hyperlink{expressions}{value\+\_\+expression}}}{\ttfamily \},} {\itshape \mbox{\hyperlink{expressions}{iterator\+\_\+expression}} \mbox{[}, \mbox{\hyperlink{expressions}{select\+\_\+expression}}\mbox{]}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Examples}

\begin{DoxyCode}{0}
\DoxyCodeLine{hash h = map \{\$1 : \$1 * 2\}, (1, 2, 3);}
\DoxyCodeLine{\textcolor{comment}{\# returns: \{"{}1"{}: 2, "{}2"{}: 4, "{}3"{}: 6\}}}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{hash h = map \{\$1 : \$1 * 2\}, (1, 2, 3), \$1 > 1;}
\DoxyCodeLine{\textcolor{comment}{\# returns: \{"{}2"{}: 4, "{}3"{}: 6\}}}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by the hash version of map}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{key\+\_\+expression}}} &The expression to map on the list or iterator value which will result in the key for the current hash element; the implicit argument {\ttfamily \$1} represents the current element being processed. The result of the expression is converted to a string to be used as the hash key for the current element  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{value\+\_\+expression}}} &The expression to map on the list which will result in the value for the current hash element; the implicit argument {\ttfamily \$1} represents the current element being processed  \\\cline{1-2}
{\itshape \mbox{\hyperlink{expressions}{iterator\+\_\+expression}}} &The data to process; if this is not a list then the {\itshape \mbox{\hyperlink{expressions}{key\+\_\+expression}}} and {\itshape \mbox{\hyperlink{expressions}{value\+\_\+expression}}} are run on the single argument passed, unless the {\itshape \mbox{\hyperlink{expressions}{iterator\+\_\+expression}}} is an object inheriting the \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}} class; in this case the {\bfseries{{\ttfamily map}}} operator iterates the object by calling \mbox{\hyperlink{class_qore_1_1_abstract_iterator_ab10d5694cc2fcd3b6689ea7494da79de}{Abstract\+Iterator\+::next()}}; if supported, this expression is evaluated using \mbox{\hyperlink{operators_op_functional}{lazy functional evaluation}}  \\\cline{1-2}
{\itshape \mbox{[}\mbox{\hyperlink{expressions}{select\+\_\+expression}}\mbox{]}} &An optional expression than can be used to filter out elements of the list before the map expression is applied; if this expression evaluates to \mbox{\hyperlink{basic_data_types_False}{False}} on an element, then the element will be skipped and the {\itshape \mbox{\hyperlink{expressions}{key\+\_\+expression}}} and {\itshape \mbox{\hyperlink{expressions}{value\+\_\+expression}}} will not be applied on that element.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions (however note that exceptions could be thrown by expressions executed by this operator).

\begin{DoxySeeAlso}{See also}
\mbox{\hyperlink{operators_map}{Map Operator (map)}} for a variant of this operator that creates and returns a list
\end{DoxySeeAlso}
\begin{DoxySince}{Since}
Qore 0.\+8.\+12 this variant of the map operator exists which builds a hash from a list or iterator source
\end{DoxySince}
\DoxyHorRuler{0}
 \hypertarget{operators_foldl}{}\doxysubsection{Fold Left Operator (foldl)}\label{operators_foldl}
\begin{DoxyParagraph}{Synopsis}
Folds an operation on a list from left to right and returns the result. The result of each individual operation is used as the first argument in the foldl expression for the next element in the list. The first operation of the fold is made by executing the fold expression on the first and second elements of the list, from this point onwards, the result of each successive operation is used as the first argument for the next operation, the second argument being the next element in the list.~\newline
~\newline
 If the second argument ({\itshape iterator\+\_\+expression}) is an object inheriting the \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}} class, the {\bfseries{{\ttfamily foldl}}} operator iterates the object by calling \mbox{\hyperlink{class_qore_1_1_abstract_iterator_ab10d5694cc2fcd3b6689ea7494da79de}{Abstract\+Iterator\+::next()}}, and the implicit arguments {\ttfamily \$1} and {\ttfamily \$2} in {\itshape expression} are the container values returned by \mbox{\hyperlink{class_qore_1_1_abstract_iterator_aa01374b285003faa21b045082063ac12}{Abstract\+Bidirectional\+Iterator\+::get\+Value()}}.~\newline
~\newline
 If the {\itshape iterator\+\_\+expression} does not evaluate to a list or an object inheriting \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}}, then the evaluated argument is returned immediately with no processing by the {\bfseries{{\ttfamily foldl}}} expression.~\newline
~\newline
 If possible, {\itshape iterator\+\_\+expression} is evaluated using \mbox{\hyperlink{operators_op_functional}{lazy functional evaluation}}.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{foldl}}} {\itshape expression}, {\itshape iterator\+\_\+expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Examples}
The following returns {\ttfamily {\bfseries{foldl}}} expression returns {\ttfamily 5} 
\begin{DoxyCode}{0}
\DoxyCodeLine{int result = foldl \$1 -\/ \$2, (10, 4, 1);}

\end{DoxyCode}
 ~\newline
 The following {\ttfamily {\bfseries{foldl}}} expression joins a list with {\ttfamily \char`\"{}, \char`\"{}} or returns a single argument (if the second operand is not a list) 
\begin{DoxyCode}{0}
\DoxyCodeLine{string str = foldl \$1 + \textcolor{stringliteral}{"{}, "{}} + \$2, list;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by foldl}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape expression}  &The expression to fold on the list; the implicit argument {\ttfamily \$1} represents the result of the last operation (or the first element in the list when beginning the fold), and {\ttfamily \$2} represents the next element of the list.  \\\cline{1-2}
{\itshape iterator\+\_\+expression}  &The list, \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}} object or other value according to the rules above to process; if possible, this expression is evaluated using \mbox{\hyperlink{operators_op_functional}{lazy functional evaluation}}.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions (however note that exceptions could be thrown by expressions executed by this operator).

\begin{DoxyNote}{Note}
the {\bfseries{{\ttfamily foldl}}} operator supports \mbox{\hyperlink{operators_op_functional}{lazy functional evaluation}} of the {\itshape iterator\+\_\+expression} 
\end{DoxyNote}
\DoxyHorRuler{0}
 \hypertarget{operators_foldr}{}\doxysubsection{Fold Right Operator (foldr)}\label{operators_foldr}
\begin{DoxyParagraph}{Synopsis}
Folds an operation on a list from right to left and returns the result. The result of each individual operation is used as the first argument in the foldr expression for the next element in the list in reverse order. The first operation of the right fold is made by executing the fold expression on the last and penultimate elements of the list, from this point onwards, the result of each successive operation is used as the first argument for the next operation, the second argument being the next element in the list in reverse order.~\newline
~\newline
 If the second argument ({\itshape iterator\+\_\+expression}) is an object inheriting the \mbox{\hyperlink{class_qore_1_1_abstract_bidirectional_iterator}{Abstract\+Bidirectional\+Iterator}} class, the {\bfseries{{\ttfamily foldr}}} operator iterates the object by calling \mbox{\hyperlink{class_qore_1_1_abstract_bidirectional_iterator_a8ca43ac8bffc78178f61e3cca9b6323e}{Abstract\+Bidirectional\+Iterator\+::prev()}}, and the implicit arguments {\ttfamily \$1} and {\ttfamily \$2} in {\itshape expression} are the container values returned by \mbox{\hyperlink{class_qore_1_1_abstract_iterator_aa01374b285003faa21b045082063ac12}{Abstract\+Bidirectional\+Iterator\+::get\+Value()}}.~\newline
~\newline
 If the {\itshape iterator\+\_\+expression} does not evaluate to a list or an object inheriting \mbox{\hyperlink{class_qore_1_1_abstract_bidirectional_iterator}{Abstract\+Bidirectional\+Iterator}}, then the evaluated argument is returned immediately with no processing by the {\bfseries{{\ttfamily foldr}}} expression.~\newline
~\newline
 If possible, {\itshape iterator\+\_\+expression} is evaluated using \mbox{\hyperlink{operators_op_functional}{lazy functional evaluation}}.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{foldr}}} {\itshape expression}, {\itshape iterator\+\_\+expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{comment}{\# returns -\/13}}
\DoxyCodeLine{foldr \$1 -\/ \$2, (10, 4, 1);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by foldr}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape expression}  &The expression to fold on the list; the implicit argument {\ttfamily \$1} represents the result of the last operation (or the last element in the list when beginning the fold), and {\ttfamily \$2} represents the next element of the list in reverse order.  \\\cline{1-2}
{\itshape iterator\+\_\+expression}  &The list, \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}} object or other value according to the rules above to process; if possible, this expression is evaluated using \mbox{\hyperlink{operators_op_functional}{lazy functional evaluation}}.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions (however note that exceptions could be thrown by expressions executed by this operator).

\begin{DoxyNote}{Note}
the {\bfseries{{\ttfamily foldr}}} operator supports \mbox{\hyperlink{operators_op_functional}{lazy functional evaluation}} of the {\itshape iterator\+\_\+expression} 
\end{DoxyNote}
\DoxyHorRuler{0}
 \hypertarget{operators_select}{}\doxysubsection{Select From List Operator (select)}\label{operators_select}
\begin{DoxyParagraph}{Synopsis}
Selects elements from a list that meet the given criteria and returns the new list.~\newline
~\newline
 If the first argument ({\itshape iterator\+\_\+expression}) is an object inheriting the \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}} class, the {\bfseries{{\ttfamily select}}} operator iterates the object by calling \mbox{\hyperlink{class_qore_1_1_abstract_iterator_ab10d5694cc2fcd3b6689ea7494da79de}{Abstract\+Iterator\+::next()}}, and the implicit argument {\ttfamily \$1} in {\itshape expression} is the value returned by \mbox{\hyperlink{class_qore_1_1_abstract_iterator_aa01374b285003faa21b045082063ac12}{Abstract\+Iterator\+::get\+Value()}}; in this case the operator always returns a list (which may be empty if {\itshape expression} returns \mbox{\hyperlink{basic_data_types_False}{False}} for all elements in the iterator object or if the iterator object is empty), and the value of the object in the list returned is the value returned by \mbox{\hyperlink{class_qore_1_1_abstract_iterator_aa01374b285003faa21b045082063ac12}{Abstract\+Iterator\+::get\+Value()}}.~\newline
~\newline
 If the list expression does not evaluate to a list or an object inheriting \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}}, then the select expression is evaluated using the value of the list expression as an argument, if it evaluates to \mbox{\hyperlink{basic_data_types_True}{True}}, then the value is returned, otherwise, no value is returned.~\newline
~\newline
 If possible, {\itshape expression} is evaluated using \mbox{\hyperlink{operators_op_functional}{lazy functional evaluation}}.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{select}}} {\itshape iterator\+\_\+expression}, {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{comment}{\# returns (2, 4, 6)}}
\DoxyCodeLine{select (1, 2, 3, 4, 5, 6), !(\$1 \% 2);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by select}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape iterator\+\_\+expression}  &The list to process or an object inheriting \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}}  \\\cline{1-2}
{\itshape expression}  &The expression will be evaluated on each element of the list, the implicit argument {\ttfamily \$1} represents current element of the list (or the iterator object itself when {\itshape iterator\+\_\+expression} is an object inheriting \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}}); only if the expression evaluates to \mbox{\hyperlink{basic_data_types_True}{True}} will the element appear in the result list  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions (however note that exceptions could be thrown by the expression executed by this operator).

\begin{DoxySince}{Since}
Qore 0.\+8.\+6.\+2 the map operator when used with an \mbox{\hyperlink{class_qore_1_1_abstract_iterator}{Abstract\+Iterator}} object instantiates the value returned by \mbox{\hyperlink{class_qore_1_1_abstract_iterator_aa01374b285003faa21b045082063ac12}{Abstract\+Iterator\+::get\+Value()}} instead of the iterator itself
\end{DoxySince}
\begin{DoxyNote}{Note}
the {\bfseries{{\ttfamily select}}} operator supports \mbox{\hyperlink{operators_op_functional}{lazy functional evaluation}} of itself and also of the {\itshape iterator\+\_\+expression} 
\end{DoxyNote}
\DoxyHorRuler{0}
 \hypertarget{operators_elements}{}\doxysubsection{Elements Operator (elements)}\label{operators_elements}
\begin{DoxyParagraph}{Synopsis}
Returns the number of elements in a list, the number of keys in a hash, the number of characters (not bytes) in a string, or the number of bytes in a binary object.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{elements}}} {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{int size = elements list;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by elements}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape expression} \mbox{\hyperlink{data_type_declarations_list_type}{list}} &Returns the number of elements in the list  \\\cline{1-2}
{\itshape expression} \mbox{\hyperlink{data_type_declarations_hash_type}{hash}} &Returns the number of keys in the hash  \\\cline{1-2}
{\itshape expression} \mbox{\hyperlink{data_type_declarations_string_type}{string}} &Returns the number of characters in the string (which may be different than the number of bytes for multi-\/byte character encodings such as {\ttfamily UTF-\/8}   \\\cline{1-2}
{\itshape expression} \mbox{\hyperlink{data_type_declarations_binary_type}{binary}} &Returns the number of bytes in the binary object  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\begin{DoxySeeAlso}{See also}
\mbox{\hyperlink{class_qore_1_1zzz8valuezzz9_a794caed9de093e89d88bfbe652e15a06}{Qore\+::zzz8valuezzz9\+::size()}}
\end{DoxySeeAlso}
\DoxyHorRuler{0}
 \hypertarget{operators_keys}{}\doxysubsection{Keys Operator (keys)}\label{operators_keys}
\begin{DoxyParagraph}{Synopsis}
Returns a list representing the keys in a hash.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{keys}}} {\itshape hash\+\_\+expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_list_type}{list}} or \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{foreach string key \textcolor{keywordflow}{in} (keys hash)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%s = \%s\(\backslash\)n"{}}, key, hash\{key\});}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by keys}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape hash\+\_\+expression}  &Returns a list of strings giving the keys in {\itshape hash\+\_\+expression}, which must evaluate to a hash. If not, then no value is returned.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\begin{DoxySeeAlso}{See also}

\begin{DoxyItemize}
\item \mbox{\hyperlink{class_qore_1_1zzz8hashzzz9_abea95265a8d43bda81e922865978fa1f}{Qore\+::zzz8hashzzz9\+::keys()}}
\item \mbox{\hyperlink{class_qore_1_1zzz8objectzzz9_a5e962eaf47dbfc60312f5f6c4ba500ad}{Qore\+::zzz8objectzzz9\+::keys()}}
\end{DoxyItemize}
\end{DoxySeeAlso}
\DoxyHorRuler{0}
 \hypertarget{operators_multiplication_operator}{}\doxysubsection{Multiply Operator ($\ast$)}\label{operators_multiplication_operator}
\begin{DoxyParagraph}{Synopsis}
Multiplies two arguments.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} {\ttfamily $\ast$} {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}, \mbox{\hyperlink{data_type_declarations_float_type}{float}}, or \mbox{\hyperlink{data_type_declarations_number_type}{number}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{value = x * y;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $\ast$ (in order of precedence)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_number_type}{number}} &Gives the result of multiplying its arguments; \mbox{\hyperlink{basic_data_types_integer}{ints}} and \mbox{\hyperlink{basic_data_types_float}{floats}} are converted to \mbox{\hyperlink{basic_data_types_number}{numbers}} if at least one of the arguments is a \mbox{\hyperlink{basic_data_types_number}{number}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_float_type}{float}} &Gives the result of multiplying its arguments; \mbox{\hyperlink{basic_data_types_integer}{ints}} are converted to \mbox{\hyperlink{basic_data_types_float}{floats}} if at least one of the arguments is a \mbox{\hyperlink{basic_data_types_float}{float}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &Gives the result of multiplying its arguments  \\\cline{1-2}
any other type &Converts argument to a \mbox{\hyperlink{basic_data_types_number}{number}} and performs the multiplication  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_division_operator}{}\doxysubsection{Divide Operator (/)}\label{operators_division_operator}
\begin{DoxyParagraph}{Synopsis}
Divides a number by another.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} {\ttfamily /} {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}, \mbox{\hyperlink{data_type_declarations_float_type}{float}}, or \mbox{\hyperlink{data_type_declarations_number_type}{number}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{value = x / y;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by / (in order of precedence)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_number_type}{number}} &Gives the result of dividing its arguments; \mbox{\hyperlink{basic_data_types_integer}{ints}} and \mbox{\hyperlink{basic_data_types_float}{floats}} are converted to \mbox{\hyperlink{basic_data_types_number}{numbers}} if at least one of the arguments is a \mbox{\hyperlink{basic_data_types_number}{number}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_float_type}{float}} &Gives the result of dividing its arguments; \mbox{\hyperlink{basic_data_types_integer}{ints}} are converted to \mbox{\hyperlink{basic_data_types_float}{floats}} if at least one of the arguments is a \mbox{\hyperlink{basic_data_types_float}{float}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &Gives the result of dividing its arguments  \\\cline{1-2}
any other type &Converts argument to a \mbox{\hyperlink{data_type_declarations_float_type}{float}} and performs the division  \\\cline{1-2}
\end{longtabu}



\begin{DoxyExceptions}{Exceptions}
{\em DIVISION-\/\+BY-\/\+ZERO} & division by zero error\\
\hline
\end{DoxyExceptions}
\DoxyHorRuler{0}
 \hypertarget{operators_modulo_operator}{}\doxysubsection{Modulo Operator (\%)}\label{operators_modulo_operator}
\begin{DoxyParagraph}{Synopsis}
Gives the integer remainder after division of one number by another.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} {\ttfamily \%} {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{mod = x \% y;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by \%}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &Gives {\itshape expression1} modulo {\itshape expression2} (ex\+: {\ttfamily 12 \% 10} result in {\ttfamily 2}). Arguments are converted to integers if necessary.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_plus_operator}{}\doxysubsection{Plus (\+Addition and Concatenation) Operator (+)}\label{operators_plus_operator}
\begin{DoxyParagraph}{Synopsis}
Numeric addition, list, string, binary, and hash concatenation operator.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} {\ttfamily +} {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}, \mbox{\hyperlink{data_type_declarations_float_type}{float}}, \mbox{\hyperlink{data_type_declarations_number_type}{number}}, \mbox{\hyperlink{data_type_declarations_date_type}{date}}, \mbox{\hyperlink{data_type_declarations_list_type}{list}}, \mbox{\hyperlink{data_type_declarations_string_type}{string}}, \mbox{\hyperlink{data_type_declarations_binary_type}{binary}}, or \mbox{\hyperlink{data_type_declarations_hash_type}{hash}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a = 1 + 2;}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{string = \textcolor{stringliteral}{"{}hello"{}} + \textcolor{stringliteral}{"{}-\/there"{}};}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{list = (1, 2) + (\textcolor{stringliteral}{"{}three"{}}, \textcolor{stringliteral}{"{}four"{}}, \textcolor{stringliteral}{"{}five"{}});}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{hash = ( \textcolor{stringliteral}{"{}key1"{}} : 1, \textcolor{stringliteral}{"{}key2"{}} : 2) + ( \textcolor{stringliteral}{"{}key3"{}} : \textcolor{stringliteral}{"{}three"{}}, \textcolor{stringliteral}{"{}key4"{}}: \textcolor{stringliteral}{"{}four"{}});}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{bin = bin1 + bin2;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by + (in order of precedence)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_list_type}{list}} list &Gives the result of concatenating its arguments, i.\+e. {\ttfamily (1, 2) + (3, 4) = (1, 2, 3, 4)}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} &Gives the result of concatenating its arguments  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_date_type}{date}} &Gives the result of adding date/time values (see \mbox{\hyperlink{date_time_arithmetic}{Date/\+Time Arithmetic}})  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_number_type}{number}} &Gives the result of adding its arguments  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_float_type}{float}} &Gives the result of adding its arguments  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &Gives the result of adding its arguments  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_hash_type}{hash}} &Gives the result of concatenating/merging its arguments. Any common keys will be overwritten by the values in the second hash ({\itshape expression2})  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_minus_operator}{}\doxysubsection{Minus Operator (-\/)}\label{operators_minus_operator}
\begin{DoxyParagraph}{Synopsis}
With \mbox{\hyperlink{basic_data_types_float}{float}}, \mbox{\hyperlink{basic_data_types_integer}{integer}}, or \mbox{\hyperlink{basic_data_types_number}{number}} arguments, subtracts one number from another.~\newline
~\newline
 With \mbox{\hyperlink{basic_data_types_date}{date}} arguments, subtracts one date from another; if both date arguments are \mbox{\hyperlink{basic_data_types_absolute_dates}{absolute dates}}, the result is a \mbox{\hyperlink{basic_data_types_relative_dates}{relative date}} (duration) giving the time between them; if the first date argument is an \mbox{\hyperlink{basic_data_types_absolute_dates}{absolute date}} and the second is a \mbox{\hyperlink{basic_data_types_relative_dates}{relative date}} (duration), then the result is an \mbox{\hyperlink{basic_data_types_absolute_dates}{absolute date}}. If both date arguments are \mbox{\hyperlink{basic_data_types_relative_dates}{relative dates}}, then the result is a \mbox{\hyperlink{basic_data_types_relative_dates}{relative date}}. If the first argument is a \mbox{\hyperlink{basic_data_types_relative_dates}{relative date}} and the second date is an \mbox{\hyperlink{basic_data_types_absolute_dates}{absolute date}}, the \mbox{\hyperlink{basic_data_types_absolute_dates}{absolute date}}\textquotesingle{}s epoch offset (offset in seconds and microseconds from {\ttfamily 1970-\/01-\/01Z}) is used to perform the calculation, and a \mbox{\hyperlink{basic_data_types_relative_dates}{relative date/time value}} is produced.~\newline
~\newline
 However, if the left-\/hand side is a \mbox{\hyperlink{container_data_types_hash}{hash}}, and the right-\/hand side is a string, then the result will be a new hash with the hash key represented by the string removed. If the left-\/hand side is a hash and the right-\/hand side is a list, then a new hash will be produced and each element from the list will be converted to a string key and any hash item with a matching key will be deleted from the new hash. Having both left and right arguments hashes is an invalid operation which does not modify the hashes in any way and silently returns \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}}.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} {\ttfamily -\/} {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}, \mbox{\hyperlink{data_type_declarations_float_type}{float}}, \mbox{\hyperlink{data_type_declarations_number_type}{number}}, \mbox{\hyperlink{data_type_declarations_date_type}{date}}, or \mbox{\hyperlink{data_type_declarations_hash_type}{hash}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{num = x -\/ y;}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{date = 2010-\/05-\/13 -\/ P3MT14H10M;}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{hash = hash -\/ \textcolor{stringliteral}{"{}key"{}};}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{hash = hash -\/ (\textcolor{stringliteral}{"{}key1"{}}, \textcolor{stringliteral}{"{}key2"{}}, \textcolor{stringliteral}{"{}key3"{}});}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by -\/ (in order of precedence)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_date_type}{date}} &date subtraction\+: {\itshape expression1} -\/ {\itshape expression2}   \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_number_type}{number}} &arithmetic subtraction\+: {\itshape expression1} -\/ {\itshape expression2}   \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_float_type}{float}} &arithmetic subtraction\+: {\itshape expression1} -\/ {\itshape expression2}   \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &arithmetic subtraction\+: {\itshape expression1} -\/ {\itshape expression2}   \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_hash_type}{hash}} -\/ \mbox{\hyperlink{data_type_declarations_string_type}{string}} &hash key deletion\+: {\itshape expression1} -\/ {\itshape expression2}   \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_hash_type}{hash}} -\/ \mbox{\hyperlink{data_type_declarations_list_type}{list}} &hash key deletion\+: {\itshape expression1} -\/ {\itshape expression2}; all elements of the list are converted to strings (if necessary) and any keys with those names are deleted from the hash.  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_hash_type}{hash}} -\/ \mbox{\hyperlink{data_type_declarations_hash_type}{hash}} &no-\/op; silently returns \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}}  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_shift_right_operator}{}\doxysubsection{Shift Right Operator ($>$$>$)}\label{operators_shift_right_operator}
\begin{DoxyParagraph}{Synopsis}
Shifts bits in an integer towards zero (divides an integer by a power of 2)
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} {\ttfamily $>$$>$} {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a = x >> y;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $>$$>$}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &Gives the result of shifting {\itshape expression1} right by {\itshape expression2} bits. Arguments are converted to integers if necesssary.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_shift_left_operator}{}\doxysubsection{Shift Left Operator ($<$$<$)}\label{operators_shift_left_operator}
\begin{DoxyParagraph}{Synopsis}
Shifts bits in an integer towards infinity (multiplies an integer by a power of 2)
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} {\ttfamily $<$$<$} {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a = x << y;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $<$$<$}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &Gives the result of shifting {\itshape expression1} left by {\itshape expression2} bits. Arguments are converted to integers if necessary.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_instanceof}{}\doxysubsection{Operator (instanceof)}\label{operators_instanceof}
\begin{DoxyParagraph}{Synopsis}
Tests if an expression is an instance of the given type or not, meaning that the type can accept the value.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression} {\ttfamily {\bfseries{instanceof}}} {\itshape type\+\_\+identifier} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (obj instanceof Qore::Mutex)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga996c5d1686fbc245f0bc7a02012e6a33}{print}}(\textcolor{stringliteral}{"{}object is Mutex\(\backslash\)n"{}});}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by instanceof}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape expression}  &If expression is an instance of the named type, which is defined as the type is able to accept the value, then the operator returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_exists}{}\doxysubsection{Exists Operator (exists)}\label{operators_exists}
\begin{DoxyParagraph}{Synopsis}
Tests if an expression represents a value or not.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{exists}}} {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (exists a)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}a = n\(\backslash\)n"{}}, a);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by exists}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape expression}  &If {\itshape expression} evaluates to a value, then the operator returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_logical_less_than_operator}{}\doxysubsection{Less Than Operator ($<$)}\label{operators_logical_less_than_operator}
\begin{DoxyParagraph}{Synopsis}
Tests if a value is less than another; types are converted if necessary (ex\+: {\ttfamily (\char`\"{}1\char`\"{} $<$ 2)} is \mbox{\hyperlink{basic_data_types_True}{True}}).
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} $<$ {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (x < y)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%n is less than \%n\(\backslash\)n"{}}, x, y);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $<$ (in order of precedence)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_number_type}{number}} &If {\itshape expression1} is numerically less than {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_float_type}{float}} &If {\itshape expression1} is numerically less than {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &If {\itshape expression1} is numerically less than {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} &If {\itshape expression1} comes before {\itshape expression2} in string sort order, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_date_type}{date}} &If {\itshape expression1} is before (or a shorter amount of time than of the arguments are \mbox{\hyperlink{basic_data_types_relative_dates}{Relative Date/\+Time Values (Durations)}}) {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_logical_greater_than_operator}{}\doxysubsection{Greater Than Operator ($>$)}\label{operators_logical_greater_than_operator}
\begin{DoxyParagraph}{Synopsis}
Tests if a value is greater than another; types are converted if necessary (ex\+: {\ttfamily (\char`\"{}2\char`\"{} $>$ 1)} is \mbox{\hyperlink{basic_data_types_True}{True}}).
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} $>$ {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (x > y)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%n is less than \%n\(\backslash\)n"{}}, x, y);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $>$ (in order of precedence)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_number_type}{number}} &If {\itshape expression1} is numerically greater than {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_float_type}{float}} &If {\itshape expression1} is numerically greater than {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &If {\itshape expression1} is numerically greater than {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} &If {\itshape expression1} comes after {\itshape expression2} in string sort order, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_date_type}{date}} &If {\itshape expression1} is after {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_logical_equality_operator}{}\doxysubsection{Equals Operator (==)}\label{operators_logical_equality_operator}
\begin{DoxyParagraph}{Synopsis}
Tests if a value is equal to another; types are converted if necessary (ex\+: {\ttfamily (\char`\"{}1\char`\"{} == 1)} is \mbox{\hyperlink{basic_data_types_True}{True}}). For absolute equals, where types must also be equal to return true, see the \mbox{\hyperlink{operators_logical_absolute_equality_operator}{Absolute Equals Operator (===)}}.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} == {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (x == y)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%n is equal to \%n\(\backslash\)n"{}}, x, y);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by == (in order of precedence)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} &If {\itshape expression1} is equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_number_type}{number}} &If {\itshape expression1} is equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_float_type}{float}} &If {\itshape expression1} is equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &If {\itshape expression1} is equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_date_type}{date}} &If {\itshape expression1} is equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_list_type}{list}} &If each element in the each list where order is relevant satisfies this operator, the operator returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise it returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_hash_type}{hash}} &If each hash has the same keys and the value of each equal key in each hash satisfies this operator, the operator returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise it returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_binary_type}{binary}} &If {\itshape expression1\textquotesingle{}s} memory contents and size are equal to {\itshape expression2\textquotesingle{}s}, then returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_object_type}{object}} &If {\itshape expression1} is a reference to the same object as {\itshape expression2}, then returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_null}{NULL}} &If both expressions are \mbox{\hyperlink{basic_data_types_null}{NULL}}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_nothing}{NOTHING}} &If neither expression has a value, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_logical_inequality_operator}{}\doxysubsection{Not Equals Operator (!=)}\label{operators_logical_inequality_operator}
\begin{DoxyParagraph}{Synopsis}
Tests if a value is not equal to another; types are converted if necessary (ex\+: {\ttfamily (\char`\"{}1\char`\"{} != 1)} is \mbox{\hyperlink{basic_data_types_False}{False}}).
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} != {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (x != y)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%n is not equal to \%n\(\backslash\)n"{}}, x, y);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by != (in order of precedence)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} &If {\itshape expression1} is not equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_number_type}{number}} &If {\itshape expression1} is not equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_float_type}{float}} &If {\itshape expression1} is not equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &If {\itshape expression1} is not equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_date_type}{date}} &If {\itshape expression1} is not equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_list_type}{list}} &If each element in the each list where order is relevant satisfies this operator, the operator returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise it returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_hash_type}{hash}} &If the hashes have different keys or the value of each equal key in each hash satisfies this operator, the operator returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise it returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_binary_type}{binary}} &If {\itshape expression1\textquotesingle{}s} memory contents or size are not equal to {\itshape expression2\textquotesingle{}s}, then returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_object_type}{object}} &If {\itshape expression1} is not a reference to the same object as {\itshape expression2}, then returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_null}{NULL}} &If either expressions is not \mbox{\hyperlink{basic_data_types_null}{NULL}}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{basic_data_types_nothing}{NOTHING}} &If one of the expressions has a value, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_logical_less_than_or_equals_operator}{}\doxysubsection{Less Than Or Equals Operator ($<$=)}\label{operators_logical_less_than_or_equals_operator}
\begin{DoxyParagraph}{Synopsis}
Tests if a value is less than or equals to another value; types are converted if necessary (ex\+: {\ttfamily (\char`\"{}1\char`\"{} $<$= 2)} is \mbox{\hyperlink{basic_data_types_True}{True}}).
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} $<$= {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (x <= y)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%n is less than or equal to \%n\(\backslash\)n"{}}, x, y);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $<$= (in order of precedence)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_number_type}{number}} &If {\itshape expression1} is numerically less than or equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_float_type}{float}} &If {\itshape expression1} is numerically less than or equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &If {\itshape expression1} is numerically less than or equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} &If {\itshape expression1} comes before in string sort order or is the same as {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_date_type}{date}} &If {\itshape expression1} is before or is the same exact date and time as {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_logical_greater_than_or_equals_operator}{}\doxysubsection{Greater Than Or Equals Operator ($>$=)}\label{operators_logical_greater_than_or_equals_operator}
\begin{DoxyParagraph}{Synopsis}
Tests if a value is greater than or equals to another value; types are converted if necessary (ex\+: {\ttfamily (\char`\"{}2\char`\"{} $>$= 1)} is \mbox{\hyperlink{basic_data_types_True}{True}}).
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} $>$= {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (x >= y)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%n is greater than or equal to \%n\(\backslash\)n"{}}, x, y);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $>$= (in order of precedence)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_number_type}{number}} &If {\itshape expression1} is numerically greater than or equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_float_type}{float}} &If {\itshape expression1} is numerically greater than or equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &If {\itshape expression1} is numerically greater than or equal to {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} &If {\itshape expression1} comes after in string sort order or is the same as {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_date_type}{date}} &If {\itshape expression1} is after or is the same exact date and time as {\itshape expression2}, returns \mbox{\hyperlink{basic_data_types_True}{True}}, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_logical_comparison_operator}{}\doxysubsection{Comparison ($<$=$>$) Operator}\label{operators_logical_comparison_operator}
\begin{DoxyParagraph}{Synopsis}
Tests if the left-\/hand value is less than, equal, or greater than the right-\/hand value; types are converted if necessary (ex\+: (\char`\"{}1\char`\"{} $<$=$>$ 2) returns -\/1).
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} $<$=$>$ {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{switch (x <=> y) \{}
\DoxyCodeLine{    case -\/1:}
\DoxyCodeLine{        \mbox{\hyperlink{group__string__functions_ga996c5d1686fbc245f0bc7a02012e6a33}{print}}(\textcolor{stringliteral}{"{}x is less than y\(\backslash\)n"{}});}
\DoxyCodeLine{        \textcolor{keywordflow}{break};}
\DoxyCodeLine{}
\DoxyCodeLine{    case 0:}
\DoxyCodeLine{        \mbox{\hyperlink{group__string__functions_ga996c5d1686fbc245f0bc7a02012e6a33}{print}}(\textcolor{stringliteral}{"{}x is equal to y\(\backslash\)n"{}});}
\DoxyCodeLine{        \textcolor{keywordflow}{break};}
\DoxyCodeLine{}
\DoxyCodeLine{    case 1:}
\DoxyCodeLine{        \mbox{\hyperlink{group__string__functions_ga996c5d1686fbc245f0bc7a02012e6a33}{print}}(\textcolor{stringliteral}{"{}x is greater than y\(\backslash\)n"{}});}
\DoxyCodeLine{        \textcolor{keywordflow}{break};}
\DoxyCodeLine{\}}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $<$=$>$ (in order of precedence)}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} &If {\itshape expression1} comes after in string sort order as {\itshape expression2}, returns {\ttfamily 1}, otherwise if they are equal, returns {\ttfamily 0}, otherwise if {\itshape expression1} comes before {\itshape expression2}, returns {\ttfamily -\/1}   \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_number_type}{number}} &If {\itshape expression1} is numerically greater than {\itshape expression2}, returns {\ttfamily 1}, otherwise if they are equal returns {\ttfamily 0}, otherwise returns {\ttfamily -\/1}   \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_float_type}{float}} &If {\itshape expression1} is numerically greater than {\itshape expression2}, returns {\ttfamily 1}, otherwise if they are equal returns {\ttfamily 0}, otherwise returns {\ttfamily -\/1}   \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &If {\itshape expression1} is numerically greater than {\itshape expression2}, returns {\ttfamily 1}, otherwise if they are equal returns {\ttfamily 0}, otherwise returns {\ttfamily -\/1}   \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_date_type}{date}} &If {\itshape expression1} is after {\itshape expression2}, returns {\ttfamily 1}, otherwise if they are equal returns {\ttfamily 0}, otherwise returns {\ttfamily -\/1}   \\\cline{1-2}
\end{longtabu}


This operator throws NAN-\/\+COMPARE-\/\+ERROR if any of the operands is NaN.

\DoxyHorRuler{0}
 \hypertarget{operators_logical_absolute_equality_operator}{}\doxysubsection{Absolute Equals Operator (===)}\label{operators_logical_absolute_equality_operator}
\begin{DoxyParagraph}{Synopsis}
Checks two values for equality without doing any data type conversions; if the types do not match, then the result is \mbox{\hyperlink{basic_data_types_False}{False}}.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} === {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (x === y)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%n is equal to \%n and has the same data type as well\(\backslash\)n"{}}, x, y);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by ===}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &This operator returns \mbox{\hyperlink{basic_data_types_True}{True}} only if the types and values of both sides of the operator are exactly equal, otherwise returns \mbox{\hyperlink{basic_data_types_False}{False}}. No type conversions are done.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_logical_absolute_inequality_operator}{}\doxysubsection{Absolute Not Equals Operator (!==)}\label{operators_logical_absolute_inequality_operator}
\begin{DoxyParagraph}{Synopsis}
Checks two values for inequality without doing any data type conversions. If the data types do not match, then returns \mbox{\hyperlink{basic_data_types_True}{True}}.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} !== {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (x !== y)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%n is not equal to \%n and may not have the data type as well\(\backslash\)n"{}}, x, y);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by !==}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &This operator returns \mbox{\hyperlink{basic_data_types_True}{True}} if either the types or the values of the arguments are different, otherwise it retuns \mbox{\hyperlink{basic_data_types_False}{False}}. No type conversions are done.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_regex_match_operator}{}\doxysubsection{Regular Expression Match Operator (=$\sim$)}\label{operators_regex_match_operator}
\begin{DoxyParagraph}{Synopsis}
Checks for a regular expression match; returns \mbox{\hyperlink{basic_data_types_True}{True}} if the expression matches the string, \mbox{\hyperlink{basic_data_types_False}{False}} if not. See \mbox{\hyperlink{qore_regex_qore_regex_options}{Qore Regular Expression Operator Options}} for the meaning of the {\ttfamily i}, {\ttfamily s}, {\ttfamily x}, and {\ttfamily m} options after the regular expression.~\newline
~\newline
 See \mbox{\hyperlink{qore_regex}{Regular Expressions}} for more information about regular expression support in Qore.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression} {\ttfamily =$\sim$ \mbox{[}m\mbox{]}/}{\itshape regex}{\ttfamily /\mbox{[}isxmu\mbox{]}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (str =\string~ /hello/)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%s contains 'hello'\(\backslash\)n"{}}, str);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by =$\sim$}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} &This operator returns \mbox{\hyperlink{basic_data_types_True}{True}} if the regular expression in {\itshape regex} matches the string in {\itshape expression}.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_regex_no_match_operator}{}\doxysubsection{Regular Expression No Match Operator (!$\sim$)}\label{operators_regex_no_match_operator}
\begin{DoxyParagraph}{Synopsis}
Checks for a regular expression non match; returns \mbox{\hyperlink{basic_data_types_True}{True}} if the expression does not match the string, \mbox{\hyperlink{basic_data_types_False}{False}} if it does. See \mbox{\hyperlink{qore_regex_qore_regex_options}{Qore Regular Expression Operator Options}} for the meaning of the {\ttfamily i}, {\ttfamily s}, {\ttfamily x}, and {\ttfamily m} options after the regular expression.~\newline
~\newline
 See \mbox{\hyperlink{qore_regex}{Regular Expressions}} for more information about regular expression support in Qore.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression} {\ttfamily !$\sim$ \mbox{[}m\mbox{]}/}{\itshape regex}{\ttfamily /\mbox{[}isxmu\mbox{]}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (str !\string~ /hello/)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%s does not contain 'hello'\(\backslash\)n"{}}, str);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by !$\sim$}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} &This operator returns \mbox{\hyperlink{basic_data_types_True}{True}} if the regular expression in {\itshape regex} does not match the string in {\itshape expression}.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_regex_subst_operator}{}\doxysubsection{Regular Expression Substitution Operator}\label{operators_regex_subst_operator}
\begin{DoxyParagraph}{Synopsis}
Looks for a regular expression match in a string, and, if found, substitutes the matched string with a new string. Subpattern backreferences are supported in the target string, {\ttfamily \$1}=first subpattern, {\ttfamily \$2}=second subpattern, etc... See \mbox{\hyperlink{qore_regex_qore_regex_options}{Qore Regular Expression Operator Options}} for the meaning of the {\ttfamily i}, {\ttfamily s}, {\ttfamily x}, and {\ttfamily m} options after the regular expression.~\newline
~\newline
 See \mbox{\hyperlink{qore_regex}{Regular Expressions}} for more information about regular expression support in Qore.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue} {\ttfamily =$\sim$ s/}{\itshape regex\+\_\+pattern}{\ttfamily /}{\itshape target\+\_\+string}{\ttfamily /\mbox{[}isxmug\mbox{]}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} or \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}} (if the {\itshape lvalue} does not hold a string)
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{str =\string~ s/hello/goodbye/i;}
\DoxyCodeLine{str =\string~ s/(\(\backslash\)w+) +(\(\backslash\)w+)/\$2, \$1/;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by =$\sim$ s///}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} &This operator substitutes text in the {\itshape lvalue} string if the regular expression matches. Subpattern backreferences are supported in {\itshape target\+\_\+string}, {\ttfamily \$1}=first subpattern, {\ttfamily \$2}=second subpattern, etc..  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_regex_extract_operator}{}\doxysubsection{Regular Expression Pattern Extraction Operator}\label{operators_regex_extract_operator}
\begin{DoxyParagraph}{Synopsis}
Matches regular expression patterns (enclosed in parentheses) in a string and returns a list giving the text matched for each pattern. If the regular expression does not match, then no value (\mbox{\hyperlink{basic_data_types_nothing}{NOTHING}}) is returned. See \mbox{\hyperlink{qore_regex_qore_regex_options}{Qore Regular Expression Operator Options}} for the meaning of the {\ttfamily i}, {\ttfamily s}, {\ttfamily x}, and {\ttfamily m} options after the regular expression.~\newline
~\newline
 See \mbox{\hyperlink{qore_regex}{Regular Expressions}} for more information about regular expression support in Qore.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape string} {\ttfamily =$\sim$ x/}{\itshape regex\+\_\+with\+\_\+patterns}{\ttfamily /\mbox{[}isxmug\mbox{]}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_list_type}{list}} or \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}} (if the {\itshape lvalue} does not hold a string or if the pattern is not matched)
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{list =\string~ x/(\(\backslash\)w+):(\(\backslash\)w+)/;}
\DoxyCodeLine{list =\string~ x/(.*)\(\backslash\).(.*)/;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by =$\sim$ x//}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} &This operator extracts strings from {\itshape string} based on patterns enclosed in parentheses in the regular expression.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_transliteration_operator}{}\doxysubsection{Transliteration Operator}\label{operators_transliteration_operator}
\begin{DoxyParagraph}{Synopsis}
Makes character substitutions in an lvalue; character ranges can also be used.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue} {\ttfamily =$\sim$ tr/}{\itshape source\+\_\+chars}{\ttfamily /}{\itshape target\+\_\+chars}{\ttfamily /}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} or \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}} (if the {\itshape lvalue} does not hold a string)
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{str =\string~ tr/a-\/z/A-\/Z/;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by =$\sim$ tr//}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_string_type}{string}} &This operator substitutes characters in the {\itshape lvalue} string. Note that if there are more characters in {\itshape source\+\_\+chars} than in {\itshape target\+\_\+chars}, then the last character in {\itshape target\+\_\+chars} will be used for any source matches where the source character position is greater than the length of {\itshape target\+\_\+chars}.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_bitwise_and_operator}{}\doxysubsection{Bitwise/\+Binary And Operator (\&)}\label{operators_bitwise_and_operator}
\begin{DoxyParagraph}{Synopsis}
Performs a bitwise (binary) AND operation on two integers.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} \& {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a = x \& y;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by \&}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &Gives the result of the binary (bitwise) AND operation between {\itshape expression1} and {\itshape expression2} (ex\+: {\ttfamily 0xffb2 \& 0xa1 = 0xa1}); operands are converted to integers if necessary.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_bitwise_or_operator}{}\doxysubsection{Bitwise/\+Binary Or Operator ($\vert$)}\label{operators_bitwise_or_operator}
\begin{DoxyParagraph}{Synopsis}
Performs a bitwise (binary) OR operation on two integers.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} $\vert$ {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a = x | y;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $\vert$}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &Gives the result of the binary (bitwise) OR operation between {\itshape expression1} and {\itshape expression2} (ex\+: {\ttfamily 0xb001 $|$ 0xfea = 0xbfeb}); operands are converted to integers if necessary  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_bitwise_xor_operator}{}\doxysubsection{Bitwise/\+Binary Xor Operator ($^\wedge$)}\label{operators_bitwise_xor_operator}
\begin{DoxyParagraph}{Synopsis}
Performs a bitwise (binary) XOR operation on two integers.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} $^\wedge$ {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a = x \string^ y;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $^\wedge$}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &Gives the result of the binary (bitwise) EXCLUSIVE OR operation between {\itshape expression1} and {\itshape expression2} (ex\+: {\ttfamily 0xaef1 \& 0xfb32 = 0x55c3}); operands are converted to integers if necessary  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_logical_and_operator}{}\doxysubsection{Logical And Operator (\&\&)}\label{operators_logical_and_operator}
\begin{DoxyParagraph}{Synopsis}
Checks to see if two expressions are \mbox{\hyperlink{basic_data_types_True}{True}} with logical short-\/circuiting.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} \&\& {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (x \&\& y)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}\%n and \%n are both True\(\backslash\)n"{}}, x, y);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by \&\&}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}} &Returns \mbox{\hyperlink{basic_data_types_True}{True}} if both expressions are \mbox{\hyperlink{basic_data_types_True}{True}}, \mbox{\hyperlink{basic_data_types_False}{False}} if otherwise. Logical short-\/circuiting is implemented; if {\itshape expression1} is \mbox{\hyperlink{basic_data_types_False}{False}}, then {\itshape expression2} is not evaluated, and the operator returns \mbox{\hyperlink{basic_data_types_False}{False}}.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_logical_or_operator}{}\doxysubsection{Logical Or Operator ($\vert$$\vert$)}\label{operators_logical_or_operator}
\begin{DoxyParagraph}{Synopsis}
Returns \mbox{\hyperlink{basic_data_types_True}{True}} if either of the arguments are \mbox{\hyperlink{basic_data_types_True}{True}} with logical short-\/circuiting.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} $\vert$$\vert$ {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keywordflow}{if} (x || y)}
\DoxyCodeLine{    \mbox{\hyperlink{group__string__functions_ga32070517a9f8a70a32ef48f83a6f128e}{printf}}(\textcolor{stringliteral}{"{}either \%n or \%n or both are True\(\backslash\)n"{}}, x, y);}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $\vert$$\vert$}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_bool_type}{bool}} &Returns \mbox{\hyperlink{basic_data_types_True}{True}} if either or both expressions evaluate to \mbox{\hyperlink{basic_data_types_True}{True}}, \mbox{\hyperlink{basic_data_types_False}{False}} if otherwise. Logical short-\/circuiting is implemented; if {\itshape expression1} is \mbox{\hyperlink{basic_data_types_True}{True}}, then {\itshape expression2} is not evaluated, and the operator returns \mbox{\hyperlink{basic_data_types_True}{True}}.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_conditional_operator}{}\doxysubsection{Conditional Operator (? \+:)}\label{operators_conditional_operator}
\begin{DoxyParagraph}{Synopsis}
Evaluates and returns the value of one of two expressions depending on the value of a conditional expression.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression} ? {\itshape if\+\_\+true\+\_\+expression} \+: {\itshape if\+\_\+false\+\_\+expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a = (z > 100 ? \textcolor{stringliteral}{"{}Big"{}} : \textcolor{stringliteral}{"{}Small"{}});}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by ? \+:}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &If {\itshape expression} is evaluated to be \mbox{\hyperlink{basic_data_types_True}{True}}, then the {\itshape if\+\_\+true\+\_\+expression} is evaluated and returned. Otherwise the {\itshape if\+\_\+false\+\_\+expression} is evaluated and returned.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_null_coalescing_operator}{}\doxysubsection{Null Coalescing Operator (??)}\label{operators_null_coalescing_operator}
\begin{DoxyParagraph}{Synopsis}
Evaluates the first operand and checks for a value (i. e. not \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}} or \mbox{\hyperlink{basic_data_types_null}{NULL}}). If it evaluates to a value, then the value of the first operand is returned, otherwise the second operand is evaluated and returned. When chained, the first argument with a value is returned.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} ?? {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{x = a ?? b ?? c;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by ??}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &If {\itshape expression1} is evaluated to be \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}} or \mbox{\hyperlink{basic_data_types_null}{NULL}} then the {\itshape expession2} is evaluated and returned. Otherwise the value of {\itshape expression1} is returned.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

See also \mbox{\hyperlink{operators_value_coalescing_operator}{Value Coalescing Operator (?$\ast$)}} that works same except for operands are evaluated based on being \mbox{\hyperlink{basic_data_types_False}{False}} instead of being \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}} or \mbox{\hyperlink{basic_data_types_null}{NULL}}.

\DoxyHorRuler{0}
 \hypertarget{operators_value_coalescing_operator}{}\doxysubsection{Value Coalescing Operator (?$\ast$)}\label{operators_value_coalescing_operator}
\begin{DoxyParagraph}{Synopsis}
Evaluates the first operand and checks for a value (\mbox{\hyperlink{basic_data_types_True}{True}} or \mbox{\hyperlink{basic_data_types_False}{False}}). If it evaluates to \mbox{\hyperlink{basic_data_types_True}{True}}, then the value of the first operand is returned, otherwise the second operand is evaluated and returned. When chained, the first argument with a value is returned.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} ?$\ast$ {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{x = a ?* b ?* c;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by ?$\ast$}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &If {\itshape expression1} is evaluated to be \mbox{\hyperlink{basic_data_types_False}{False}} then the {\itshape expession2} is evaluated and returned. Otherwise the value of {\itshape expression1} is returned.  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

See also \mbox{\hyperlink{operators_null_coalescing_operator}{Null Coalescing Operator (??)}} that works same except for operands are evaluated based on being \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}} or \mbox{\hyperlink{basic_data_types_null}{NULL}} instead of being \mbox{\hyperlink{basic_data_types_False}{False}}.

\DoxyHorRuler{0}
 \hypertarget{operators_comma_operator}{}\doxysubsection{Comma Operator (,)}\label{operators_comma_operator}
\begin{DoxyParagraph}{Synopsis}
Makes a list from more than one element.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1}, {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_list_type}{list}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a = 1, 2, \textcolor{stringliteral}{"{}three"{}};}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by ,}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &The comma operator builds lists of arguments  \\\cline{1-2}
\end{longtabu}


This operator does not throw any exceptions.

\DoxyHorRuler{0}
 \hypertarget{operators_unshift}{}\doxysubsection{Unshift Operator (unshift)}\label{operators_unshift}
\begin{DoxyParagraph}{Synopsis}
Inserts an element into the first position of a list, moves all other elements up one position and returns the list processed. Throws an exception if the {\itshape lvalue} is not a list.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{unshift}}} {\itshape lvalue}, {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_list_type}{list}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{unshift list, \textcolor{stringliteral}{"{}one"{}};}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by unshift}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &Inserts the value of {\itshape expression} as the first element in the list given by {\itshape lvalue}. All other elements in the list are moved forward. If {\itshape expression} evaluates to a list, this list will be appended as the last element of {\itshape lvalue}. To concatenate lists, use the \mbox{\hyperlink{operators_plus_operator}{plus operator}}.  \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_push}{}\doxysubsection{Push Operator (push)}\label{operators_push}
\begin{DoxyParagraph}{Synopsis}
Adds one element to the end of a list and returns the list processed. Throws a parse-\/time exception if the {\itshape lvalue} is known not to be a list at parse time, otherwise throws a runtime exception if the {\itshape lvalue} is not a list if \mbox{\hyperlink{parse_directives_strict-args}{\%strict-\/args}} is in effect.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{push}}} {\itshape lvalue}, {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_list_type}{list}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{push list, \textcolor{stringliteral}{"{}last"{}};}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by push}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &Appends the value of the {\itshape expression} as the last element in the list given by {\itshape lvalue}. If {\itshape expression} evaluates to a list, this list will be appended as the last element of {\itshape lvalue}. To concatenate lists, use the \mbox{\hyperlink{operators_plus_operator}{plus operator}}.  \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_splice}{}\doxysubsection{Splice Operator (splice)}\label{operators_splice}
\begin{DoxyParagraph}{Synopsis}
Removes and optionally inserts elements in lists, strings, and binary objects and returns the {\itshape lvalue} after processing. For a similar operator that returns the values removed, see the \mbox{\hyperlink{operators_extract}{extract operator}}.~\newline
~\newline
 Works on strings, lists, and binary data in a similar way; removes elements from a list, characters from a string, or bytes from binary data and optionally inserts new ones. If no {\itshape length\+\_\+expression} is given, splice removes all elements/characters/bytes from the list, string, or binary data lvalue starting at {\itshape offset\+\_\+expression} (offsets begin at 0). Otherwise, a number of elements/characters/bytes equal to {\itshape length\+\_\+expression} is removed (or up to the end of the list/string/data if applicable). If {\itshape substitution\+\_\+expression} is present, then the removed elements/characters/bytes are substituted with the elements/string/bytes given by this expression.~\newline
~\newline
 Note that string splice takes character offsets, which may not be the same as byte offsets for multi-\/byte character encodings, such as {\ttfamily UTF-\/8} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{splice}}} {\itshape lvalue}, {\itshape offset\+\_\+expression{\itshape }, \mbox{[}length\+\_\+expression, \mbox{[}substitution\+\_\+expression\mbox{]}\mbox{]}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_list_type}{list}}, \mbox{\hyperlink{data_type_declarations_string_type}{string}}, or \mbox{\hyperlink{data_type_declarations_binary_type}{binary}} (returns {\itshape lvalue} after processing)
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{splice list, 2, 2;}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{splice string, 2, 2, \textcolor{stringliteral}{"{}-\/text-\/"{}};}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{splice bin, 2, 2, <deadbeef>;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by splice}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{data_type_declarations_list_type}{list}}, \mbox{\hyperlink{data_type_declarations_string_type}{string}}, or \mbox{\hyperlink{data_type_declarations_binary_type}{binary}}) &If the {\itshape lvalue} is a list, list elements are processed, if it is a string, characters in the string are processed, and for binary data, bytes are processed. For any other data type, no action is taken.  \\\cline{1-2}
{\itshape offset\+\_\+expression}  &The start element/character/byte position for removing elements/characters/bytes from the list, string, or binary data; if this value is negative, it gives the element offset from the end of the data  \\\cline{1-2}
{\itshape length\+\_\+expression}  &The number of elements/characters/bytes to remove. If this expression is not present, then all elements/characters/bytes from the offset to the end of the list/string/binary data are removed. If this expression is present and evaluates to 0, no characters/elements/byte are removed; if this value is negative, then it gives an offset from the end of the data (ie -\/2 means remove all elements/characters/bytes up to but not including the last two)  \\\cline{1-2}
{\itshape substitution\+\_\+expression}  &For list splice, an optional element or list to substitute for the removed elements (to insert a list in a single element\textquotesingle{}s position, make sure that the list to be inserted is the first and only element of another list used as the argument in this position; in other words, pass a list within a single-\/element list). For string splice, an optional string to substitute for the removed characters. For binary splice, string or binary data to substitute for any removed bytes.  \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_extract}{}\doxysubsection{Extract Operator (extract)}\label{operators_extract}
\begin{DoxyParagraph}{Synopsis}
Removes and optionally inserts elements in lists and strings. For a similar operator that removes values from an lvalue and returns the {\itshape lvalue} (instead of the value removed), see the \mbox{\hyperlink{operators_splice}{splice operator}}.~\newline
~\newline
 Works on either strings, lists, and binary data in a similar way; removes elements from a list, characters from a string, and bytes from binary data and optionally inserts new ones. If no length\+\_\+expression is given, extract removes all elements/characters/bytes from the {\itshape lvalue} starting at {\itshape offset\+\_\+expression} (offsets begin at 0). Otherwise, a number of elements/characters/bytes equal to {\itshape length\+\_\+expression} is removed (or up to the end of the data if applicable). If {\itshape substitution\+\_\+expression} is present, then the removed elements/characters/bytes are substituted with the data given by this expression.~\newline
~\newline
 When operating on lists, a list is returned of any elements extracted (if no elements are extracted, then an empty list is returned); when operating on strings, a string is extracted of all characters extracted from the string (if no characters are extracted, then an empty string is returned). When operating on binary data, a binary object is returned.~\newline
~\newline
 Note that string extract takes character offsets, which may not be the same as byte offsets for multi-\/byte character encodings, such as {\ttfamily UTF-\/8} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\ttfamily {\bfseries{extract}}} {\itshape lvalue}, {\itshape offset\+\_\+expression{\itshape }, \mbox{[}length\+\_\+expression, \mbox{[}substitution\+\_\+expression\mbox{]}\mbox{]}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_list_type}{list}}, \mbox{\hyperlink{data_type_declarations_string_type}{string}}, or \mbox{\hyperlink{data_type_declarations_binary_type}{binary}} (the value(s) removed from {\itshape lvalue})
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{list sublist = extract list, 2, 2;}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{string substring = extract string, 2, 2, \textcolor{stringliteral}{"{}-\/text-\/"{}};}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{binary b = extract bin, 2, 2, <deadbeef>;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by extract}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{data_type_declarations_list_type}{list}}, \mbox{\hyperlink{data_type_declarations_string_type}{string}}, or \mbox{\hyperlink{data_type_declarations_binary_type}{binary}}) &If the {\itshape lvalue} is a list, list elements are processed, if it is a string, characters in the string are processed, and for binary data, bytes are processed. For any other data type, no action is taken.  \\\cline{1-2}
{\itshape offset\+\_\+expression}  &The start element/character/byte position for removing elements/characters/bytes from the list, string, or binary data; if this value is negative, it gives the element offset from the end of the data  \\\cline{1-2}
{\itshape length\+\_\+expression}  &The number of elements/characters/bytes to remove. If this expression is not present, then all elements/characters/bytes from the offset to the end of the list/string/binary data are removed. If this expression is present and evaluates to 0, no characters/elements/byte are removed; if this value is negative, then it gives an offset from the end of the data (ie -\/2 means remove all elements/characters/bytes up to but not including the last two)  \\\cline{1-2}
{\itshape substitution\+\_\+expression}  &For list extract, an optional element or list to substitute for the removed elements (to insert a list in a single element\textquotesingle{}s position, make sure that the list to be inserted is the first and only element of another list used as the argument in this position; in other words, pass a list within a single-\/element list). For string splice, an optional string to substitute for the removed characters. For binary splice, string or binary data to substitute for any removed bytes.  \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_assignment_operator}{}\doxysubsection{Assignment Operator (=)}\label{operators_assignment_operator}
\begin{DoxyParagraph}{Synopsis}
Assigns a value to an lvalue and returns the value assigned.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue} {\ttfamily =} {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a = 1;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by =}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &Assigns the value of {\itshape expression} to {\itshape lvalue}   \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_weak_assignment_operator}{}\doxysubsection{Weak Reference Assignment Operator (\+:=)}\label{operators_weak_assignment_operator}
\begin{DoxyParagraph}{Synopsis}
Identical to the \mbox{\hyperlink{operators_assignment_operator}{assignment operator}} except when the rvalue is an object; in such cases a weak reference to the object is assigned instead of a strong reference. Weak references do not extend the life of an object and also do not participate in object graph cycles (i.\+e. recursive references) and therefore can be used to break up large graphs of objects to improve garbage collector performance with such graphs, however the programmer must ensure that the object has a valid strong reference elsewhere or the object will go out of scope.~\newline
~\newline
 This operator should only be used in very special circumstances by expert users and is only allowed when the \mbox{\hyperlink{parse_directives_allow-weak-references}{\%allow-\/weak-\/references}} sandbox permission is set.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue} {\ttfamily \+:=} {\itshape \mbox{\hyperlink{expressions}{rvalue\+\_\+expression}}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_any_type}{any}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{object a := get\_object\_from\_cache();}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by \+:=}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &Assigns the value of {\itshape expression} to {\itshape lvalue} and returns the value assigned; if {\itshape \mbox{\hyperlink{expressions}{rvalue\+\_\+expression}}} is an object, a weak reference is assigned instead of a strong reference  \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_plus_equals_operator}{}\doxysubsection{Plus Equals Operator (+=)}\label{operators_plus_equals_operator}
\begin{DoxyParagraph}{Synopsis}
Increments and concatenates an lvalue with the value of an expression depending on the data type of the {\itshape lvalue}, unless the {\itshape lvalue} is \mbox{\hyperlink{basic_data_types_nothing}{NOTHING}}, in which case this operator acts like the assignment operator (simply assigns the value of the right hand side to the {\itshape lvalue}).
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue} {\ttfamily +=} {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}, \mbox{\hyperlink{data_type_declarations_float_type}{float}}, \mbox{\hyperlink{data_type_declarations_number_type}{number}}, \mbox{\hyperlink{data_type_declarations_date_type}{date}}, \mbox{\hyperlink{data_type_declarations_list_type}{list}}, \mbox{\hyperlink{data_type_declarations_string_type}{string}}, \mbox{\hyperlink{data_type_declarations_binary_type}{binary}}, \mbox{\hyperlink{data_type_declarations_hash_type}{hash}}, or \mbox{\hyperlink{data_type_declarations_object_type}{object}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a += 10;}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{date += P1M2DT45M;}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{list += new\_element;}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{string += \textcolor{stringliteral}{"{}.foo"{}};}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{binary += <0c67a374>}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{hash += (\textcolor{stringliteral}{"{}new-\/key"{}} : 1, \textcolor{stringliteral}{"{}other"{}} : \textcolor{stringliteral}{"{}two"{}});}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{object += hash;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by +=}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{data_type_declarations_list_type}{list}}) &the expression will be evaluated and concatenated to the {\itshape lvalue}. If {\itshape expression} is a list, the lists will be concatenated, to ensure adding a single element to a list, use the \mbox{\hyperlink{operators_push}{push operator}}  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{data_type_declarations_hash_type}{hash}} or (\mbox{\hyperlink{data_type_declarations_object_type}{object}}) &the {\itshape expression} will be evaluated, and, if it is a hash or object, then it\textquotesingle{}s members will be added to the {\itshape lvalue}, any duplicate elements in the {\itshape lvalue} will be overridden by elements in the {\itshape expression}.  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{data_type_declarations_string_type}{string}}) &the {\itshape expression} will be evaluated and converted to a string if necessary and concatenated to the {\itshape lvalue}.  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{data_type_declarations_number_type}{number}}) &the {\itshape expression} will be evaluated and converted to a number if necessary and added to the {\itshape lvalue}.  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{data_type_declarations_float_type}{float}}) &the {\itshape expression} will be evaluated and converted to a float if necessary and added to the {\itshape lvalue}.  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{data_type_declarations_binary_type}{binary}}) &the {\itshape expression} will be evaluated and converted to a binary if necessary and added to the {\itshape lvalue}.  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{data_type_declarations_date_type}{date}}) &the {\itshape expression} will be evaluated and converted to a date if necessary and added to the {\itshape lvalue}.  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{basic_data_types_nothing}{NOTHING}}) &the {\itshape lvalue} will be assigned to the value of {\itshape expression}.  \\\cline{1-2}
{\itshape lvalue} (all other types) &the {\itshape lvalue\textquotesingle{}s} type will be converted to an integer, and the {\itshape expression} will be evaluated and converted to an integer if necessary, and then the result will be added to the {\itshape lvalue}.  \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_minus_equals_operator}{}\doxysubsection{Minus Equals Operator (-\/=)}\label{operators_minus_equals_operator}
\begin{DoxyParagraph}{Synopsis}
For a float or integer argument, decrements the value of an {\itshape lvalue} by the value of an {\itshape expression}. However if the {\itshape lvalue} is a hash or object and the {\itshape expression} is a string, removes the key represented by the string from the hash or object.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue} {\ttfamily -\/=} {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}, \mbox{\hyperlink{data_type_declarations_float_type}{float}}, \mbox{\hyperlink{data_type_declarations_number_type}{number}}, \mbox{\hyperlink{data_type_declarations_date_type}{date}}, \mbox{\hyperlink{data_type_declarations_hash_type}{hash}}, or \mbox{\hyperlink{data_type_declarations_object_type}{object}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a -\/= 10;}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{date -\/= PT45H213S;}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{hash -\/= \textcolor{stringliteral}{"{}key"{}};}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{hash -\/= (\textcolor{stringliteral}{"{}key1"{}}, \textcolor{stringliteral}{"{}key2"{}});}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{object -\/= \textcolor{stringliteral}{"{}key"{}};}

\end{DoxyCode}
 
\begin{DoxyCode}{0}
\DoxyCodeLine{object -\/= list\_of\_keys;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by -\/=}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{data_type_declarations_number_type}{number}}) &the {\itshape expression} will be evaluated and converted to a number if necessary and subtracted from the {\itshape lvalue}   \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{data_type_declarations_float_type}{float}}) &the {\itshape expression} will be evaluated and converted to a float if necessary and subtracted from the {\itshape lvalue}   \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{data_type_declarations_date_type}{date}}) &the {\itshape expression} will be evaluated and converted to a date if necessary and subtracted from the {\itshape lvalue}   \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{data_type_declarations_hash_type}{hash}} or (\mbox{\hyperlink{data_type_declarations_object_type}{object}}), {\itshape expression} (\mbox{\hyperlink{data_type_declarations_string_type}{string}}) &the hash key represented by {\itshape expression} will be removed from the {\itshape lvalue}   \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{data_type_declarations_hash_type}{hash}} or (\mbox{\hyperlink{data_type_declarations_object_type}{object}}), {\itshape expression} (\mbox{\hyperlink{data_type_declarations_list_type}{list}}) &each element in the list will be converted to a string (if necessary) and the key represented by each string will be removed from the hash or object  \\\cline{1-2}
{\itshape lvalue} (\mbox{\hyperlink{basic_data_types_nothing}{NOTHING}}), {\itshape expression} (any type) &the {\itshape expression} will be assigned to {\itshape lvalue}   \\\cline{1-2}
{\itshape lvalue} (all other types) &the {\itshape lvalue\textquotesingle{}s} type will be converted to an integer (if necessary), and the {\itshape expression} will be evaluated and converted to an integer (if necessary), and then the result will be subtracted from the {\itshape lvalue}   \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_and_equals_operator}{}\doxysubsection{And Equals Operator (\&=)}\label{operators_and_equals_operator}
\begin{DoxyParagraph}{Synopsis}
Performs a bitwise (binary) AND operation on an {\itshape lvalue} using the value of an {\itshape expression} and returns the new value.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue} {\ttfamily \&=} {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a \&= 0xfe;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by \&=}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &the {\itshape lvalue\textquotesingle{}s} type will be converted to an integer if necessary, and the {\itshape expression} will be evaluated and converted to an integer as well if necessary, and then the result will be binary and\textquotesingle{}ed to the {\itshape lvalue}   \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_or_equals_operator}{}\doxysubsection{Or Equals Operator ($\vert$=)}\label{operators_or_equals_operator}
\begin{DoxyParagraph}{Synopsis}
Performs a bitwise (binary) OR operation on an {\itshape lvalue} using the value of an {\itshape expression} and returns the new value.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue} {\ttfamily $\vert$=} {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a |= 0xba;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $\vert$=}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &the {\itshape lvalue\textquotesingle{}s} type will be converted to an integer if necessary, and the {\itshape expression} will be evaluated and converted to an integer as well if necessary, and then the result will be binary or\textquotesingle{}ed to the {\itshape lvalue}   \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_modulo_equals_operator}{}\doxysubsection{Modulo Equals Operator (\%=)}\label{operators_modulo_equals_operator}
\begin{DoxyParagraph}{Synopsis}
Performs a modulo calculation on an lvalue using the value of an expression and returns the new value.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue} {\ttfamily \%=} {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a \%= 100;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by \%=}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &the {\itshape lvalue\textquotesingle{}s} type will be converted to an integer if necessary, and the {\itshape expression} will be evaluated and converted to an integer as well if necessary, and then the result will be used to divide the {\itshape lvalue\textquotesingle{}s} value and the remainder will be saved to the {\itshape lvalue}   \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_multiply_equals_operator}{}\doxysubsection{Multiply Equals Operator ($\ast$=)}\label{operators_multiply_equals_operator}
\begin{DoxyParagraph}{Synopsis}
Performs a multiplication operation on an lvalue using the value of an expression and returns the value assigned.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue} {\ttfamily $\ast$=} {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}, \mbox{\hyperlink{data_type_declarations_float_type}{float}}, or \mbox{\hyperlink{data_type_declarations_number_type}{number}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a *= 10;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $\ast$=}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &The type precedence from highest to lowest is \mbox{\hyperlink{basic_data_types_number}{number}}, \mbox{\hyperlink{basic_data_types_float}{float}} float, and \mbox{\hyperlink{basic_data_types_integer}{int}}, other types are converted to \mbox{\hyperlink{basic_data_types_integer}{int}}. The {\itshape expression} will be evaluated and multiplied by the {\itshape lvalue}, and the result will be saved to the {\itshape lvalue}.  \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_divide_equals_operator}{}\doxysubsection{Divide Equals Operator (/=)}\label{operators_divide_equals_operator}
\begin{DoxyParagraph}{Synopsis}
Performs a division operation on an lvalue using the value of an expression and returns the value assigned.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue} {\ttfamily /=} {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}, \mbox{\hyperlink{data_type_declarations_float_type}{float}}, or \mbox{\hyperlink{data_type_declarations_number_type}{number}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a /= 10;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by /=}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &The type precedence from highest to lowest is \mbox{\hyperlink{basic_data_types_number}{number}}, \mbox{\hyperlink{basic_data_types_float}{float}} float, and \mbox{\hyperlink{basic_data_types_integer}{int}}, other types are converted to \mbox{\hyperlink{basic_data_types_integer}{int}}; The {\itshape expression} will be evaluated and multiplied by the {\itshape lvalue}, and the result will be saved to the {\itshape lvalue}. The {\itshape expression} will be evaluated and used to divide the {\itshape lvalue}, and the result will be saved to the {\itshape lvalue}.  \\\cline{1-2}
\end{longtabu}



\begin{DoxyExceptions}{Exceptions}
{\em DIVISION-\/\+BY-\/\+ZERO} & If the divisor expression evaluates to zero, this exception is thrown\\
\hline
\end{DoxyExceptions}
\DoxyHorRuler{0}
 \hypertarget{operators_xor_equals_operator}{}\doxysubsection{Xor Equals Operator ($^\wedge$=)}\label{operators_xor_equals_operator}
\begin{DoxyParagraph}{Synopsis}
Performs an exclusive-\/or operation on an lvalue using the value of an expression.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue} {\ttfamily $^\wedge$=} {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a \string^= 0xf9034ba7;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $^\wedge$=}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &Values are converted to integers if necessary. The {\itshape expression} will be evaluated and exclusive-\/or\textquotesingle{}ed with the {\itshape lvalue}, and the result will be saved to the {\itshape lvalue}   \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_shift_left_equals_operator}{}\doxysubsection{Shift Left Equals Operator ($<$$<$=)}\label{operators_shift_left_equals_operator}
\begin{DoxyParagraph}{Synopsis}
Performs a shift-\/left operation on an lvalue using the value of an expression and returns the value assigned.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue} {\ttfamily $<$$<$=} {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a <<= 3;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $<$$<$=}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &Values are converted to integers if necessary. The {\itshape expression} will be evaluated and this value will determine how many bits the {\itshape lvalue} will be shifted left. The result will be saved to the {\itshape lvalue}.  \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_shift_right_equals_operator}{}\doxysubsection{Shift Right Equals Operator ($>$$>$=)}\label{operators_shift_right_equals_operator}
\begin{DoxyParagraph}{Synopsis}
Performs a shift-\/right operation on an lvalue using the value of an expression and returns the value assigned.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape lvalue} {\ttfamily $>$$>$=} {\itshape expression} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_int_type}{int}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{a >>= 3;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by $>$$>$=}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
All &Values are converted to integers if necessary. The {\itshape expression} will be evaluated and this value will determine how many bits the {\itshape lvalue} will be shifted right. The result will be saved to the {\itshape lvalue}.  \\\cline{1-2}
\end{longtabu}


\DoxyHorRuler{0}
 \hypertarget{operators_range_operator}{}\doxysubsection{Range Operator (..)}\label{operators_range_operator}
\begin{DoxyParagraph}{Synopsis}
Returns a list of integers between two expressions.
\end{DoxyParagraph}
\begin{DoxyParagraph}{Syntax}
{\itshape expression1} .. {\itshape expression2} 
\end{DoxyParagraph}
\begin{DoxyParagraph}{Return Type}
\mbox{\hyperlink{data_type_declarations_list_type}{list}}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example}

\begin{DoxyCode}{0}
\DoxyCodeLine{list = 3..7;}
\DoxyCodeLine{list = 7..3;}

\end{DoxyCode}

\end{DoxyParagraph}
{\bfseries{Arguments Processed by ..}}  \tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
{\bfseries{Argument}} &{\bfseries{Processing}}  \\\cline{1-2}
\mbox{\hyperlink{data_type_declarations_int_type}{int}} &Arguments are converted to integers if necessary.  \\\cline{1-2}
\end{longtabu}


\begin{DoxySince}{Since}
Qore 0.\+8.\+13
\end{DoxySince}
\begin{DoxyNote}{Note}

\begin{DoxyItemize}
\item the {\bfseries{{\ttfamily range}}} operator supports \mbox{\hyperlink{operators_op_functional}{lazy functional evaluation}} of itself
\item this operator cannot be used on the left-\/hand side of an assignment expression 
\end{DoxyItemize}
\end{DoxyNote}
