scala.caps

Capability trackingSome classes in this package were compiled with capability tracking enabled.Learn more

Show tracked capabilities

Members list

Type members

Classlikes

Base trait for classes that represent capabilities in the object-capability model.

A capability is a value representing a permission, access right, resource or effect. Capabilities are typically passed to code as parameters; they should not be global objects. Often, they come with access restrictions such as scoped lifetimes or limited sharing.

An example is the Label class in scala.util.boundary. It represents a capability in the sense that it gives permission to break to the enclosing boundary represented by the Label. It has a scoped lifetime, since breaking to a Label after the associated boundary was exited gives a runtime exception.

Capability has a formal meaning when Capture Checking is turned on. But even without capture checking, extending this trait can be useful for documenting the intended purpose of a class.

Capability has exactly two subtraits: Shared and Exclusive.

Attributes

Source: package.scala
Supertypes: class Any
Known subtypes: trait ExclusiveCapability

trait Unscoped

trait Mutable

trait Var[T]

trait SharedCapability

trait Control

class Label[T]

class CanThrow[E]

object any

object fresh
Show all

A marker trait for classifier capabilities that can appear in .only and .except qualifiers. Capability classes directly extending Classifier are treated as classifier capbilities.

Classifier has a formal meaning when Capture Checking is turned on. It should not be used outside of capture checking.

Attributes

Source: package.scala
Supertypes: class Object

trait Matchable

class Any
Known subtypes: trait Control

class Label[T]

class CanThrow[E]

trait SharedCapability

trait Unscoped

trait Mutable

trait Var[T]
Show all

Marker trait for capabilities that capture some continuation or return point in the stack. Examples are exceptions, labels, CanThrow or Async contexts.

Control has a formal meaning when Capture Checking is turned on.

Attributes

Source: package.scala
Supertypes: trait SharedCapability

trait Classifier

trait Capability

class Object

trait Matchable

class Any
Show all
Known subtypes: class Label[T]

class CanThrow[E]

A marker trait that declares that all inheriting classes are "pure" in the sense that their values retain no capabilities including capabilities needed to perform effects. This has formal meaning only under capture checking.

NOTE: If an upper bound is Pure, we check that an argument conforms to it only in sources where capture checking is enabled. For instance,

def fC <: Pure fObject

would give an error only under capture checking. Pure is also dropped in upper bounds if it forms part of an &-type, or is under a type lambda.

Attributes

Source: Pure.scala
Supertypes: class Any
Known subtypes: trait MapOps[K, V, CC, C]

trait Map[K, V]

class AbstractMap[K, V]

class HashMap[K, V]

class IntMap[T]

class ListMap[K, V]

class LongMap[T]

class Map1[K, V]

class Map2[K, V]

class Map3[K, V]

class Map4[K, V]

class WithDefault[K, V]

class WithDefault[K, V]

class TreeMap[K, V]

class TreeSeqMap[K, V]

class VectorMap[K, V]

trait SeqMap[K, V]

trait SortedMap[K, V]

trait SortedMapOps[K, V, CC, C]

trait StrictOptimizedSortedMapOps[K, V, CC, C]

trait StrictOptimizedMapOps[K, V, CC, C]

trait SeqOps[A, CC, C]

trait IndexedSeqOps[A, CC, C]

class ArraySeq[A]

class ofBoolean

class ofByte

class ofChar

class ofDouble

class ofFloat

class ofInt

class ofLong

class ofRef[T]

class ofShort

class ofUnit

trait IndexedSeq[A]

class NumericRange[T]

class Exclusive[T]

class Inclusive[T]

class Range

class Exclusive

class Inclusive

class Vector[A]

class WrappedString

trait LinearSeqOps[A, CC, C]

class LazyList[A]

trait LinearSeq[A]

class List[A]

class ::[A]

object Nil

class Queue[A]

class Stream[A]

class Cons[A]

object Empty

trait Seq[A]

class AbstractSeq[A]

class LazyListBase[A]

trait StrictOptimizedSeqOps[A, CC, C]

trait MapOps[K, V, CC, C]

class TrieMap[K, V]

class AnyRefMap[K, V]

class CollisionProofHashMap[K, V]

class HashMap[K, V]

class LinkedHashMap[K, V]

class ListMap[K, V]

class LongMap[V]

trait Map[K, V]

trait Map[K, V]

class AbstractMap[K, V]

class WithDefault[K, V]

class WithDefault[K, V]

class OpenHashMap[Key, Value]

class TreeMap[K, V]

class SystemProperties

trait MultiMap[K, V]

trait SeqMap[K, V]

trait SortedMap[K, V]

trait SortedMapOps[K, V, CC, C]

trait SeqOps[A, CC, C]

trait Buffer[A]

class AbstractBuffer[A]

class ArrayBuffer[A]

class ArrayDeque[A]

class Queue[A]

class Stack[A]

class ListBuffer[A]

