The Ceylon language module containing the core types referred to in the language specification.
Packages | |
ceylon.language | The Ceylon language package. |
ceylon.language.meta | The Ceylon metamodel base package. |
ceylon.language.meta.declaration | The Ceylon metamodel open type and declaration package. |
ceylon.language.meta.model | The Ceylon metamodel closed type and model package. |
The Ceylon language package.
Annotations | |
abstract | Source Code shared AbstractAnnotation abstract() Annotation to mark a class as abstract. An |
actual | Source Code shared ActualAnnotation actual() Annotation to mark a member of a type as refining a member of a supertype. |
annotation | Source Code shared AnnotationAnnotation annotation() Annotation to mark a class as an annotation class, or a top-level function as an annotation constructor. See also: Annotation |
by | Source Code Annotation to specify API authors. Parameters:
|
default | Source Code shared DefaultAnnotation default() Annotation to mark a member whose implementation may be
refined by subtypes. Non- |
deprecated | Source Code Annotation to mark program elements which should not be used anymore. Parameters:
|
doc | Source Code Annotation to specify API documentation of a program element. Parameters:
|
final | Source Code shared FinalAnnotation final() Annotation to mark a class as final. A |
formal | Source Code shared FormalAnnotation formal() Annotation to mark a member whose implementation must be provided by subtypes. |
late | Source Code shared LateAnnotation late() Annotation to disable definite initialization analysis for a reference. |
license | Source Code Annotation to specify the URL of the license of a module or package. Parameters:
|
native | Source Code shared NativeAnnotation native() Annotation to mark a member whose implementation is defined in platform-native code. |
optional | Source Code shared OptionalImportAnnotation optional() Annotation to specify that a module can be executed even if the annotated dependency is not available. |
see | Source Code Annotation to specify API references to other related program elements. Parameters:
|
shared | Source Code shared SharedAnnotation shared() Annotation to mark a type or member as shared. A |
tagged | Source Code Annotation to categorize the API by tag. Parameters:
|
throws | Source Code Annotation to mark a program element that throws an exception. Parameters:
|
variable | Source Code shared VariableAnnotation variable() Annotation to mark an value as variable. A |
AbstractAnnotation | Source Code shared AbstractAnnotation The annotation class for abstract. |
ActualAnnotation | Source Code shared ActualAnnotation The annotation class for actual. |
AnnotationAnnotation | Source Code shared AnnotationAnnotation The annotation class for annotation. |
AuthorsAnnotation | Source Code shared AuthorsAnnotation The annotation class for by. |
DefaultAnnotation | Source Code shared DefaultAnnotation The annotation class for default. |
DeprecationAnnotation | Source Code shared DeprecationAnnotation The annotation class for deprecated. |
DocAnnotation | Source Code shared DocAnnotation The annotation class for the doc annotation. |
FinalAnnotation | Source Code shared FinalAnnotation The annotation class for final. |
FormalAnnotation | Source Code shared FormalAnnotation The annotation class for formal. |
LateAnnotation | Source Code shared LateAnnotation The annotation class for late. |
LicenseAnnotation | Source Code shared LicenseAnnotation The annotation class for license. |
NativeAnnotation | Source Code shared NativeAnnotation The annotation class for native. |
OptionalImportAnnotation | Source Code shared OptionalImportAnnotation The annotation class for optional. |
SeeAnnotation | Source Code shared SeeAnnotation The annotation class for see. |
SharedAnnotation | Source Code shared SharedAnnotation The annotation class for shared. |
TagsAnnotation | Source Code shared TagsAnnotation The annotation class for tagged. |
ThrownExceptionAnnotation | Source Code shared ThrownExceptionAnnotation The annotation class for throws. |
VariableAnnotation | Source Code shared VariableAnnotation The annotation class for variable. |
Values | |
empty | Source Code shared empty empty A sequence with no elements, abbreviated |
emptyIterator | Source Code shared emptyIterator emptyIterator An iterator that returns no elements. |
emptyMap | Source Code shared emptyMap emptyMap A Map with no entries. |
emptySet | Source Code shared emptySet emptySet A Set with no elements. |
equal | Source Code shared equal equal The value is exactly equal to the given value. |
false | Source Code shared false false A value representing falsity in Boolean logic. |
finished | Source Code shared finished finished A value that indicates that an See also: Iterator |
infinity | Source Code An instance of |
language | Source Code shared language language Contains information about the language |
larger | Source Code shared larger larger The value is larger than the given value. |
nothing | Source Code shared Nothing nothing A value that is assignable to any type, but that results in an exception when evaluated. This is most useful for generating members in an IDE. |
null | Source Code shared null null The null value. By: Gavin |
operatingSystem | Source Code shared operatingSystem operatingSystem Operating System on which the current process is running. |
process | Source Code shared process process Represents the current process (instance of the virtual machine). By: Gavin, Tako |
runtime | Source Code shared runtime runtime Machine (Virtual or not) on which the current process is running. Holds information about runtime name, version and about inherent limitations like minimum/maximum values that can be represented by the runtime. |
smaller | Source Code shared smaller smaller The value is smaller than the given value. |
system | Source Code shared system system Represents the system on which the current process is running. Holds information about system time and locale. |
true | Source Code shared true true A value representing truth in Boolean logic. |
Functions | |
any | Source Code Determines if any one of the given boolean values
(usually a comprehension) is See also: every |
apply | Source Code Applies an arbitrary In practice, this behaves as if the See also: unflatten |
arrayOfSize | Source Code Create an array of the specified size, populating every
index with the given element. If the specified size is
smaller than Parameters:
|
byDecreasing | Source Code A comparator which orders elements in decreasing order
according to the See also: byIncreasing |
byIncreasing | Source Code A comparator which orders elements in increasing order
according to the See also: byDecreasing |
byItem | Source Code shared Comparison byItem<Item>(Comparison comparing(Item x, Item y))(Object->Item x, Object->Item y) A comparator for See also: byKey |
byKey | Source Code A comparator for See also: byItem |
className | Source Code Return the name of the concrete class of the given object, in a format native to the virtual machine. |
coalesce | Source Code Return a sequence containing the given values which are not null. If there are no values which are not null, return an empty sequence. Parameters:
|
compose | Source Code Given a function with return type For any such functions compose(g,f)(*args)==g(f(*args)) for every possible argument tuple |
concatenate | Source Code Given a list of iterable objects, return a new sequence of all elements of the all given objects. If there are no arguments, or if none of the arguments contains any elements, return the empty sequence. Parameters:
See also: SequenceBuilder |
count | Source Code A count of the number of |
curry | Source Code shared Callable<Return,Rest> curry<Return, Argument, First, Rest>(Callable<Return,Tuple<Argument,First,Rest>> f)(First first) given First satisfies Argument Curries a function, returning a function with two parameter lists, given a function with at least one parameter. The first parameter list of the returned function has just the first parameter of the original function, and the second parameter list has the remaining parameters. That is, if |
emptyOrSingleton | Source Code |
entries | Source Code Given a stream of items, produce a stream of entries.
For each non-null item produced by the given stream
of items, the resulting stream contains an See also: Iterable.indexed |
equalTo | Source Code Returns a partial function that will compare an element to any other element and returns true if they're equal. This is useful in conjunction with methods that receive a predicate function. |
every | Source Code Determines if every one of the given boolean values
(usually a comprehension) is See also: any |
first | Source Code The first of the given values (usually a comprehension), if any. |
flatten | Source Code Given a function with a single parameter of tuple type
That is, if See also: unflatten |
forItem | Source Code A function that returns the result of the given See also: forKey |
forKey | Source Code A function that returns the result of the given See also: forItem |
formatInteger | Source Code The string representation of If Parameters:
Throws:
|
greaterThan | Source Code Returns a partial function that will compare an element to any other element and returns true if the compared element is greater than its element. This is useful in conjunction with methods that receive a predicate function. |
identical | Source Code Determine if the arguments are identical. Equivalent to
Parameters:
See also: identityHash |
identityHash | Source Code Return the system-defined identity hash value of the given value. This hash value is consistent with identity equality. See also: identical |
largest | Source Code Given two See also: Comparable, smallest, max |
lessThan | Source Code Returns a partial function that will compare an element to any other element and returns true if the compared element is less than its element. This is useful in conjunction with methods that receive a predicate function. |
mapPairs | Source Code shared {Result*} mapPairs<Result, FirstArgument, SecondArgument>(Result collecting(FirstArgument firstArg, SecondArgument secondArg), {FirstArgument*} firstArguments, {SecondArgument*} secondArguments) Given two streams, form a new stream by applying a function to the arguments in the given streams. The length of the resulting stream is the length of the shorter of the two given streams. Thus: mapPairs(xs,ys,fun)[i]==fun(xs[i],ys[i]) for every |
max | Source Code Given a nonempty stream of See also: Comparable, min, largest |
min | Source Code Given a nonempty stream of See also: Comparable, max, smallest |
parseBoolean | Source Code The Recognized values are “true”, “false”. |
parseFloat | Source Code The The syntax accepted by this method is the same as the
syntax for a |
parseInteger | Source Code The The syntax accepted by this function is the same as the
syntax for an A radix can be given in input to specify what is the base
to take in consideration for the parsing. radix has to be
between
Parameters:
Throws:
|
plus | Source Code |
Source Code Print a line to the standard output of the virtual machine
process, printing the given value's This method is a shortcut for: process.writeLine(line?.string else "<null>") and is intended mainly for debugging purposes. By: Gavin | |
printAll | Source Code Print multiple values to the standard output of the virtual machine process as a single line of text, separated by a given character sequence. Parameters:
By: Gavin |
printStackTrace | Source Code Print the stack trace of the given exception using the given function, or to standard error if no function is specified. Parameters:
|
product | Source Code Given a nonempty stream of See also: sum |
shuffle | Source Code shared Callable<Callable<Result,FirstArgs>,SecondArgs> shuffle<Result, FirstArgs, SecondArgs>(Callable<Callable<Result,SecondArgs>,FirstArgs> f) Given a function with two parameter lists, return a function with the order of the argument lists reversed. The parameter lists may have any number of parameters. That is, if This function is often used in conjunction with
See also: curry |
smallest | Source Code Given two See also: Comparable, largest, min |
sort | Source Code Sort the given elements, returning a new sequence. See also: Comparable |
sum | Source Code Given a nonempty stream of See also: product |
suppressedExceptions | Source Code Returns the exceptions that were suppressed (if any) during the handling of the given exception. |
times | Source Code |
uncurry | Source Code shared Callable<Return,Tuple<Argument,First,Rest>> uncurry<Return, Argument, First, Rest>(Callable<Return,Rest> f(First first)) given First satisfies Argument Uncurries a function, returning a function with one parameter list, given a function with two parameter lists, where the first parameter list has exactly one parameter. The parameter list of the returned function has the parameter of the first parameter list of the original function, followed by all parameters of the second parameter list. That is, if |
unflatten | Source Code Given a function with parameter types
That is, if See also: flatten |
unzip | Source Code Given a stream of tuples, return two streams. The first stream produces the first elements of the given tuples, and the second stream produces the remaining elements of the given tuples. Thus: unzip(tuples)[i]==[tuples[i].first,*tuples[i].rest] |
unzipEntries | Source Code Given a stream of entries, return two streams. The first stream produces the keys of the given entries, and the second stream produces the items of the given entries. Thus: unzipEntries(entries)[i]==[entries[i].key,entries[i].item] |
unzipPairs | Source Code Given a stream of pairs, return two streams. The first stream produces the first elements of the given pairs, and the second stream produces the second elements of the given pairs. Thus: unzipPairs(pairs)[i]==[pairs[i][0],pairs[i][1]] |
zip | Source Code Given a stream of values, and a stream of tuples, produce a new stream of tuples formed by prepending the values in the first stream to the tuples in the second stream. The length of the resulting stream is the length of the shorter of the two given streams. Thus: zip(heads, tails)[i]==[heads[i],*tails[i]] for every |
zipEntries | Source Code Given two streams, form a new stream consisting of all entries where, for any given index in the resulting stream, the key of the entry is the element occurring at the same index in the first stream, and the item is the element occurring at the same index in the second stream. The length of the resulting stream is the length of the shorter of the two given streams. Thus: zipEntries(keys,items)[i]==keys[i]->items[i] for every |
zipPairs | Source Code Given two streams, form a new stream consisting of all pairs where, for any given index in the resulting stream, the first element of the pair is the element occurring at the same index in the first stream, and the second element of the pair is the element occurring at the same index in the second stream. The length of the resulting stream is the length of the shorter of the two given streams. Thus: zipPairs(xs,ys)[i]==[xs[i],ys[i]] for every |
Interfaces | |
Annotated | Source Code shared Annotated A program element that can be annotated. |
Annotation | Source Code shared Annotation The supertype of all annotation classes. Annotation classesAn annotation class must satisfy "An annotation class." final annotation class Example(shared String description) satisfies Annotation {} Annotation classes which satisfy Each initializer parameter of an annotation class must have one of the following types:
An initializer parameter of an annotation class may be variadic or defaulted. Annotation constructorsAn annotation constructor is simply a top level function, annotated with
"An annotation constructor." annotation Example example(String description="") => Example(description); Each parameter of an annotation constructor must have one of the following types:
A parameter of an annotation constructor may be variadic or defaulted. The constructor must simply instantiate and return the annotation class, and there are strict rules about the arguments to the instantiation. An annotation class can have multiple annotation constructors. |
Binary | Source Code Abstraction of numeric types like |
Callable | Source Code A reference to a function. The type arguments encode
the function return type and parameter types. The
parameter types are typically represented as a tuple
type. For example, the type of the function reference
Callable<Float,[Float,Float]> which we usually abbreviate Float(Float,Float) add = plus<Float>; value four = add(2.0, 2.0); or by supplying a tuple containing the arguments: Float(Float,Float) add = plus<Float>; [Float,Float] twoAndTwo = [2.0, 2.0]; value four = add(*twoAndTwo); This interface may not be implemented by user code. |
Category | Source Code shared Category Abstract supertype of objects that contain other
values, called elements, where it is possible to
efficiently determine if a given value is an element.
The if ("hello" in "hello world") { ... } if (69 in 0..100) { ... } if (key->value in { for (n in 0..100) n.string->n**2 }) { ... } Ordinarily, |
Cloneable | Source Code Abstract supertype of objects whose value can be cloned. |
Closeable | Source Code shared Closeable Abstract supertype of types which may appear
as the expression type of a resource expression
in a |
Collection | Source Code Represents an iterable collection of elements of finite
size. A All |
Comparable | Source Code The general contract for values whose magnitude can be
compared. The total order of a type must be consistent with the definition of equality for the type. That is, there are three mutually exclusive possibilities:
|
ConstrainedAnnotation | Source Code shared ConstrainedAnnotation<out Value = Annotation,out Values = Anything,in ProgramElement = Nothing> An annotation constrained to appear only on certain program elements, and only with certain values. This interface should not be satisfied directly. Instead either OptionalAnnotation or SequencedAnnotation should be satisfied. |
Correspondence | Source Code Abstract supertype of objects which associate values
with keys. The item corresponding to a given key may be obtained
from a value bg = settings["backgroundColor"] else white; The |
Empty | Source Code shared Empty A sequence with no elements. The type [] none = []; (Whether the syntax |
Enumerable | Source Code Abstraction of ordinal types whose instances can be mapped to the integers or to a range of integers. |
Exponentiable | Source Code Abstraction of numeric types that may be
raised to a power |
Identifiable | Source Code shared Identifiable The abstract supertype of all types with a well-defined
notion of identity. Values of type |
Integral | Source Code Abstraction of integral numeric types. That is, types
with no fractional part, including |
Invertable | Source Code Abstraction of types which support a unary additive
inversion operation Implementations which also satisfy Summable should respect the following constraint:
|
Iterable | Source Code Abstract supertype of categories whose elements may be iterated. An iterable category need not be finite, but its elements must at least be countable. There may not be a well-defined iteration order, and so the order of iterated elements may not be stable. The type An instance of {String+} words = { "hello", "world" }; An instance of for (c in "hello world") { ... }
Lazy operations are preferred, because they can be efficiently chained. For example: string.filter((Character c) => c.letter) .map((Character c) => c.uppercased) is much less expensive than: string.select((Character c) => c.letter) .collect((Character c) => c.uppercased) Furthermore, it is always easy to produce a new immutable iterable object given the view produced by a lazy operation. For example: [ *string.filter((Character c) => c.letter) .map((Character c) => c.uppercased) ] Lazy operations normally return an instance of
However, there are certain scenarios where an eager operation is more useful, more convenient, or no more expensive than a lazy operation, including:
Eager operations normally return a sequence. |
Iterator | Source Code Produces elements of an |
List | Source Code Represents a collection in which every element has a unique non-negative integer index. A Direct access to a list element by index produces a
value of optional type. The following idiom may be
used instead of upfront bounds-checking, as long as
the list element type is a non- value char = "hello world"[index]; if (exists char) { /*do something*/ } else { /*out of bounds*/ } To iterate the indexes of a for (i->char in "hello world".indexed) { ... } |
Map | Source Code Represents a collection which maps keys to items,
where a key can map to at most one item. Each such
mapping may be represented by an A The presence of an entry in a map may be tested
using the if ("lang"->"en_AU" in settings) { ... } The entries of the map may be iterated using for (key->item in settings) { ... } The item for a key may be obtained using the item operator: String lang = settings["lang"] else "en_US"; |
Number | Source Code shared Number Abstraction of numbers. Binary numeric operations are
defined the interface Numeric. This type defines
operations which can be expressed without reference to
the self type |
Numeric | Source Code Abstraction of numeric types with addition,
In general, a numeric type need not define a total order. For example, complex numbers do not have a total order. Numeric types with a total order also satisfy Scalar. |
OptionalAnnotation | Source Code An annotation that may occur at most once at a single program element and only on certain program elements. An optional annotation is declared simply by having the annotation class
satisfy OptionalAnnotation instead of Annotation. For example
the following would only be allowed on final annotation class ExampleClass() satisfies OptionalAnnotation<Example, ClassDeclaration> {} At runtime a ceylon.language.meta.declaration::Declaration instance
can be queried for its |
Ordinal | Source Code Abstraction of ordinal types, that is, types with
successor and predecessor operations, including
|
Ranged | Source Code Abstract supertype of ranged objects which map a range
of A span may be obtained from an instance of print("hello world"[0..5]) |
Scalable | Source Code Abstract supertype of types that support scaling by
a numeric factor Implementations should generally respect the following constraints, where relevant:
Implementations of
Implementations of
|
Scalar | Source Code Abstraction of numeric types representing scalar values with a total order, including the built-in numeric types Integer and Float. |
Sequence | Source Code A nonempty, immutable sequence of values. The type
Given a possibly-empty sequence of type [Integer*] nums = ... ; if (nonempty nums) { Integer first = nums.first; Integer max = max(nums); [Integer+] squares = nums.collect((Integer i) => i**2)); [Integer+] sorted = nums.sort(byIncreasing((Integer i) => i)); } Operations like |
SequencedAnnotation | Source Code An annotation that may occur multiple times at a single program element, and only on certain program elemenets. A sequenced annotation is declared simply by having the annotation class
satisfy SequencedAnnotation instead of Annotation. For example
the following would only be allowed on alias ExecutableDeclaration => ClassOrInterfaceDeclaration|FunctionDeclaration "Documents a pattern that the annotated element is particpating in" final annotation class Pattern(String name) satisfies SequencedAnnotation<Pattern, ExecutableDeclaration> { } At runtime a ceylon.language.meta.declaration::Declaration instance
can be queried for its |
Sequential | Source Code A possibly-empty, immutable sequence of values. The
type
|
Set | Source Code A collection of unique elements. A Sets may be the subject of the binary union,
intersection, and complement operators |
Summable | Source Code Abstraction of types which support a binary addition
operator In general, the addition operation should be a binary associative operation. |
Classes | |
Anything | Source Code shared abstract Anything The abstract supertype of all types. A value of type
Note that the type |
Array | Source Code A fixed-size array of elements. An array may have zero size (an empty array). Arrays are mutable. Any element of an array may be set to a new value. This class is provided primarily to support interoperation with Java, and for some performance-critical low-level programming tasks. |
ArraySequence | Source Code An immutable |
Basic | Source Code shared abstract Basic The default superclass when no superclass is explicitly
specified using |
Boolean | Source Code shared abstract Boolean A type capable of representing the values true and false of Boolean logic. |
Character | Source Code shared Character A 32-bit Unicode character. |
Comparison | Source Code shared abstract Comparison The result of a comparison between two |
Entry | Source Code A pair containing a key and an associated value called
the item. Used primarily to represent the elements of
a String->Person entry = person.name->person; |
Finished | Source Code shared abstract Finished The type of the value that indicates that
an |
Float | Source Code shared Float An IEEE 754 64-bit floating point number. A |
Integer | Source Code shared Integer A 64-bit integer, or the closest approximation to a 64-bit integer provided by the underlying platform.
Overflow or loss of precision occurs silently (with no exception raised). |
LazyList | Source Code An implementation of |
LazyMap | Source Code A |
LazySet | Source Code An implementation of |
Null | Source Code shared abstract Null The type of the The String? firstArg = process.arguments.first; if (exists firstArg) { print("hello " + firstArg); } The String name = process.arguments.first else "world"; The Float? diff = x>=y then x-y; |
Object | Source Code shared abstract Object The abstract supertype of all types representing
definite values. Any two true==false 1=="hello world" "hello"+" "+"world"=="hello world" Singleton("hello world")=={ "hello world" } However, since |
Range | Source Code Represents the range of totally ordered, ordinal values
generated by two endpoints of type A range may be produced using the for (i in min..max) { ... } if (char in 'A'..'Z') { ... } |
SequenceAppender | Source Code This class is used for constructing a new nonempty
sequence by incrementally appending elements to an
existing nonempty sequence. The existing sequence is
not modified, since |
SequenceBuilder | Source Code Since sequences are immutable, this class is used for constructing a new sequence by incrementally appending elements to the empty sequence. This class is mutable but threadsafe. |
Singleton | Source Code A sequence with exactly one element, which may be null. |
String | Source Code shared String A string of characters. Each character in the string is a 32-bit Unicode character. The internal UTF-16 encoding is hidden from clients. A string is a 'w' in greeting "hello" in greeting Strings are summable: String greeting = "hello" + " " + "world"; They are efficiently iterable: for (char in "hello world") { ... } They are value char = "hello world"[5]; They are ranged: String who = "hello world"[6...]; Note that since It is easy to use comprehensions to transform strings: String { for (s in "hello world") if (s.letter) s.uppercased } Since a |
StringBuilder | Source Code shared StringBuilder Since strings are immutable, this class is used for constructing a string by incrementally appending characters to the empty string. This class is mutable but threadsafe. |
Tuple | Source Code A tuple is a typed linked list. Each instance of
value point = Tuple(0.0, Tuple(0.0, Tuple("origin"))); Float x = point.first; Float y = point.rest.first; String label = point.rest.rest.first; Usually, we abbreviate code involving tuples. [Float,Float,String] point = [0.0, 0.0, "origin"]; Float x = point[0]; Float y = point[1]; String label = point[2]; A list of types enclosed in brackets is an abbreviated
tuple type. An instance of [String,String] words = ["hello", "world"]; The index operator with a literal integer argument is a
shortcut for a chain of evaluations of A terminated tuple type is a tuple where the type of
the last link in the chain is Here, String[] labels = ... ; [Float,Float,String*] point = [0.0, 0.0, *labels]; Float x = point[0]; Float y = point[1]; String? firstLabel = point[2]; String[] allLabels = point[2...]; |
empty | Source Code shared empty A sequence with no elements, abbreviated |
emptyIterator | Source Code shared emptyIterator An iterator that returns no elements. |
emptyMap | Source Code shared emptyMap A Map with no entries. |
emptySet | Source Code shared emptySet A Set with no elements. |
equal | Source Code shared equal The value is exactly equal to the given value. |
false | Source Code shared false A value representing falsity in Boolean logic. |
finished | Source Code shared finished A value that indicates that an |
language | Source Code shared language Contains information about the language |
larger | Source Code shared larger The value is larger than the given value. |
null | Source Code shared null The null value. |
operatingSystem | Source Code shared operatingSystem Operating System on which the current process is running. |
process | Source Code shared process Represents the current process (instance of the virtual machine). |
runtime | Source Code shared runtime Machine (Virtual or not) on which the current process is running. Holds information about runtime name, version and about inherent limitations like minimum/maximum values that can be represented by the runtime. |
smaller | Source Code shared smaller The value is smaller than the given value. |
system | Source Code shared system Represents the system on which the current process is running. Holds information about system time and locale. |
true | Source Code shared true A value representing truth in Boolean logic. |
Exceptions | |
AssertionException | Source Code shared AssertionException An exception that occurs when an assertion fails, that
is, when a condition in an |
Exception | Source Code shared Exception The supertype of all exceptions. A subclass represents a more specific kind of problem, and may define additional attributes which propagate information about problems of that kind. |
InitializationException | Source Code shared InitializationException Thrown when a problem was detected with value initialization. Possible problems include:
|
NegativeNumberException | Source Code shared NegativeNumberException Thrown when a negative number is not allowed. |
OverflowException | Source Code shared OverflowException Thrown when a mathematical operation caused a number to overflow from its bounds. |