uCalc API Version: 2.1.3-preview.2 Released: 6/17/2026

Warning

uCalc API Preview Release Notice:The documentation describes the intended behavior of the API. The current preview build contains incomplete features, unoptimized performance, and is subject to breaking changes.

Items = [ItemsAccessor]

Property

Product:

Fast Math Parser

Class:

uCalcBase

Provides access to the collection of all defined symbols (items) for runtime introspection and dynamic analysis.

Remarks

🧐 Introspection: The Items Property

The Items property is uCalc's primary gateway for runtime introspection. It provides access to the complete collection of all symbols—known as Items—that have been defined within a uCalc instance.

An "Item" is the fundamental, universal object for any symbol in uCalc, including:

Variables created with DefineVariable()
Functions created with DefineFunction()
Operators created with DefineOperator()
Data Types, Aliases, and more.

This property returns an ItemsAccessor object, which is a powerful, iterable, and queryable collection, essential for debugging, creating dynamic user interfaces, or building tools that analyze the state of the uCalc engine.

⚙️ Accessing and Filtering Items

The ItemsAccessor supports direct iteration and indexed filtering, providing a flexible way to query the engine's symbol table.

1. Iterating All Items

You can use a foreach loop to iterate over every symbol defined in the instance.

// Loop through every defined item and print its nameforeach(var item in uc.Items) {   Console.WriteLine(item.Name);}

2. Filtering by Property or Name

The collection can be filtered using an indexer [] with a property from the ItemIs enum or a string name. The result of a filter is another iterable collection.

// Get a list containing only defined functionsvar functionList = uc.Items[ItemIs.Function];foreach(var func in functionList) {    Console.WriteLine(func.Name);}// Get all overloads of the '+' operatorvar plusOverloads = uc.Items["+"];foreach(var op in plusOverloads) {    Console.WriteLine(op.Text);}

3. Advanced Filtering with `Properties()`

For more complex queries, you can combine multiple ItemIs flags using the static Properties() method. This allows you to find items that match all (ItemIs::SelectAll) or any (ItemIs::SelectAny) of a set of properties.

// Find all items that are BOTH an Operator AND Infixvar infixOperators = uc.Items[    uCalc.Properties(ItemIs.SelectAll, ItemIs.Operator, ItemIs.Infix)];

💡 Why uCalc? (Comparative Analysis)

Items provides functionality similar to reflection or introspection in other programming environments, but it is tailored specifically for the uCalc engine.

vs. .NET/Java Reflection: Reflection is a powerful, general-purpose system for inspecting assemblies and types at runtime. However, it can be complex and verbose. The @Items property provides a much simpler, higher-level API focused exclusively on the symbols within the uCalc engine, making it easier and more efficient for its intended purpose.
vs. Python's dir() or globals(): In dynamic languages, introspection is a core feature. @Items is conceptually similar to these tools but provides a more structured, property-based filtering mechanism out of the box, whereas in Python you might need to combine dir() with isinstance() checks in a loop.

Examples

Succinct: Lists the names of all user-defined and built-in functions.

				
					using uCalcSoftware;

var uc = new uCalc();
// Note: Some items in this list (like bool, or int*) appear more than once or out of chronological
// order because they are aliases (like bool, which is also an alias for boolean)
Console.WriteLine("Defined Functions:");
foreach(var item in uc.GetItems(ItemIs.Function)) {
   Console.WriteLine($" - {item.Name}");
}

