Type properties summary

Potentially cyclic — A potentially cyclic type uses the @n notation when it is parsed or converted to a string. When a potentially cyclic type is cloned, the correlator uses an algorithm that preserves aliases. See Potentially cyclic types

	Yes. This type has the corresponding property. 1 Attempts to use a NaN in a key terminates the monitor instance. 2 Although a context can be enqueued, it is not parseable, so the correlator will reject it from the input queue with a warning.
	No. This type does not have the corresponding property.
	This type inherits the corresponding property from its constituent types, that is, the item type in a sequence, the key and item types in a dictionary, the types of fields in an event. The type has the corresponding property only when all its constituent types have that property. 3 An event defined inside a monitor cannot be emitted, enqueued or received by the correlator.
	The type is comparable only when all its constituent types are both comparable and acyclic.
	An event E is acyclic only when all its constituent types are both acyclic and E-free.

// You can do everything with "Tick", including index both its fields.

event Tick {
string symbol;
float price;
}

// You can do everything with "Order", except refer to its target or
// properties fields in an event template.

event Order {
string customer;
Tick target;
string symbol;
float quantity;
dictionary<string,string> properties;
}

// The correlator cannot receive this as an external event and you cannot
// usefully enqueue it, but you can route it, or enqueue it to a context.

event SubscriptionRequest {
string channel;
context recipient;
}

// You can do very little with this event except access its members and
// methods. It cannot be routed, you cannot sort sequence<TimeParse>,
// trying to group a stream query by TimeParse is illegal, and so on.

event TimeParse {
import "TimeFormatPlugin" as TF;
string pattern;
chunk compiledPattern;
}

// This has all the same restrictions as TimeParse, but is also
// potentially cyclic, so will use the @n format when parsed or
// converted to a string.

event Room {
string roomName;
float squareFeet;
sequence<Room> adjacentRooms;
sequence<Employee> occupants;
}

Data Type	Indexable	Parseable	Routable	Comparable	Acyclic	E-free
boolean
decimal				1
float				1
integer
string
location
context			2
listener
chunk
stream
action
sequence
dictionary
event E		3	3