Package-level declarations

A Graph is an unordered collection of vertices, along with the successor-predecessor relationships between them. From the Graph's viewpoint, the vertices are merely mementos that support equals and hashCode. Edges are not explicitly represented, but instead are a consequence of how the outEdges and inEdges are populated.

IO is a utility class for input/output operations.

This is an implementation of a directed multigraph. A graph consists of a collection of vertices connected by (directed) edges. A vertex v1 may be connected to another vertex v2 by more than one edge, which makes this a multigraph implementation. However, note that v1 and v2 can not be multiply connected by the same edge (i.e., two edges connecting v1 and v2 must not be equal to each other).

Support explicit mutable wrapping of variables. This was useful when the VM was in Java, since values captured by inner classes and lambdas could only be immutable. Kotlin introduces its own mutable wrappers for captured vars, but this is still occasionally useful.

A NullOutputStream discards everything written to it.

A utility for determining the shortest path through fields from a starting object to a target object. The search is performed breadth-first to ensure the shortest path is found.

A ParagraphFormatter object holds a particular paragraph style in the form of window width, margin, and indentation settings. It is then used to apply those whitespace and word-wrap settings to a String.

ParagraphFormatterStream wraps an Appendable with a ParagraphFormatter, so that Strings can automatically be formatted by the ParagraphFormatter before being appended to the output stream.

This is an implementation of an immutable List for which append, the non-destructive append operation, takes constant time. There is also a withoutLast operation for producing a list with its rightmost element removed. Iterating over the entire list takes linear time, and does not use recursion.

A prefix tree, with amortized O(1) access time, amortized O(1) insertion time O(1), amortized O(1) removal time, and O(n) prune time. Thread-safe iff the internal transition tables, supplied by the factory, are thread-safe.

Subclasses get a public clone method without a silly catch of an impossible exception.

A ThreadFactory that creates Threads named with a prefix, a dash, and a practically unique counter.

Strings provides various string utilities.

Tuple of length 1.

Tuple of length 10.

Tuple of length 2.

Tuple of length 3.

Tuple of length 4.

Tuple of length 5.

Tuple of length 6.

Tuple of length 7.

Tuple of length 8.

Tuple of length 9.

UTF8ResourceBundleControl permits the reading of UTF-8-encoded Java properties files.

A WorkStealingQueue tracks parallelism separate subqueues of tasks. Each Interpreter feeds and consumes a distinct subqueue dedicated to that interpreter thread, ideally without contention from other threads. When a subqueue is exhausted, the requesting thread will examine the other threads' queues and steal one for itself. Only at that point will contention occur.

Produce a String representation of the stack trace captured in this Throwable.

Given a List of Iterables (over some X), execute the action for each combination of X values, one from each Iterable.

When you know better, this bypasses static type-safety, while leaving dynamic type-safety intact, other than generics and nulls.

Produce a String representation of the current stack trace. It throws a Throwable and catches it, which will show up in the trace.

Given an Iterable receiver, run the normal forEach operation to produce a series of values, apply the extractor extension function to each of those values to produce an Iterable for each of them, and run forEach on those Iterables, in order, using the body function.

Given an Iterable receiver, run the normal forEach operation to produce a series of values, apply the extractor1 extension function to each of those values to produce an Iterable for each of them, run the extractor2 extension function to produce an Iterable to run forEach on, with the body function.

Drain the elements of the receiver into a new MutableSet, leaving the receiver empty.

Having already compared two things to get an Int that represents less-than, equal, or greater-than, answer that if it's not equal (i.e., not 0). Otherwise use the inlined zero-argument block to do further comparisons.

Having already compared two things to get an Int that represents less-than, equal, or greater-than, answer that if it's not equal (i.e., not 0). Otherwise evaluate the two lambdas and use (Comparable.compareTo) to produce an Int to use instead.

If the receiver is null, answer true. Otherwise run the body with the non-null receiver and answer the resulting Boolean.

Create an Iterable, starting with the receiver. The iterator produces successive values by applying advance until null is reached. The receiver is also allowed to be null, which indicates an empty iterator.

Run a daemon thread that drives the receiver.

Execute the given lambda repeatedly until it returns true.

Execute the given lambda repeatedly until it returns false.

Transform the receiver via the supplied function and collect the results into an optionally provided set. Answer the result set.

If the receiver is null, answer false. Otherwise run the body with the non-null receiver and answer the resulting Boolean.

For each element in the collection, execute the action, passing a zero-argument function to run exactly once afterward (in this Thread or another). When the last element's zero-argument function has been invoked, or immediately if the collection is empty, invoke then.

For each element in the collection, execute the action, passing a zero-argument function to run exactly once afterward (in this Thread or another). When the last element's zero-argument function has been invoked, or immediately if the collection is empty, invoke then.

Partition the receiver into partitions approximately equal sublists. Some may be empty if count is larger than the receiver's size. Invoke the supplied body for each sublist. The body must eventually, perhaps in another Thread, invoke a function passed to it, to indicate completion, and to provide a list containing the element-wise transformation of the original sublist. These transformed sublists are then concatenated to form a new list, which is passed to the after function, perhaps in another Thread.

Given a list and a key-extraction function, produce a list of non-empty lists of elements that have the same key. Note that it only looks for runs of a key, and treats reoccurrences of some key after a gap to be a new key.

Kotlin has one of these in experimental, which forces the Universe to say it's also experimental. So boo.

Execute the given lambda while holding the supplied ReentrantReadWriteLock's write lock. This is the correct alternative to the broken write supplied by the Kotlin library, which non-atomically attempts to upgrade a read lock into a write lock by first dropping all extant holds of the read lock (!).

Construct a tuple of length 1.

Construct a tuple of length 2.

Construct a tuple of length 3.

Construct a tuple of length 4.

Construct a tuple of length 5.

Construct a tuple of length 6.

Construct a tuple of length 7.

Construct a tuple of length 8.

Construct a tuple of length 9.

Construct a tuple of length 10.

Project the receiver onto an {@link EnumMap}, applying the function to each enum value of the array.