Defined Functions:
 - abs
 - acos
 - acosh
 - addptr
 - addressof
 - anytype
 - append
 - append_copy
 - arg
 - argcount
 - asc
 - asin
 - asinh
 - atan
 - atan2
 - atanh
 - back
 - baseconvert
 - bin
 - bool
 - bool
 - int8u
 - c_str
 - cbrt
 - ceil
 - chr
 - clear
 - compare
 - complex
 - conj
 - contains
 - copysign
 - cos
 - cosh
 - define
 - doloop
 - double
 - endswith
 - erase
 - erase_copy
 - erf
 - erfc
 - error
 - eval
 - evalstr
 - evaluate
 - evaluateint
 - evaluatestr
 - exp
 - exp2
 - expm1
 - exprptr
 - fabs
 - fdim
 - file
 - filesize
 - fill
 - find_first_not_of
 - find_first_of
 - find_last_not_of
 - find_last_of
 - single
 - floor
 - fmax
 - fmin
 - fmod
 - forloop
 - format
 - fpclassify
 - frac
 - frexp
 - fromto
 - goto
 - hex
 - hypot
 - iif
 - ilogb
 - imag
 - indexof
 - inf
 - insert
 - insert_copy
 - int
 - int16
 - int16u
 - int
 - int32u
 - int64
 - int64u
 - int8
 - int8u
 - int
 - isfinite
 - isinf
 - isnan
 - isnormal
 - lastindexof
 - lcase
 - ldexp
 - length
 - lgamma
 - llrint
 - llround
 - log
 - log10
 - log1p
 - log2
 - logb
 - lrint
 - lround
 - ltrim
 - max
 - min
 - modf
 - nan
 - nearbyint
 - nextafter
 - nexttoward
 - norm
 - oct
 - omnitype
 - padleft
 - padright
 - parse
 - pointer
 - polar
 - pop
 - pow
 - precedence
 - proj
 - push
 - rand
 - randfromsameseed
 - randomnumber
 - randomseed
 - real
 - remainder
 - remquo
 - repeat
 - replace
 - replace_copy
 - reset
 - rint
 - round
 - rtrim
 - sametypeas
 - scalbln
 - scalbn
 - setvar
 - sgn
 - signbit
 - sin
 - single
 - sinh
 - size_t
 - sizeof
 - sort
 - sqr
 - sqrt
 - startswith
 - str
 - string
 - substr
 - subtractptr
 - swap
 - tan
 - tanh
 - tgamma
 - trim
 - trunc
 - ucalcinstance
 - ucase
 - valueat
 - valueattype
 - void

using uCalcSoftware;&#13;&#13;var uc = new uCalc();&#13;// Note: Some items in this list (like bool, or int*) appear more than once or out of chronological&#13;// order because they are aliases (like bool, which is also an alias for boolean)&#13;Console.WriteLine("Defined Functions:");&#13;foreach(var item in uc.GetItems(ItemIs.Function)) {&#13;   Console.WriteLine($" - {item.Name}");&#13;}

				
					#include <iostream>
#include "uCalc.h"

using namespace std;
using namespace uCalcSoftware;

int main() {
   uCalc uc;
   // Note: Some items in this list (like bool, or int*) appear more than once or out of chronological
   // order because they are aliases (like bool, which is also an alias for boolean)
   cout << "Defined Functions:" << endl;
   for(auto item : uc.GetItems(ItemIs::Function)) {
      cout << " - " << item.Name() << endl;
   }
}

Defined Functions:
 - abs
 - acos
 - acosh
 - addptr
 - addressof
 - anytype
 - append
 - append_copy
 - arg
 - argcount
 - asc
 - asin
 - asinh
 - atan
 - atan2
 - atanh
 - back
 - baseconvert
 - bin
 - bool
 - bool
 - int8u
 - c_str
 - cbrt
 - ceil
 - chr
 - clear
 - compare
 - complex
 - conj
 - contains
 - copysign
 - cos
 - cosh
 - define
 - doloop
 - double
 - endswith
 - erase
 - erase_copy
 - erf
 - erfc
 - error
 - eval
 - evalstr
 - evaluate
 - evaluateint
 - evaluatestr
 - exp
 - exp2
 - expm1
 - exprptr
 - fabs
 - fdim
 - file
 - filesize
 - fill
 - find_first_not_of
 - find_first_of
 - find_last_not_of
 - find_last_of
 - single
 - floor
 - fmax
 - fmin
 - fmod
 - forloop
 - format
 - fpclassify
 - frac
 - frexp
 - fromto
 - goto
 - hex
 - hypot
 - iif
 - ilogb
 - imag
 - indexof
 - inf
 - insert
 - insert_copy
 - int
 - int16
 - int16u
 - int
 - int32u
 - int64
 - int64u
 - int8
 - int8u
 - int
 - isfinite
 - isinf
 - isnan
 - isnormal
 - lastindexof
 - lcase
 - ldexp
 - length
 - lgamma
 - llrint
 - llround
 - log
 - log10
 - log1p
 - log2
 - logb
 - lrint
 - lround
 - ltrim
 - max
 - min
 - modf
 - nan
 - nearbyint
 - nextafter
 - nexttoward
 - norm
 - oct
 - omnitype
 - padleft
 - padright
 - parse
 - pointer
 - polar
 - pop
 - pow
 - precedence
 - proj
 - push
 - rand
 - randfromsameseed
 - randomnumber
 - randomseed
 - real
 - remainder
 - remquo
 - repeat
 - replace
 - replace_copy
 - reset
 - rint
 - round
 - rtrim
 - sametypeas
 - scalbln
 - scalbn
 - setvar
 - sgn
 - signbit
 - sin
 - single
 - sinh
 - size_t
 - sizeof
 - sort
 - sqr
 - sqrt
 - startswith
 - str
 - string
 - substr
 - subtractptr
 - swap
 - tan
 - tanh
 - tgamma
 - trim
 - trunc
 - ucalcinstance
 - ucase
 - valueat
 - valueattype
 - void