class UnrolledBuffer[T]

trait IndexedBuffer[A]

trait IndexedSeqOps[A, CC, C]

class ArraySeq[T]

class ofBoolean

class ofByte

class ofChar

class ofDouble

class ofFloat

class ofInt

class ofLong

class ofRef[T]

class ofShort

class ofUnit

trait IndexedSeq[T]

class StringBuilder

trait Seq[A]

class AbstractSeq[A]

class Accumulator[A, CC, C]

class AnyAccumulator[A]

class DoubleAccumulator

class IntAccumulator

class LongAccumulator

trait EvidenceIterableFactory[CC, Ev]

trait ClassTagIterableFactory[CC]

class Delegate[CC]

class Delegate[CC]

trait ClassTagSeqFactory[CC]

trait StrictOptimizedClassTagSeqFactory[CC]

object ArraySeq

object ArraySeq

object UnrolledBuffer

class Delegate[CC, Ev]

class Delegate[CC]

object SortedSet

object SortedSet

object SortedSet

trait SortedIterableFactory[CC]

object TreeSet

object PriorityQueue

object TreeSet

trait IterableFactory[CC]

object HashSet

object LazyListIterable

object ListSet

object Set

object HashSet

object LinkedHashSet

class AnyIterableDelegate[CC]

class AnySeqDelegate[CC]

class Delegate[CC]

object Iterable

object Iterable

object Set

object Iterable

object Set

object Iterator

trait SeqFactory[CC]

object LazyList

object Stream

class Delegate[CC]

object IndexedSeq

object LinearSeq

object Seq

object Buffer

object IndexedBuffer

object IndexedSeq

object Seq

object IndexedSeq

object LinearSeq

object Seq

trait StrictOptimizedSeqFactory[CC]

object List

object Queue

object Vector

object ArrayBuffer

object ArrayDeque

object ListBuffer

object Queue

object Stack

object AnyAccumulator

object View

trait LinearSeqOps[A, CC, C]

trait LinearSeq[A]

trait StrictOptimizedLinearSeqOps[A, CC, C]

trait Map[K, V]

class AbstractMap[K, V]

trait DefaultMap[K, V]

trait SeqMap[K, V]

trait SortedMap[K, V]

trait Seq[A]

class AbstractSeq[A]

trait IndexedSeq[A]

trait Set[A]

trait Set[A]

class AbstractSet[A]

class BitSet

class BitSet1

class BitSet2

class BitSetN

class HashSet[A]

class ListSet[A]

class Set1[A]

class Set2[A]

class Set3[A]

class Set4[A]

class SortedMapOps.this.ImmutableKeySortedSet

class TreeSet[A]

class Enumeration.this.ValueSet

trait SortedSet[A]

trait Set[A]

class AbstractSet[A]

class BitSet

class HashSet[A]

class LinkedHashSet[A]

class TreeSet[A]

trait SortedSet[A]

class AbstractSet[A]

trait SortedSet[A]

trait BitSet

trait SetOps[A, CC, C]

trait SetOps[A, CC, C]

trait SortedSetOps[A, CC, C]

trait StrictOptimizedSortedSetOps[A, CC, C]

trait StrictOptimizedSetOps[A, CC, C]

trait SetOps[A, CC, C]

trait SortedSetOps[A, CC, C]

trait SortedSetOps[A, CC, C]

trait BitSetOps[C]

trait SortedSetFactoryDefaults[A, CC, WithFilterCC]

trait StrictOptimizedSortedSetOps[A, CC, C]

trait StrictOptimizedSetOps[A, CC, C]

trait SortedMapFactoryDefaults[K, V, CC, WithFilterCC, UnsortedCC]

trait SortedMapOps[K, V, CC, C]

trait StrictOptimizedSortedMapOps[K, V, CC, C]

trait StrictOptimizedSeqOps[A, CC, C]

trait ArrayDequeOps[A, CC, C]

class Enumeration.this.Value

class Enumeration.this.Val

trait PartialOrdering[T]

trait Ordering[T]

object DeadlineIsOrdered

object DurationIsOrdered

object FiniteDurationIsOrdered

object Enumeration.this.ValueOrdering

trait Numeric[T]

trait Fractional[T]

trait BigDecimalIsFractional

object BigDecimalIsFractional

trait DoubleIsFractional

object DoubleIsFractional

trait FloatIsFractional

object FloatIsFractional

trait Integral[T]

trait BigDecimalAsIfIntegral

object BigDecimalAsIfIntegral

trait BigIntIsIntegral

object BigIntIsIntegral

trait ByteIsIntegral

object ByteIsIntegral

trait CharIsIntegral

object CharIsIntegral

trait IntIsIntegral

object IntIsIntegral

trait LongIsIntegral

object LongIsIntegral

trait ShortIsIntegral

object ShortIsIntegral

trait BigDecimalIsConflicted

trait BigDecimalOrdering

