Type Union is used for objects that can be of any of a specific finite set of types. Union Two versions of unions are available, one with selectors (like records) and one without. union
The declaration states that can have values that are integers, strings or ``big'' floats. If, for example, the Union object is an integer, the object is said to belong to the Integer branch of the Union. Note that we are being a bit careless with the language here. Technically, the type of is always Union(Integer, String, Float). If it belongs to the Integer branch, may be converted to an object of type Integer.
The syntax for writing a Union type without selectors is
Union(, , ..., )
The types in a union without selectors must be distinct.
It is possible to create unions like Union(Integer, PositiveInteger) but they are difficult to work with because of the overlap in the branch types. See below for the rules Axiom uses for converting something into a union object.
The case infix case operator returns a Boolean and can be used to determine the branch in which an object lies.
This function displays a message stating in which branch of the Union the object (defined as above) lies.
This tries sayBranch with an integer.
This tries sayBranch with a string.
This tries sayBranch with a floating-point number.
There are two things of interest about this particular example to which we would like to draw your attention.
Sometimes Union types can have extremely long names. Axiom therefore abbreviates the names of unions by printing the type of the branch first within the Union and then eliding the remaining types with an ellipsis (...).
Here the Integer branch is displayed first. Use ``::'' to create a Union object from an object.
Here the String branch is displayed first.
Use typeOf to see the full and actual Union type. typeOf
A common operation that returns a union is exquoexquoInteger which returns the ``exact quotient'' if the quotient is exact,
and "failed" if the quotient is not exact.
A union with a "failed" is frequently used to indicate the failure or lack of applicability of an object. As another example, assign an integer a variable declared to be a rational number.
The operation retractIfCanretractIfCanFraction tries to retract the fraction to the underlying domain Integer. It produces a union object. Here it succeeds.
Assign it a rational number.
Here the retraction fails.
Like records (ugTypesRecords ), you can write Union types selector:union with selectors. union:selector
The syntax for writing a Union type with selectors is
Union(:, :, ..., :)
You must be careful if a selector has the same name as a variable in
the workspace. If this occurs, precede the selector name by a single
quote quote. selector:quoting It is an error to use a
selector that does not correspond to the branch of the Union in
which the element actually lies.
Be sure to understand the difference between records and unions with selectors. union:difference from record Records can have more than one component and the selectors are used to refer to the components. record:difference from union Unions always have one component but the type of that one component can vary. An object of type Record(a: Integer, b: Float, c: String) contains an integer and a float and a string. An object of type Union(a: Integer, b: Float, c: String) contains an integer or a float or a string.
Here is a version of the sayBranch function (cf. ugTypesUnionsWOSel ) that works with a union with selectors. It displays a message stating in which branch of the Union the object lies.
Note that case uses the selector name as its right-hand argument. case If you accidentally use the branch type on the right-hand side of case, false will be returned.
Declare variable to have a union type with selectors.
Give an initial value to .
Use to determine in which branch of a Union an object lies.
To access the element in a particular branch, use the selector.