#include <iostream>&#13;#include "uCalc.h"&#13;&#13;using namespace std;&#13;using namespace uCalcSoftware;&#13;&#13;int main() {&#13;   uCalc uc;&#13;   // Note: Some items in this list (like bool, or int*) appear more than once or out of chronological&#13;   // order because they are aliases (like bool, which is also an alias for boolean)&#13;   cout << "Defined Functions:" << endl;&#13;   for(auto item : uc.GetItems(ItemIs::Function)) {&#13;      cout << " - " << item.Name() << endl;&#13;   }&#13;}

				
					Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Note: Some items in this list (like bool, or int*) appear more than once or out of chronological
      '// order because they are aliases (like bool, which is also an alias for boolean)
      Console.WriteLine("Defined Functions:")
      For Each item In uc.GetItems(ItemIs.Function)
   Console.WriteLine($" - {item.Name}")
         Next
      End Sub
   End Module

Defined Functions:
 - abs
 - acos
 - acosh
 - addptr
 - addressof
 - anytype
 - append
 - append_copy
 - arg
 - argcount
 - asc
 - asin
 - asinh
 - atan
 - atan2
 - atanh
 - back
 - baseconvert
 - bin
 - bool
 - bool
 - int8u
 - c_str
 - cbrt
 - ceil
 - chr
 - clear
 - compare
 - complex
 - conj
 - contains
 - copysign
 - cos
 - cosh
 - define
 - doloop
 - double
 - endswith
 - erase
 - erase_copy
 - erf
 - erfc
 - error
 - eval
 - evalstr
 - evaluate
 - evaluateint
 - evaluatestr
 - exp
 - exp2
 - expm1
 - exprptr
 - fabs
 - fdim
 - file
 - filesize
 - fill
 - find_first_not_of
 - find_first_of
 - find_last_not_of
 - find_last_of
 - single
 - floor
 - fmax
 - fmin
 - fmod
 - forloop
 - format
 - fpclassify
 - frac
 - frexp
 - fromto
 - goto
 - hex
 - hypot
 - iif
 - ilogb
 - imag
 - indexof
 - inf
 - insert
 - insert_copy
 - int
 - int16
 - int16u
 - int
 - int32u
 - int64
 - int64u
 - int8
 - int8u
 - int
 - isfinite
 - isinf
 - isnan
 - isnormal
 - lastindexof
 - lcase
 - ldexp
 - length
 - lgamma
 - llrint
 - llround
 - log
 - log10
 - log1p
 - log2
 - logb
 - lrint
 - lround
 - ltrim
 - max
 - min
 - modf
 - nan
 - nearbyint
 - nextafter
 - nexttoward
 - norm
 - oct
 - omnitype
 - padleft
 - padright
 - parse
 - pointer
 - polar
 - pop
 - pow
 - precedence
 - proj
 - push
 - rand
 - randfromsameseed
 - randomnumber
 - randomseed
 - real
 - remainder
 - remquo
 - repeat
 - replace
 - replace_copy
 - reset
 - rint
 - round
 - rtrim
 - sametypeas
 - scalbln
 - scalbn
 - setvar
 - sgn
 - signbit
 - sin
 - single
 - sinh
 - size_t
 - sizeof
 - sort
 - sqr
 - sqrt
 - startswith
 - str
 - string
 - substr
 - subtractptr
 - swap
 - tan
 - tanh
 - tgamma
 - trim
 - trunc
 - ucalcinstance
 - ucase
 - valueat
 - valueattype
 - void