object BigDecimal

trait BigIntOrdering

object BigInt

trait BooleanOrdering

object Boolean

trait ByteOrdering

object Byte

trait CachedReverse[T]

object Int

trait CharOrdering

object Char

trait IeeeOrdering

object IeeeOrdering

trait TotalOrdering

object DeprecatedDoubleOrdering

object TotalOrdering

trait IeeeOrdering

object IeeeOrdering

trait TotalOrdering

object DeprecatedFloatOrdering

object TotalOrdering

trait IntOrdering

trait LongOrdering

object Long

trait OptionOrdering[T]

trait ShortOrdering

object Short

trait StringOrdering

object String

trait SymbolOrdering

object Symbol

trait UnitOrdering

object Unit

trait ReferenceWrapper[T]

class PhantomReference[T]

class SoftReference[T]

class WeakReference[T]

class Enumeration

object RoundingMode
Show all
Self type: Pure

Marker trait for capabilities that can be safely shared in a concurrent context.

SharedCapability has a formal meaning when Capture Checking is turned on. During separation checking, shared capabilities are not taken into account.

Attributes

Source: package.scala
Supertypes: trait Classifier

trait Capability

class Object

trait Matchable

class Any
Known subtypes: trait Control

class Label[T]

class CanThrow[E]

Experimental classlikes

Carrier trait for capture set type parameters.

Attributes

Experimental: true
Source: package.scala
Supertypes: class Any

Attributes

Companion: trait
Experimental: true
Source: package.scala
Supertypes: class Object

trait Matchable

class Any
Self type: Contains.type

A type constraint expressing that the capture set C needs to contain the capability R

Type parameters

C: the capture set that must contain the capability R
R: the singleton type of the capability that must be present in C

Attributes

Companion: object
Experimental: true
Source: package.scala
Supertypes: class Object

trait Matchable

class Any

Marker trait for capabilities that should only be used by one concurrent process at a given time. For example, write-access to a shared mutable buffer.

ExclusiveCapability has a formal meaning when Capture Checking is turned on. During separation checking, exclusive usage of marked capabilities will be enforced.

Attributes

Experimental: true
Source: package.scala
Supertypes: trait Capability

class Object

trait Matchable

class Any
Known subtypes: trait Unscoped

trait Mutable

trait Var[T]

Attributes

Experimental: true
Source: package.scala
Supertypes: trait Unscoped

trait Classifier

trait ExclusiveCapability

trait Capability

trait Stateful

class Object

trait Matchable

class Any
Show all
Known subtypes: trait Var[T]

Marker trait for classes that can consult and change the global program state. These classes typically contain mutable variables and/or update methods.

Attributes

Experimental: true
Source: package.scala
Supertypes: class Object

trait Matchable

class Any
Known subtypes: trait Mutable

trait Var[T]

Marker trait for classes that are not subject to scoping restrictions of captured capabilities.

Attributes

Experimental: true
Source: package.scala
Supertypes: trait Classifier

trait ExclusiveCapability

trait Capability

class Object

trait Matchable

class Any
Show all
Known subtypes: trait Mutable

trait Var[T]

The universal capture reference.

Attributes

Experimental: true
Source: package.scala
Supertypes: trait Capability

class Object

trait Matchable

class Any
Self type: any.type

An annotation for definitions that are assumed to be accessible from code compiled under safe mode.

Attributes

Experimental: true
Source: package.scala
Supertypes: trait ConstantAnnotation

trait StaticAnnotation

class Annotation

class Object

trait Matchable

class Any
Show all

The universal result capture reference.

Attributes

Experimental: true
Source: package.scala
Supertypes: trait Capability

class Object

trait Matchable

class Any
Self type: fresh.type

Attributes

Experimental: true
Source: package.scala
Supertypes: class Object

trait Matchable

class Any
Self type: internal.type

An annotation for definitions that should not be accessible from code compiled under safe mode.

Attributes

Experimental: true
Source: package.scala
Supertypes: trait ConstantAnnotation

trait StaticAnnotation

class Annotation

class Object

trait Matchable

class Any
Show all

Was an annotation on capset parameters C stating that the method's body does not have C in its use-set. C might be accessed under a box in the method or in the result type of the method. Now deprecated and with no effect.

Attributes

Deprecated: true
Experimental: true
Source: package.scala
Supertypes: trait StaticAnnotation

class Annotation

class Object

trait Matchable

class Any

Attributes

Experimental: true
Source: package.scala
Supertypes: class Object

trait Matchable

class Any
Self type: unsafe.type

Types

Attributes

Source: package.scala

Attributes

Source: package.scala

Value members

Experimental methods

A wrapper that strips all covariant capture sets from Mutable types in the result of pure operation op, turning them into immutable types. Array[?] is also included since it counts as a Mutable type for separation checking.

Attributes

Experimental: true
Source: package.scala

In this article

Generated with