Imports System&#13;Imports uCalcSoftware&#13;Public Module Program&#13;   Public Sub Main()&#13;      Dim uc As New uCalc()&#13;      '// Note: Some items in this list (like bool, or int*) appear more than once or out of chronological&#13;      '// order because they are aliases (like bool, which is also an alias for boolean)&#13;      Console.WriteLine("Defined Functions:")&#13;      For Each item In uc.GetItems(ItemIs.Function)&#13;   Console.WriteLine($" - {item.Name}")&#13;         Next&#13;      End Sub&#13;   End Module

uCalc.Items

				
					using uCalcSoftware;

var uc = new uCalc();
// Note: Some items in this list (like bool, or int*) appear more than once or out of chronological
// order because they are aliases (like bool, which is also an alias for boolean)
foreach(var item in uc.Items) {
   Console.WriteLine(item.Name);
}

!
%
&
&&
*
+
,
-
/
<
<<
<=
<>
=
==
>
>=
>>
\
^
_enduserformattedoutput
_newline
_token_alphanumeric
_token_argseparator
_token_binaryhexoctalnotation
_token_catchall
_token_catchall_utf8_other
_token_curlybrace
_token_curlybrace_close
_token_floatnumber
_token_imaginaryunit
_token_line
_token_memberaccess
_token_newline
_token_parenthesis
_token_parenthesis_close
_token_punctuation
_token_quotechar
_token_quotechar_double
_token_quotechar_single
_token_quotechar_tripledouble
_token_reducible
_token_reducible2
_token_semicolon
_token_squarebracket
_token_squarebracket_close
_token_string_doublequoted
_token_string_singlequoted
_token_string_tripledoublequoted
_token_stringinterpolationquote
_token_variableargs
_token_whitespace
_ucalc_lib_is32
_ucalc_lib_is64
_ucalc_lib_release_timestamp
_ucalc_lib_version
abs
acos
acosh
addptr
addressof
and
andalso
anytype
append
append_copy
arg
argcount
asc
asin
asinh
atan
atan2
atanh
back
baseconvert
bin
bitand
bitor
bool
bool
int8u
c_str
cbrt
ceil
chr
clear
compare
complex
conj
contains
copysign
cos
cosh
define
doloop
double
endswith
erase
erase_copy
erf
erfc
error
eval
evalstr
evaluate
evaluateint
evaluatestr
exp
exp2
expm1
exprptr
fabs
false
fdim
file
filesize
fill
find_first_not_of
find_first_of
find_last_not_of
find_last_of
single
floor
fmax
fmin
fmod
forloop
format
fpclassify
frac
frexp
fromto
goto
hex
hypot
iif
ilogb
imag
indexof
inf
insert
insert_copy
int
int16
int16u
int
int32u
int64
int64u
int8
int8u
int
isfinite
isinf
isnan
isnormal
lastindexof
lastrandomnumber
lcase
ldexp
length
lgamma
llrint
llround
log
log10
log1p
log2
logb
lrint
lround
ltrim
max
min
mod
modf
nan
nearbyint
nextafter
nexttoward
norm
not
oct
omnitype
or
orelse
padleft
padright
parse
pointer
polar
pop
pow
precedence
proj
push
rand
randfromsameseed
randomnumber
randomseed
real
remainder
remquo
repeat
replace
replace_copy
reset
rint
round
rtrim
sametypeas
scalbln
scalbn
setvar
sgn
signbit
sin
single
sinh
size_t
sizeof
sort
sqr
sqrt
startswith
str
string
substr
subtractptr
swap
tan
tanh
tgamma
trim
true
trunc
ucalcinstance
ucase
valueat
valueattype
void
xor
|
||
~

using uCalcSoftware;&#13;&#13;var uc = new uCalc();&#13;// Note: Some items in this list (like bool, or int*) appear more than once or out of chronological&#13;// order because they are aliases (like bool, which is also an alias for boolean)&#13;foreach(var item in uc.Items) {&#13;   Console.WriteLine(item.Name);&#13;}

				
					#include <iostream>
#include "uCalc.h"

using namespace std;
using namespace uCalcSoftware;

int main() {
   uCalc uc;
   // Note: Some items in this list (like bool, or int*) appear more than once or out of chronological
   // order because they are aliases (like bool, which is also an alias for boolean)
   for(auto item : uc.Items()) {
      cout << item.Name() << endl;
   }
}

!
%
&
&&
*
+
,
-
/
<
<<
<=
<>
=
==
>
>=
>>
\
^
_enduserformattedoutput
_newline
_token_alphanumeric
_token_argseparator
_token_binaryhexoctalnotation
_token_catchall
_token_catchall_utf8_other
_token_curlybrace
_token_curlybrace_close
_token_floatnumber
_token_imaginaryunit
_token_line
_token_memberaccess
_token_newline
_token_parenthesis
_token_parenthesis_close
_token_punctuation
_token_quotechar
_token_quotechar_double
_token_quotechar_single
_token_quotechar_tripledouble
_token_reducible
_token_reducible2
_token_semicolon
_token_squarebracket
_token_squarebracket_close
_token_string_doublequoted
_token_string_singlequoted
_token_string_tripledoublequoted
_token_stringinterpolationquote
_token_variableargs
_token_whitespace
_ucalc_lib_is32
_ucalc_lib_is64
_ucalc_lib_release_timestamp
_ucalc_lib_version
abs
acos
acosh
addptr
addressof
and
andalso
anytype
append
append_copy
arg
argcount
asc
asin
asinh
atan
atan2
atanh
back
baseconvert
bin
bitand
bitor
bool
bool
int8u
c_str
cbrt
ceil
chr
clear
compare
complex
conj
contains
copysign
cos
cosh
define
doloop
double
endswith
erase
erase_copy
erf
erfc
error
eval
evalstr
evaluate
evaluateint
evaluatestr
exp
exp2
expm1
exprptr
fabs
false
fdim
file
filesize
fill
find_first_not_of
find_first_of
find_last_not_of
find_last_of
single
floor
fmax
fmin
fmod
forloop
format
fpclassify
frac
frexp
fromto
goto
hex
hypot
iif
ilogb
imag
indexof
inf
insert
insert_copy
int
int16
int16u
int
int32u
int64
int64u
int8
int8u
int
isfinite
isinf
isnan
isnormal
lastindexof
lastrandomnumber
lcase
ldexp
length
lgamma
llrint
llround
log
log10
log1p
log2
logb
lrint
lround
ltrim
max
min
mod
modf
nan
nearbyint
nextafter
nexttoward
norm
not
oct
omnitype
or
orelse
padleft
padright
parse
pointer
polar
pop
pow
precedence
proj
push
rand
randfromsameseed
randomnumber
randomseed
real
remainder
remquo
repeat
replace
replace_copy
reset
rint
round
rtrim
sametypeas
scalbln
scalbn
setvar
sgn
signbit
sin
single
sinh
size_t
sizeof
sort
sqr
sqrt
startswith
str
string
substr
subtractptr
swap
tan
tanh
tgamma
trim
true
trunc
ucalcinstance
ucase
valueat
valueattype
void
xor
|
||
~

#include <iostream>&#13;#include "uCalc.h"&#13;&#13;using namespace std;&#13;using namespace uCalcSoftware;&#13;&#13;int main() {&#13;   uCalc uc;&#13;   // Note: Some items in this list (like bool, or int*) appear more than once or out of chronological&#13;   // order because they are aliases (like bool, which is also an alias for boolean)&#13;   for(auto item : uc.Items()) {&#13;      cout << item.Name() << endl;&#13;   }&#13;}

				
					Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Note: Some items in this list (like bool, or int*) appear more than once or out of chronological
      '// order because they are aliases (like bool, which is also an alias for boolean)
      For Each item In uc.Items
         Console.WriteLine(item.Name)
      Next
   End Sub
End Module

!
%
&
&&
*
+
,
-
/
<
<<
<=
<>
=
==
>
>=
>>
\
^
_enduserformattedoutput
_newline
_token_alphanumeric
_token_argseparator
_token_binaryhexoctalnotation
_token_catchall
_token_catchall_utf8_other
_token_curlybrace
_token_curlybrace_close
_token_floatnumber
_token_imaginaryunit
_token_line
_token_memberaccess
_token_newline
_token_parenthesis
_token_parenthesis_close
_token_punctuation
_token_quotechar
_token_quotechar_double
_token_quotechar_single
_token_quotechar_tripledouble
_token_reducible
_token_reducible2
_token_semicolon
_token_squarebracket
_token_squarebracket_close
_token_string_doublequoted
_token_string_singlequoted
_token_string_tripledoublequoted
_token_stringinterpolationquote
_token_variableargs
_token_whitespace
_ucalc_lib_is32
_ucalc_lib_is64
_ucalc_lib_release_timestamp
_ucalc_lib_version
abs
acos
acosh
addptr
addressof
and
andalso
anytype
append
append_copy
arg
argcount
asc
asin
asinh
atan
atan2
atanh
back
baseconvert
bin
bitand
bitor
bool
bool
int8u
c_str
cbrt
ceil
chr
clear
compare
complex
conj
contains
copysign
cos
cosh
define
doloop
double
endswith
erase
erase_copy
erf
erfc
error
eval
evalstr
evaluate
evaluateint
evaluatestr
exp
exp2
expm1
exprptr
fabs
false
fdim
file
filesize
fill
find_first_not_of
find_first_of
find_last_not_of
find_last_of
single
floor
fmax
fmin
fmod
forloop
format
fpclassify
frac
frexp
fromto
goto
hex
hypot
iif
ilogb
imag
indexof
inf
insert
insert_copy
int
int16
int16u
int
int32u
int64
int64u
int8
int8u
int
isfinite
isinf
isnan
isnormal
lastindexof
lastrandomnumber
lcase
ldexp
length
lgamma
llrint
llround
log
log10
log1p
log2
logb
lrint
lround
ltrim
max
min
mod
modf
nan
nearbyint
nextafter
nexttoward
norm
not
oct
omnitype
or
orelse
padleft
padright
parse
pointer
polar
pop
pow
precedence
proj
push
rand
randfromsameseed
randomnumber
randomseed
real
remainder
remquo
repeat
replace
replace_copy
reset
rint
round
rtrim
sametypeas
scalbln
scalbn
setvar
sgn
signbit
sin
single
sinh
size_t
sizeof
sort
sqr
sqrt
startswith
str
string
substr
subtractptr
swap
tan
tanh
tgamma
trim
true
trunc
ucalcinstance
ucase
valueat
valueattype
void
xor
|
||
~

Imports System&#13;Imports uCalcSoftware&#13;Public Module Program&#13;   Public Sub Main()&#13;      Dim uc As New uCalc()&#13;      '// Note: Some items in this list (like bool, or int*) appear more than once or out of chronological&#13;      '// order because they are aliases (like bool, which is also an alias for boolean)&#13;      For Each item In uc.Items&#13;         Console.WriteLine(item.Name)&#13;      Next&#13;   End Sub&#13;End Module

ListOfItem with name / property

				
					using uCalcSoftware;

var uc = new uCalc();
Console.WriteLine("Items with the Prefix property");
Console.WriteLine("------------------------------");
foreach(var item in uc.GetItems(ItemIs.Prefix)) {
   Console.WriteLine(item.Name);
}

Console.WriteLine("");
Console.WriteLine("Different versions of the + operator");
Console.WriteLine("------------------------------------");
foreach(var item in uc.GetItems("+")) {
   Console.WriteLine(item.Text);
}

Items with the Prefix property
------------------------------
!
+
-
not
~

Different versions of the + operator
------------------------------------
Operator: 70 +{x}
Operator: 50 {x} + {y}
Operator: 50 {x As Int} + {y As Int} As Int
Operator: 50 {x As String} + {y As String} As String
Operator: 50 {x As Complex} + {y As Complex} As Complex
Operator: 50 {ByHandle x As AnyType Ptr} + {y As Int} As SameTypeAs:0 Ptr
Operator: 50 {ByHandle x As AnyType} + {ByHandle y As String} As String
Operator: 50 {ByHandle x As String} + {ByHandle y As AnyType} As String

using uCalcSoftware;&#13;&#13;var uc = new uCalc();&#13;Console.WriteLine("Items with the Prefix property");&#13;Console.WriteLine("------------------------------");&#13;foreach(var item in uc.GetItems(ItemIs.Prefix)) {&#13;   Console.WriteLine(item.Name);&#13;}&#13;&#13;Console.WriteLine("");&#13;Console.WriteLine("Different versions of the + operator");&#13;Console.WriteLine("------------------------------------");&#13;foreach(var item in uc.GetItems("+")) {&#13;   Console.WriteLine(item.Text);&#13;}

				
					#include <iostream>
#include "uCalc.h"

using namespace std;
using namespace uCalcSoftware;

int main() {
   uCalc uc;
   cout << "Items with the Prefix property" << endl;
   cout << "------------------------------" << endl;
   for(auto item : uc.GetItems(ItemIs::Prefix)) {
      cout << item.Name() << endl;
   }

   cout << "" << endl;
   cout << "Different versions of the + operator" << endl;
   cout << "------------------------------------" << endl;
   for(auto item : uc.GetItems("+")) {
      cout << item.Text() << endl;
   }
}

Items with the Prefix property
------------------------------
!
+
-
not
~

Different versions of the + operator
------------------------------------
Operator: 70 +{x}
Operator: 50 {x} + {y}
Operator: 50 {x As Int} + {y As Int} As Int
Operator: 50 {x As String} + {y As String} As String
Operator: 50 {x As Complex} + {y As Complex} As Complex
Operator: 50 {ByHandle x As AnyType Ptr} + {y As Int} As SameTypeAs:0 Ptr
Operator: 50 {ByHandle x As AnyType} + {ByHandle y As String} As String
Operator: 50 {ByHandle x As String} + {ByHandle y As AnyType} As String

#include <iostream>&#13;#include "uCalc.h"&#13;&#13;using namespace std;&#13;using namespace uCalcSoftware;&#13;&#13;int main() {&#13;   uCalc uc;&#13;   cout << "Items with the Prefix property" << endl;&#13;   cout << "------------------------------" << endl;&#13;   for(auto item : uc.GetItems(ItemIs::Prefix)) {&#13;      cout << item.Name() << endl;&#13;   }&#13;&#13;   cout << "" << endl;&#13;   cout << "Different versions of the + operator" << endl;&#13;   cout << "------------------------------------" << endl;&#13;   for(auto item : uc.GetItems("+")) {&#13;      cout << item.Text() << endl;&#13;   }&#13;}

				
					Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Console.WriteLine("Items with the Prefix property")
      Console.WriteLine("------------------------------")
      For Each item In uc.GetItems(ItemIs.Prefix)
         Console.WriteLine(item.Name)
      Next
      
      Console.WriteLine("")
      Console.WriteLine("Different versions of the + operator")
      Console.WriteLine("------------------------------------")
      For Each item In uc.GetItems("+")
         Console.WriteLine(item.Text)
      Next
   End Sub
End Module

Items with the Prefix property
------------------------------
!
+
-
not
~

Different versions of the + operator
------------------------------------
Operator: 70 +{x}
Operator: 50 {x} + {y}
Operator: 50 {x As Int} + {y As Int} As Int
Operator: 50 {x As String} + {y As String} As String
Operator: 50 {x As Complex} + {y As Complex} As Complex
Operator: 50 {ByHandle x As AnyType Ptr} + {y As Int} As SameTypeAs:0 Ptr
Operator: 50 {ByHandle x As AnyType} + {ByHandle y As String} As String
Operator: 50 {ByHandle x As String} + {ByHandle y As AnyType} As String

Imports System&#13;Imports uCalcSoftware&#13;Public Module Program&#13;   Public Sub Main()&#13;      Dim uc As New uCalc()&#13;      Console.WriteLine("Items with the Prefix property")&#13;      Console.WriteLine("------------------------------")&#13;      For Each item In uc.GetItems(ItemIs.Prefix)&#13;         Console.WriteLine(item.Name)&#13;      Next&#13;      &#13;      Console.WriteLine("")&#13;      Console.WriteLine("Different versions of the + operator")&#13;      Console.WriteLine("------------------------------------")&#13;      For Each item In uc.GetItems("+")&#13;         Console.WriteLine(item.Text)&#13;      Next&#13;   End Sub&#13;End Module