chisel6.4.0 < Back


# Packages

-  package root
  Definition Classes
    root
-  package chisel3

  This package contains the main chisel3 API.

  This package contains the main chisel3 API.

  Definition Classes
    root
-  package aop
  Definition Classes
    chisel3
-  package choice

  This package contains Chisel language definitions for describing configuration options and their accepted values.

  This package contains Chisel language definitions for describing configuration options and their accepted values.

  Definition Classes
    chisel3
-  package connectable
  Definition Classes
    chisel3
-  package experimental

  Package for experimental features, which may have their API changed, be removed, etc.

  Package for experimental features, which may have their API changed, be removed, etc.

  Because its contents won't necessarily have the same level of stability and support as non-experimental, you must explicitly import this package to use its contents.

  Definition Classes
    chisel3
-  package interface
  Definition Classes
    chisel3
-  package ltl
  Definition Classes
    chisel3
-  package naming
  Definition Classes
    chisel3
-  package probe
  Definition Classes
    chisel3
-  package properties

  The properties package includes functionality related to non-hardware data.

  The properties package includes functionality related to non-hardware data.

  This entire package is currently very experimental, so expect some rough edges and rapid API evolution.

  Definition Classes
    chisel3
-  package reflect
  Definition Classes
    chisel3
-  package simulator
  Definition Classes
    chisel3
-  package stage
  Definition Classes
    chisel3
-  package std
  Definition Classes
    chisel3
-  package testers

  The testers package provides the basic interface for chisel testers.

  The testers package provides the basic interface for chisel testers.

  Definition Classes
    chisel3
-  package util

  The util package provides extensions to core chisel for common hardware components and utility functions

  The util package provides extensions to core chisel for common hardware components and utility functions

  Definition Classes
    chisel3
- ActualDirection
- Aggregate
- AliasedAggregateFieldException
- AsyncReset
- AutoClonetypeException
- BiConnectException
- Binary
- BindingException
- Bits
- Bits
- BlackBox
- Bool
- Bool
- BoolFactory
- BuildInfo
- Bundle
- Character
- ChiselEnum
- ChiselException
- Clock
- Const
- Data
- Decimal
- Disable
- DontCare
- Element
- EnumType
- ExpectedAnnotatableException
- ExpectedChiselTypeException
- ExpectedHardwareException
- FirrtlFormat
- FixedIOBaseModule
- FixedIOExtModule
- FixedIORawModule
- FlatIO
- Flipped
- FullName
- HasTarget
- Hexadecimal
- IO
- IgnoreSeqInBundle
- ImplicitClock
- ImplicitReset
- Input
- InstanceId
- InternalErrorException
- KnownWidth
- Mem
- MemBase
- MixedDirectionAggregateException
- Module
- ModuleAspect
- MonoConnectException
- Mux
- Name
- Num
- NumObject
- Output
- PString
- Percent
- Printable
- PrintableHelper
- Printables
- RawModule
- RebindingException
- Record
- Reg
- RegInit
- RegNext
- RequireAsyncReset
- RequireSyncReset
- Reset
- ResetType
- SInt
- SInt
- SIntFactory
- SourceInfoDoc
- SpecifiedDirection
- SyncReadMem
- UInt
- UInt
- UIntFactory
- UnknownWidth
- Vec
- Vec
- VecFactory
- VecInit
- VecLike
- VerifPrintMacrosDoc
- VerificationStatement
- WhenContext
- Width
- Wire
- WireDefault
- WireFactory
- WireInit
- assert
- assume
- chiselTypeOf
- cover
- dontTouch
- emitVerilog
- fromBigIntToLiteral
- fromBooleanToLiteral
- fromIntToLiteral
- fromIntToWidth
- fromLongToLiteral
- fromStringToLiteral
- getVerilogString
- layer
- printf
- stop
- suppressEnumCastWarning
- when
- withClock
- withClockAndReset
- withDisable
- withReset
- withoutIO

c

chisel3

# Vec

###

#### sealed class Vec[T <: Data] extends Aggregate with VecLike[T]

A vector (array) of Data elements. Provides hardware versions of various collection transformation functions found in software array implementations.

Careful consideration should be given over the use of Vec vs Seq or some other Scala collection. In general Vec only needs to be used when there is a need to express the hardware collection in a Reg or IO Bundle or when access to elements of the array is indexed via a hardware signal.

Example of indexing into a Vec using a hardware address and where the Vec is defined in an IO Bundle

    val io = IO(new Bundle {
      val in = Input(Vec(20, UInt(16.W)))
      val addr = Input(UInt(5.W))
      val out = Output(UInt(16.W))
    })
    io.out := io.in(io.addr)

T

  type of elements

Source
  Aggregate.scala
Note

  - when multiple conflicting assignments are performed on a Vec element, the last one takes effect (unlike Mem, where the result is undefined)
  - Vecs, unlike classes in Scala's collection library, are propagated intact to FIRRTL as a vector type, which may make debugging easier

Linear Supertypes
VecLike[T], IndexedSeq[T], IndexedSeqOps[T, IndexedSeq, IndexedSeq[T]], IndexedSeq[T], IndexedSeqOps[T, [_]IndexedSeq[_], IndexedSeq[T]], Seq[T], SeqOps[T, [_]IndexedSeq[_], IndexedSeq[T]], Seq[T], Equals, SeqOps[T, [_]IndexedSeq[_], IndexedSeq[T]], PartialFunction[Int, T], (Int) => T, Iterable[T], Iterable[T], IterableFactoryDefaults[T, [x]IndexedSeq[x]], IterableOps[T, [_]IndexedSeq[_], IndexedSeq[T]], IterableOnceOps[T, [_]IndexedSeq[_], IndexedSeq[T]], IterableOnce[T], Aggregate, Data, SourceInfoDoc, NamedComponent, HasId, InstanceId, AnyRef, Any
Type Hierarchy

Ordering

1. Grouped
2. Alphabetic
3. By Inheritance

Inherited

1. Vec
2. VecLike
3. IndexedSeq
4. IndexedSeqOps
5. IndexedSeq
6. IndexedSeqOps
7. Seq
8. SeqOps
9. Seq
10. Equals
11. SeqOps
12. PartialFunction
13. Function1
14. Iterable
15. Iterable
16. IterableFactoryDefaults
17. IterableOps
18. IterableOnceOps
19. IterableOnce
20. Aggregate
21. Data
22. SourceInfoDoc
23. NamedComponent
24. HasId
25. InstanceId
26. AnyRef
27. Any

Implicitly

1. by UnliftOps
2. by iterableOnceExtensionMethods
3. by DataEquality
4. by toConnectableDefault
5. by ConnectableVecDefault
6. by ConnectableDefault
7. by any2stringadd
8. by StringFormat
9. by Ensuring
10. by ArrowAssoc

1. Hide All
2. Show All

Visibility

1. Public
2. Protected

### Value Members

1.  final def !=(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
2.  final def ##: Int
   Definition Classes
     AnyRef → Any
3.  def +(other: String): String
   Implicit
     This member is added by an implicit conversion from Vec[T] toany2stringadd[Vec[T]] performed by method any2stringadd in scala.Predef.
   Definition Classes
     any2stringadd
4.  final def ++[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]
   Definition Classes
     IterableOps
   Annotations
     @inline()
5.  final def ++:[B >: T](prefix: IterableOnce[B]): IndexedSeq[B]
   Definition Classes
     SeqOps → IterableOps
   Annotations
     @inline()
6.  final def +:[B >: T](elem: B): IndexedSeq[B]
   Definition Classes
     SeqOps
   Annotations
     @inline()
7.  def ->[B](y: B): (Vec[T], B)
   Implicit
     This member is added by an implicit conversion from Vec[T] toArrowAssoc[Vec[T]] performed by method ArrowAssoc in scala.Predef.This conversion will take place only if T is a subclass of Option[Nothing] (T <: Option[Nothing]).
   Definition Classes
     ArrowAssoc
   Annotations
     @inline()
8.  def :#=(producer: Seq[T])(implicit sourceInfo: SourceInfo): Unit

   The "mono-direction connection operator", aka the "coercion operator".

   The "mono-direction connection operator", aka the "coercion operator".

   For `consumer :#= producer`, all leaf members of consumer (regardless of relative flip) are driven by the corresponding leaf members of producer (regardless of relative flip)

   Identical to calling :<= and :>=, but swapping consumer/producer for :>= (order is irrelevant), e.g.: consumer :<= producer producer :>= consumer

   Symbol reference:

   - ':' is the consumer side
   - '=' is the producer side
   - '#' means to ignore flips, always drive from producer to consumer

   The following restrictions apply:

   - The Chisel type of consumer and producer must be the "same shape" recursively:
     - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
     - All vector types are the same length
     - All bundle types have the same member names, but the flips of members can be different between producer and consumer
   - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs.

   Additional notes: - Connecting two `util.DecoupledIO`'s would connect `bits`, `valid`, AND `ready` from producer to consumer (despite `ready` being flipped) - Functionally equivalent to chisel3.:=, but different than Chisel.:=

   producer

     the right-hand-side of the connection, all members will be driving, none will be driven-to

   Implicit
     This member is added by an implicit conversion from Vec[T] toConnectableVecDefault[T] performed by method ConnectableVecDefault in chisel3.Data.This conversion will take place only if T is a subclass of Data (T <: Data).
   Definition Classes
     ConnectableVecOperators
9.  final def :#=[S <: Data](producer: connectable.Connectable[S])(implicit evidence: =:=[Vec[T], S], sourceInfo: SourceInfo): Unit

   The "mono-direction connection operator", aka the "coercion operator".

   The "mono-direction connection operator", aka the "coercion operator".

   For `consumer :#= producer`, all leaf members of consumer (regardless of relative flip) are driven by the corresponding leaf members of producer (regardless of relative flip)

   Identical to calling :<= and :>=, but swapping consumer/producer for :>= (order is irrelevant), e.g.: consumer :<= producer producer :>= consumer

   Symbol reference:

   - ':' is the consumer side
   - '=' is the producer side
   - '#' means to ignore flips, always drive from producer to consumer

   The following restrictions apply:

   - The Chisel type of consumer and producer must be the "same shape" recursively:
     - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
     - All vector types are the same length
     - All bundle types have the same member names, but the flips of members can be different between producer and consumer
   - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs.

   Additional notes: - Connecting two `util.DecoupledIO`'s would connect `bits`, `valid`, AND `ready` from producer to consumer (despite `ready` being flipped) - Functionally equivalent to chisel3.:=, but different than Chisel.:=

   producer

     the right-hand-side of the connection, all members will be driving, none will be driven-to

   Implicit
     This member is added by an implicit conversion from Vec[T] toConnectableDefault[Vec[T]] performed by method ConnectableDefault in chisel3.Data.
   Definition Classes
     ConnectableOpExtension
10.  final def :#=[S <: Data](lProducer: => S)(implicit evidence: =:=[Vec[T], S], sourceInfo: SourceInfo): Unit

    The "mono-direction connection operator", aka the "coercion operator".

    The "mono-direction connection operator", aka the "coercion operator".

    For `consumer :#= producer`, all leaf members of consumer (regardless of relative flip) are driven by the corresponding leaf members of producer (regardless of relative flip)

    Identical to calling :<= and :>=, but swapping consumer/producer for :>= (order is irrelevant), e.g.: consumer :<= producer producer :>= consumer

    Symbol reference:

    - ':' is the consumer side
    - '=' is the producer side
    - '#' means to ignore flips, always drive from producer to consumer

    The following restrictions apply:

    - The Chisel type of consumer and producer must be the "same shape" recursively:
      - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
      - All vector types are the same length
      - All bundle types have the same member names, but the flips of members can be different between producer and consumer
    - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs.

    Additional notes: - Connecting two `util.DecoupledIO`'s would connect `bits`, `valid`, AND `ready` from producer to consumer (despite `ready` being flipped) - Functionally equivalent to chisel3.:=, but different than Chisel.:=

    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectableDefault[Vec[T]] performed by method ConnectableDefault in chisel3.Data.
    Definition Classes
      ConnectableOpExtension
11.  final def :+[B >: T](elem: B): IndexedSeq[B]
    Definition Classes
      SeqOps
    Annotations
      @inline()
12.  final def :++[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]
    Definition Classes
      SeqOps
    Annotations
      @inline()
13.  def :<=(producer: Seq[T])(implicit sourceInfo: SourceInfo): Unit

    The "aligned connection operator" between a producer and consumer.

    The "aligned connection operator" between a producer and consumer.

    For `consumer :<= producer`, each of `consumer`'s leaf members which are aligned with respect to `consumer` are driven from the corresponding `producer` leaf member. Only `consumer`'s leaf/branch alignments influence the connection.

    Symbol reference:

    - ':' is the consumer side
    - '=' is the producer side
    - '<' means to connect from producer to consumer

    The following restrictions apply:

    - The Chisel type of consumer and producer must be the "same shape" recursively:
      - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
      - All vector types are the same length
      - All bundle types have the same member names, but the flips of members can be different between producer and consumer
    - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs.

    Additional notes:

    - Connecting two `util.DecoupledIO`'s would connect `bits` and `valid` from producer to consumer, but leave `ready` unconnected
    producer

      the right-hand-side of the connection; will always drive leaf connections, and never get driven by leaf connections ("aligned connection")

    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectableVecDefault[T] performed by method ConnectableVecDefault in chisel3.Data.This conversion will take place only if T is a subclass of Data (T <: Data).
    Definition Classes
      ConnectableVecOperators
14.  final def :<=(producer: DontCare.type)(implicit sourceInfo: SourceInfo): Unit

    The "aligned connection operator" between a producer and consumer.

    The "aligned connection operator" between a producer and consumer.

    For `consumer :<= producer`, each of `consumer`'s leaf members which are aligned with respect to `consumer` are driven from the corresponding `producer` leaf member. Only `consumer`'s leaf/branch alignments influence the connection.

    Symbol reference:

    - ':' is the consumer side
    - '=' is the producer side
    - '<' means to connect from producer to consumer

    The following restrictions apply:

    - The Chisel type of consumer and producer must be the "same shape" recursively:
      - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
      - All vector types are the same length
      - All bundle types have the same member names, but the flips of members can be different between producer and consumer
    - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs.

    Additional notes:

    - Connecting two `util.DecoupledIO`'s would connect `bits` and `valid` from producer to consumer, but leave `ready` unconnected
    producer

      the right-hand-side of the connection; will always drive leaf connections, and never get driven by leaf connections ("aligned connection")

    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectableDefault[Vec[T]] performed by method ConnectableDefault in chisel3.Data.
    Definition Classes
      ConnectableOpExtension
15.  final def :<=[S <: Data](producer: connectable.Connectable[S])(implicit evidence: =:=[Vec[T], S], sourceInfo: SourceInfo): Unit

    The "aligned connection operator" between a producer and consumer.

    The "aligned connection operator" between a producer and consumer.

    For `consumer :<= producer`, each of `consumer`'s leaf members which are aligned with respect to `consumer` are driven from the corresponding `producer` leaf member. Only `consumer`'s leaf/branch alignments influence the connection.

    Symbol reference:

    - ':' is the consumer side
    - '=' is the producer side
    - '<' means to connect from producer to consumer

    The following restrictions apply:

    - The Chisel type of consumer and producer must be the "same shape" recursively:
      - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
      - All vector types are the same length
      - All bundle types have the same member names, but the flips of members can be different between producer and consumer
    - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs.

    Additional notes:

    - Connecting two `util.DecoupledIO`'s would connect `bits` and `valid` from producer to consumer, but leave `ready` unconnected
    producer

      the right-hand-side of the connection; will always drive leaf connections, and never get driven by leaf connections ("aligned connection")

    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectableDefault[Vec[T]] performed by method ConnectableDefault in chisel3.Data.
    Definition Classes
      ConnectableOpExtension
16.  final def :<=[S <: Data](lProducer: => S)(implicit evidence: =:=[Vec[T], S], sourceInfo: SourceInfo): Unit

    The "aligned connection operator" between a producer and consumer.

    The "aligned connection operator" between a producer and consumer.

    For `consumer :<= producer`, each of `consumer`'s leaf members which are aligned with respect to `consumer` are driven from the corresponding `producer` leaf member. Only `consumer`'s leaf/branch alignments influence the connection.

    Symbol reference:

    - ':' is the consumer side
    - '=' is the producer side
    - '<' means to connect from producer to consumer

    The following restrictions apply:

    - The Chisel type of consumer and producer must be the "same shape" recursively:
      - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
      - All vector types are the same length
      - All bundle types have the same member names, but the flips of members can be different between producer and consumer
    - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs.

    Additional notes:

    - Connecting two `util.DecoupledIO`'s would connect `bits` and `valid` from producer to consumer, but leave `ready` unconnected
    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectableDefault[Vec[T]] performed by method ConnectableDefault in chisel3.Data.
    Definition Classes
      ConnectableOpExtension
17.  def :<>=(producer: Seq[T])(implicit sourceInfo: SourceInfo): Unit

    The "bi-direction connection operator", aka the "tur-duck-en operator"

    The "bi-direction connection operator", aka the "tur-duck-en operator"

    For `consumer :<>= producer`, both producer and consumer leafs could be driving or be driven-to. The `consumer`'s members aligned w.r.t. `consumer` will be driven by corresponding members of `producer`; the `producer`'s members flipped w.r.t. `producer` will be driven by corresponding members of `consumer`

    Identical to calling `:<=` and `:>=` in sequence (order is irrelevant), e.g. `consumer :<= producer` then `consumer :>= producer`

    Symbol reference:

    - ':' is the consumer side
    - '=' is the producer side
    - '<' means to connect from producer to consumer
    - '>' means to connect from consumer to producer

    The following restrictions apply:

    - The Chisel type of consumer and producer must be the "same shape" recursively:
      - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
      - All vector types are the same length
      - All bundle types have the same member names, but the flips of members can be different between producer and consumer
    - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs. - An additional type restriction is that all relative orientations of `consumer` and `producer` must match exactly.

    Additional notes:

    - Connecting two wires of `util.DecoupledIO` chisel type would connect `bits` and `valid` from producer to consumer, and `ready` from consumer to producer.
    - If the types of consumer and producer also have identical relative flips, then we can emit FIRRTL.<= as it is a stricter version of chisel3.:<>=
    - "turk-duck-en" is a dish where a turkey is stuffed with a duck, which is stuffed with a chicken; `:<>=` is a `:=` stuffed with a `<>`
    producer

      the right-hand-side of the connection

    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectableVecDefault[T] performed by method ConnectableVecDefault in chisel3.Data.This conversion will take place only if T is a subclass of Data (T <: Data).
    Definition Classes
      ConnectableVecOperators
18.  final def :<>=(producer: DontCare.type)(implicit sourceInfo: SourceInfo): Unit

    The "bi-direction connection operator", aka the "tur-duck-en operator"

    The "bi-direction connection operator", aka the "tur-duck-en operator"

    For `consumer :<>= producer`, both producer and consumer leafs could be driving or be driven-to. The `consumer`'s members aligned w.r.t. `consumer` will be driven by corresponding members of `producer`; the `producer`'s members flipped w.r.t. `producer` will be driven by corresponding members of `consumer`

    Identical to calling `:<=` and `:>=` in sequence (order is irrelevant), e.g. `consumer :<= producer` then `consumer :>= producer`

    Symbol reference:

    - ':' is the consumer side
    - '=' is the producer side
    - '<' means to connect from producer to consumer
    - '>' means to connect from consumer to producer

    The following restrictions apply:

    - The Chisel type of consumer and producer must be the "same shape" recursively:
      - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
      - All vector types are the same length
      - All bundle types have the same member names, but the flips of members can be different between producer and consumer
    - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs. - An additional type restriction is that all relative orientations of `consumer` and `producer` must match exactly.

    Additional notes:

    - Connecting two wires of `util.DecoupledIO` chisel type would connect `bits` and `valid` from producer to consumer, and `ready` from consumer to producer.
    - If the types of consumer and producer also have identical relative flips, then we can emit FIRRTL.<= as it is a stricter version of chisel3.:<>=
    - "turk-duck-en" is a dish where a turkey is stuffed with a duck, which is stuffed with a chicken; `:<>=` is a `:=` stuffed with a `<>`
    producer

      the right-hand-side of the connection

    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectableDefault[Vec[T]] performed by method ConnectableDefault in chisel3.Data.
    Definition Classes
      ConnectableOpExtension
19.  final def :<>=[S <: Data](producer: connectable.Connectable[S])(implicit evidence: =:=[Vec[T], S], sourceInfo: SourceInfo): Unit

    The "bi-direction connection operator", aka the "tur-duck-en operator"

    The "bi-direction connection operator", aka the "tur-duck-en operator"

    For `consumer :<>= producer`, both producer and consumer leafs could be driving or be driven-to. The `consumer`'s members aligned w.r.t. `consumer` will be driven by corresponding members of `producer`; the `producer`'s members flipped w.r.t. `producer` will be driven by corresponding members of `consumer`

    Identical to calling `:<=` and `:>=` in sequence (order is irrelevant), e.g. `consumer :<= producer` then `consumer :>= producer`

    Symbol reference:

    - ':' is the consumer side
    - '=' is the producer side
    - '<' means to connect from producer to consumer
    - '>' means to connect from consumer to producer

    The following restrictions apply:

    - The Chisel type of consumer and producer must be the "same shape" recursively:
      - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
      - All vector types are the same length
      - All bundle types have the same member names, but the flips of members can be different between producer and consumer
    - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs. - An additional type restriction is that all relative orientations of `consumer` and `producer` must match exactly.

    Additional notes:

    - Connecting two wires of `util.DecoupledIO` chisel type would connect `bits` and `valid` from producer to consumer, and `ready` from consumer to producer.
    - If the types of consumer and producer also have identical relative flips, then we can emit FIRRTL.<= as it is a stricter version of chisel3.:<>=
    - "turk-duck-en" is a dish where a turkey is stuffed with a duck, which is stuffed with a chicken; `:<>=` is a `:=` stuffed with a `<>`
    producer

      the right-hand-side of the connection

    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectableDefault[Vec[T]] performed by method ConnectableDefault in chisel3.Data.
    Definition Classes
      ConnectableOpExtension
20.  final def :<>=[S <: Data](lProducer: => S)(implicit evidence: =:=[Vec[T], S], sourceInfo: SourceInfo): Unit

    The "bi-direction connection operator", aka the "tur-duck-en operator"

    The "bi-direction connection operator", aka the "tur-duck-en operator"

    For `consumer :<>= producer`, both producer and consumer leafs could be driving or be driven-to. The `consumer`'s members aligned w.r.t. `consumer` will be driven by corresponding members of `producer`; the `producer`'s members flipped w.r.t. `producer` will be driven by corresponding members of `consumer`

    Identical to calling `:<=` and `:>=` in sequence (order is irrelevant), e.g. `consumer :<= producer` then `consumer :>= producer`

    Symbol reference:

    - ':' is the consumer side
    - '=' is the producer side
    - '<' means to connect from producer to consumer
    - '>' means to connect from consumer to producer

    The following restrictions apply:

    - The Chisel type of consumer and producer must be the "same shape" recursively:
      - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
      - All vector types are the same length
      - All bundle types have the same member names, but the flips of members can be different between producer and consumer
    - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs. - An additional type restriction is that all relative orientations of `consumer` and `producer` must match exactly.

    Additional notes:

    - Connecting two wires of `util.DecoupledIO` chisel type would connect `bits` and `valid` from producer to consumer, and `ready` from consumer to producer.
    - If the types of consumer and producer also have identical relative flips, then we can emit FIRRTL.<= as it is a stricter version of chisel3.:<>=
    - "turk-duck-en" is a dish where a turkey is stuffed with a duck, which is stuffed with a chicken; `:<>=` is a `:=` stuffed with a `<>`
    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectableDefault[Vec[T]] performed by method ConnectableDefault in chisel3.Data.
    Definition Classes
      ConnectableOpExtension
21.  def :=(that: Vec[T])(implicit sourceInfo: SourceInfo): Unit

    "The strong connect operator", assigning elements in this Vec from elements in a Vec.

    "The strong connect operator", assigning elements in this Vec from elements in a Vec.

    For chisel3._, this operator is mono-directioned; all sub-elements of `this` will be driven by sub-elements of `that`.

    - Equivalent to `this :#= that`

    For Chisel._, this operator connections bi-directionally via emitting the FIRRTL.<=

    - Equivalent to `this :<>= that`, with the additional restriction that the relative bundle field flips must match
    Note

      This is necessary in Aggregate, rather than relying on Data.:=, due to supporting the Seq

      ,

      the length of this Vec must match the length of the input Vec

22.  def :=(that: Seq[T])(implicit sourceInfo: SourceInfo): Unit

    "The strong connect operator", assigning elements in this Vec from elements in a Seq.

    "The strong connect operator", assigning elements in this Vec from elements in a Seq.

    For chisel3._, this operator is mono-directioned; all sub-elements of `this` will be driven by sub-elements of `that`.

    - Equivalent to `this :#= that`

    For Chisel._, this operator connections bi-directionally via emitting the FIRRTL.<=

    - Equivalent to `this :<>= that`
    Note

      the length of this Vec must match the length of the input Seq

23.  final def :=(that: => Data)(implicit sourceInfo: SourceInfo): Unit

    The "strong connect" operator.

    The "strong connect" operator.

    For chisel3._, this operator is mono-directioned; all sub-elements of `this` will be driven by sub-elements of `that`.

    - Equivalent to `this :#= that`

    For Chisel._, this operator connections bi-directionally via emitting the FIRRTL.<=

    - Equivalent to `this :<>= that`
    that

      the Data to connect from

    Definition Classes
      Data
24.  def :>=(producer: Seq[T])(implicit sourceInfo: SourceInfo): Unit

    The "flipped connection operator", or the "backpressure connection operator" between a producer and consumer.

    The "flipped connection operator", or the "backpressure connection operator" between a producer and consumer.

    For `consumer :>= producer`, each of `producer`'s leaf members which are flipped with respect to `producer` are driven from the corresponding consumer leaf member Only `producer`'s leaf/branch alignments influence the connection.

    Symbol reference:

    - ':' is the consumer side
    - '=' is the producer side
    - '>' means to connect from consumer to producer

    The following restrictions apply:

    - The Chisel type of consumer and producer must be the "same shape" recursively:
      - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
      - All vector types are the same length
      - All bundle types have the same member names, but the flips of members can be different between producer and consumer
    - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs.

    Additional notes:

    - Connecting two `util.DecoupledIO`'s would connect `ready` from consumer to producer, but leave `bits` and `valid` unconnected
    producer

      the right-hand-side of the connection; will always be driven by leaf connections, and never drive leaf connections ("flipped connection")

    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectableVecDefault[T] performed by method ConnectableVecDefault in chisel3.Data.This conversion will take place only if T is a subclass of Data (T <: Data).
    Definition Classes
      ConnectableVecOperators
25.  final def :>=(producer: DontCare.type)(implicit sourceInfo: SourceInfo): Unit

    The "flipped connection operator", or the "backpressure connection operator" between a producer and consumer.

    The "flipped connection operator", or the "backpressure connection operator" between a producer and consumer.

    For `consumer :>= producer`, each of `producer`'s leaf members which are flipped with respect to `producer` are driven from the corresponding consumer leaf member Only `producer`'s leaf/branch alignments influence the connection.

    Symbol reference:

    - ':' is the consumer side
    - '=' is the producer side
    - '>' means to connect from consumer to producer

    The following restrictions apply:

    - The Chisel type of consumer and producer must be the "same shape" recursively:
      - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
      - All vector types are the same length
      - All bundle types have the same member names, but the flips of members can be different between producer and consumer
    - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs.

    Additional notes:

    - Connecting two `util.DecoupledIO`'s would connect `ready` from consumer to producer, but leave `bits` and `valid` unconnected
    producer

      the right-hand-side of the connection; will always be driven by leaf connections, and never drive leaf connections ("flipped connection")

    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectableDefault[Vec[T]] performed by method ConnectableDefault in chisel3.Data.
    Definition Classes
      ConnectableOpExtension
26.  final def :>=[S <: Data](producer: connectable.Connectable[S])(implicit evidence: =:=[Vec[T], S], sourceInfo: SourceInfo): Unit

    The "flipped connection operator", or the "backpressure connection operator" between a producer and consumer.

    The "flipped connection operator", or the "backpressure connection operator" between a producer and consumer.

    For `consumer :>= producer`, each of `producer`'s leaf members which are flipped with respect to `producer` are driven from the corresponding consumer leaf member Only `producer`'s leaf/branch alignments influence the connection.

    Symbol reference:

    - ':' is the consumer side
    - '=' is the producer side
    - '>' means to connect from consumer to producer

    The following restrictions apply:

    - The Chisel type of consumer and producer must be the "same shape" recursively:
      - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
      - All vector types are the same length
      - All bundle types have the same member names, but the flips of members can be different between producer and consumer
    - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs.

    Additional notes:

    - Connecting two `util.DecoupledIO`'s would connect `ready` from consumer to producer, but leave `bits` and `valid` unconnected
    producer

      the right-hand-side of the connection; will always be driven by leaf connections, and never drive leaf connections ("flipped connection")

    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectableDefault[Vec[T]] performed by method ConnectableDefault in chisel3.Data.
    Definition Classes
      ConnectableOpExtension
27.  final def :>=[S <: Data](lProducer: => S)(implicit evidence: =:=[Vec[T], S], sourceInfo: SourceInfo): Unit

    The "flipped connection operator", or the "backpressure connection operator" between a producer and consumer.

    The "flipped connection operator", or the "backpressure connection operator" between a producer and consumer.

    For `consumer :>= producer`, each of `producer`'s leaf members which are flipped with respect to `producer` are driven from the corresponding consumer leaf member Only `producer`'s leaf/branch alignments influence the connection.

    Symbol reference:

    - ':' is the consumer side
    - '=' is the producer side
    - '>' means to connect from consumer to producer

    The following restrictions apply:

    - The Chisel type of consumer and producer must be the "same shape" recursively:
      - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
      - All vector types are the same length
      - All bundle types have the same member names, but the flips of members can be different between producer and consumer
    - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs.

    Additional notes:

    - Connecting two `util.DecoupledIO`'s would connect `ready` from consumer to producer, but leave `bits` and `valid` unconnected
    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectableDefault[Vec[T]] performed by method ConnectableDefault in chisel3.Data.
    Definition Classes
      ConnectableOpExtension
28.  def <>(that: Vec[T])(implicit sourceInfo: SourceInfo): Unit

    The "bulk connect operator", assigning elements in this Vec from elements in a Vec.

    The "bulk connect operator", assigning elements in this Vec from elements in a Vec.

    For chisel3._, uses the `chisel3.internal.BiConnect` algorithm; sub-elements of `that` may end up driving sub-elements of `this`

    - See docs/src/explanations/connection-operators.md for details

    For Chisel._, emits the FIRRTL.<- operator

    - Equivalent to `this :<>= that` without the restrictions that bundle field names and vector sizes must match
    that

      the Vec to connect from

    Note

      This is necessary in Aggregate, rather than relying on Data.<>, due to supporting the Seq

      ,

      the length of this Vec and that Vec must match

29.  def <>(that: Seq[T])(implicit sourceInfo: SourceInfo): Unit

    The "bulk connect operator", assigning elements in this Vec from elements in a Seq.

    The "bulk connect operator", assigning elements in this Vec from elements in a Seq.

    For chisel3._, uses the `chisel3.internal.BiConnect` algorithm; sub-elements of `that` may end up driving sub-elements of `this`

    - Complicated semantics, will likely be deprecated in the future

    For Chisel._, emits the FIRRTL.<- operator

    - Equivalent to `this :<>= that` but bundle field names and vector sizes do not have to match
    that

      the Seq to connect from

    Note

      the length of this Vec and that Seq must match

30.  final def <>(that: => Data)(implicit sourceInfo: SourceInfo): Unit

    The "bulk connect operator", assigning elements in this Vec from elements in a Vec.

    The "bulk connect operator", assigning elements in this Vec from elements in a Vec.

    For chisel3._, uses the `chisel3.internal.BiConnect` algorithm; sub-elements of that`may end up driving sub-elements of` this``

    - Complicated semantics, hard to write quickly, will likely be deprecated in the future

    For Chisel._, emits the FIRRTL.<- operator

    - Equivalent to `this :<>= that` without the restrictions that bundle field names and vector sizes must match
    that

      the Data to connect from

    Definition Classes
      Data
31.  final def ==(arg0: Any): Boolean
    Definition Classes
      AnyRef → Any
32.  def ===(rhs: Vec[T]): Bool

    Dynamic recursive equality operator for generic Data

    Dynamic recursive equality operator for generic Data

    rhs

      a hardware Data to compare `lhs` to

    returns

      a hardware Bool asserted if `lhs` is equal to `rhs`

    Implicit
      This member is added by an implicit conversion from Vec[T] toDataEquality[Vec[T]] performed by method DataEquality in chisel3.Data.
    Definition Classes
      DataEquality
    Exceptions thrown

      `ChiselException` when `lhs` and `rhs` are different types during elaboration time

33.  final def addString(b: StringBuilder): b.type
    Definition Classes
      IterableOnceOps
    Annotations
      @inline()
34.  final def addString(b: StringBuilder, sep: String): b.type
    Definition Classes
      IterableOnceOps
    Annotations
      @inline()
35.  def addString(b: StringBuilder, start: String, sep: String, end: String): b.type
    Definition Classes
      IterableOnceOps
36.  def andThen[C](k: PartialFunction[T, C]): PartialFunction[Int, C]
    Definition Classes
      PartialFunction
37.  def andThen[C](k: (T) => C): PartialFunction[Int, C]
    Definition Classes
      PartialFunction → Function1
38.  def appended[B >: T](elem: B): IndexedSeq[B]
    Definition Classes
      SeqOps
39.  def appendedAll[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]
    Definition Classes
      SeqOps
40.  def apply(idx: Int): T

    Creates a statically indexed read or write accessor into the array.

    Creates a statically indexed read or write accessor into the array.

    Definition Classes
      Vec → SeqOps → Function1
41.  macro def apply(p: UInt): T

    Creates a dynamically indexed read or write accessor into the array.

    Creates a dynamically indexed read or write accessor into the array.

    Definition Classes
      VecLike
42.  def applyOrElse[A1 <: Int, B1 >: T](x: A1, default: (A1) => B1): B1
    Definition Classes
      PartialFunction
43.  def applyPreferredMaxLength: Int
    Attributes
      protected
    Definition Classes
      IndexedSeq
44.  def as[S <: Data](implicit ev: <:<[Vec[T], S]): connectable.Connectable[S]

    Static cast to a super type

    Static cast to a super type

    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
    Definition Classes
      Connectable
45.  final def asInstanceOf[T0]: T0
    Definition Classes
      Any
46.  macro def asTypeOf[T <: Data](that: T): T

    Does a reinterpret cast of the bits in this node into the format that provides.

    Does a reinterpret cast of the bits in this node into the format that provides. Returns a new Wire of that type. Does not modify existing nodes.

    x.asTypeOf(that) performs the inverse operation of x := that.toBits.

    Definition Classes
      Data
    Note

      bit widths are NOT checked, may pad or drop bits from input

      ,

      that should have known widths

47.  final macro def asUInt: UInt

    Reinterpret cast to UInt.

    Reinterpret cast to UInt.

    Definition Classes
      Data
    Note

      value not guaranteed to be preserved: for example, a SInt of width 3 and value -1 (0b111) would become an UInt with value 7

      ,

      Aggregates are recursively packed with the first element appearing in the least-significant bits of the result.

48.  def autoSeed(name: String): Vec.this.type

    Takes the last seed suggested.

    Takes the last seed suggested. Multiple calls to this function will take the last given seed, unless this HasId is a module port (see overridden method in Data.scala).

    If the final computed name conflicts with the final name of another signal, the final name may get uniquified by appending a digit at the end of the name.

    Is a lower priority than suggestName, in that regardless of whether autoSeed was called, suggestName will always take precedence if it was called.

    returns

      this object

    Definition Classes
      Data → HasId
49.  val base: Vec[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
    Definition Classes
      Connectable
50.  def binding: Option[Binding]
    Attributes
      protected[chisel3]
    Definition Classes
      Data
51.  def binding_=(target: Binding): Unit
    Attributes
      protected
    Definition Classes
      Data
52.  def canEqual(that: Any): Boolean
    Definition Classes
      IndexedSeq → Seq → Equals
53.  def circuitName: String
    Definition Classes
      HasId
54.  def className: String
    Attributes
      protected[this]
    Definition Classes
      Iterable
55.  def clone(): AnyRef
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws(classOf[java.lang.CloneNotSupportedException]) @native()
56.  def cloneType: Vec.this.type

    Internal API; Chisel users should look at chisel3.chiselTypeOf(...).

    Internal API; Chisel users should look at chisel3.chiselTypeOf(...).

    cloneType must be defined for any Chisel object extending Data. It is responsible for constructing a basic copy of the object being cloned.

    returns

      a copy of the object.

    Definition Classes
      Vec → Data
57.  final def coll: Vec.this.type
    Attributes
      protected
    Definition Classes
      Iterable → IterableOps
58.  def collect[B](pf: PartialFunction[T, B]): IndexedSeq[B]
    Definition Classes
      IterableOps → IterableOnceOps
59.  def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
    Definition Classes
      IterableOnceOps
60.  def combinations(n: Int): Iterator[IndexedSeq[T]]
    Definition Classes
      SeqOps
61.  def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, T]
    Definition Classes
      PartialFunction
62.  def compose[A](g: (A) => Int): (A) => T
    Definition Classes
      Function1
    Annotations
      @unspecialized()
63.  final def concat[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]
    Definition Classes
      SeqOps → IterableOps
    Annotations
      @inline()
64.  macro def contains(x: T)(implicit ev: <:<[T, UInt]): Bool

    Outputs true if the vector contains at least one element equal to x (using the === operator).

    Outputs true if the vector contains at least one element equal to x (using the === operator).

    Definition Classes
      VecLike
65.  def contains[A1 >: T](elem: A1): Boolean
    Definition Classes
      SeqOps
66.  def containsAFlipped: Boolean
    Definition Classes
      Vec → Data
67.  def containsSlice[B >: T](that: Seq[B]): Boolean
    Definition Classes
      SeqOps
68.  def copyToArray[B >: T](xs: Array[B], start: Int, len: Int): Int
    Definition Classes
      IterableOnceOps
69.  def copyToArray[B >: T](xs: Array[B], start: Int): Int
    Definition Classes
      IterableOnceOps
    Annotations
      @deprecatedOverriding()
70.  def copyToArray[B >: T](xs: Array[B]): Int
    Definition Classes
      IterableOnceOps
    Annotations
      @deprecatedOverriding()
71.  def corresponds[B](that: Seq[B])(p: (T, B) => Boolean): Boolean
    Definition Classes
      SeqOps
72.  def corresponds[B](that: IterableOnce[B])(p: (T, B) => Boolean): Boolean
    Definition Classes
      IterableOnceOps
73.  macro def count(p: (T) => Bool): UInt

    Outputs the number of elements for which p is true.

    Outputs the number of elements for which p is true.

    Definition Classes
      VecLike
74.  def count(p: (T) => Boolean): Int
    Definition Classes
      IterableOnceOps
75.  def diff[B >: T](that: Seq[B]): IndexedSeq[T]
    Definition Classes
      SeqOps
76.  def distinct: IndexedSeq[T]
    Definition Classes
      SeqOps
77.  def distinctBy[B](f: (T) => B): IndexedSeq[T]
    Definition Classes
      SeqOps
78.  def do_apply(p: UInt)(implicit sourceInfo: SourceInfo): T

    Definition Classes
      Vec → VecLike
79.  def do_asTypeOf[T <: Data](that: T)(implicit sourceInfo: SourceInfo): T

    Definition Classes
      Data
80.  def do_asUInt(implicit sourceInfo: SourceInfo): UInt

    Definition Classes
      Data
81.  def do_contains(x: T)(implicit sourceInfo: SourceInfo, ev: <:<[T, UInt]): Bool

    Definition Classes
      VecLike
82.  def do_count(p: (T) => Bool)(implicit sourceInfo: SourceInfo): UInt

    Definition Classes
      VecLike
83.  def do_exists(p: (T) => Bool)(implicit sourceInfo: SourceInfo): Bool

    Definition Classes
      VecLike
84.  def do_forall(p: (T) => Bool)(implicit sourceInfo: SourceInfo): Bool

    Definition Classes
      VecLike
85.  def do_indexWhere(p: (T) => Bool)(implicit sourceInfo: SourceInfo): UInt

    Definition Classes
      VecLike
86.  def do_lastIndexWhere(p: (T) => Bool)(implicit sourceInfo: SourceInfo): UInt

    Definition Classes
      VecLike
87.  def do_onlyIndexWhere(p: (T) => Bool)(implicit sourceInfo: SourceInfo): UInt

    Definition Classes
      VecLike
88.  def do_reduceTree(redOp: (T, T) => T, layerOp: (T) => T = (x: T) => x)(implicit sourceInfo: SourceInfo): T
89.  def drop(n: Int): IndexedSeq[T]
    Definition Classes
      IndexedSeqOps → IterableOps → IterableOnceOps
90.  def dropRight(n: Int): IndexedSeq[T]
    Definition Classes
      IndexedSeqOps → IterableOps
91.  def dropWhile(p: (T) => Boolean): IndexedSeq[T]
    Definition Classes
      IterableOps → IterableOnceOps
92.  def elementWise: ElementWiseExtractor[Int, T]
    Definition Classes
      PartialFunction
93.  def empty: IndexedSeq[T]
    Definition Classes
      IterableFactoryDefaults → IterableOps
94.  def endsWith[B >: T](that: Iterable[B]): Boolean
    Definition Classes
      SeqOps
95.  def ensuring(cond: (Vec[T]) => Boolean, msg: => Any): Vec[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toEnsuring[Vec[T]] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
96.  def ensuring(cond: (Vec[T]) => Boolean): Vec[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toEnsuring[Vec[T]] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
97.  def ensuring(cond: Boolean, msg: => Any): Vec[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toEnsuring[Vec[T]] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
98.  def ensuring(cond: Boolean): Vec[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toEnsuring[Vec[T]] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
99.  final def eq(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
100.  def equals(that: Any): Boolean
     Definition Classes
       VecLike → HasId → Seq → Equals → AnyRef → Any
101.  def exclude(members: (Vec[T]) => Data*): connectable.Connectable[Vec[T]]

     Select members of base to exclude

     Select members of base to exclude

     members

       functions given the base return a member to exclude

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
102.  def exclude: connectable.Connectable[Vec[T]]

     Adds base to excludes

     Adds base to excludes

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
103.  def excludeAs[S <: Data](members: (Vec[T]) => Data*)(implicit ev: <:<[Vec[T], S]): connectable.Connectable[S]

     Select members of base to exclude and static cast to a new type

     Select members of base to exclude and static cast to a new type

     members

       functions given the base return a member to exclude

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
104.  def excludeEach[S <: Data](pf: PartialFunction[Data, Seq[Data]])(implicit ev: <:<[Vec[T], S]): connectable.Connectable[S]

     Programmatically select members of base to exclude and static cast to a new type

     Programmatically select members of base to exclude and static cast to a new type

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
105.  def excludeProbes: connectable.Connectable[Vec[T]]

     Exclude probes

     Exclude probes

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
106.  macro def exists(p: (T) => Bool): Bool

     Outputs true if p outputs true for at least one element.

     Outputs true if p outputs true for at least one element.

     Definition Classes
       VecLike
107.  def exists(p: (T) => Boolean): Boolean
     Definition Classes
       IterableOnceOps
108.  def filter(pred: (T) => Boolean): IndexedSeq[T]
     Definition Classes
       IterableOps → IterableOnceOps
109.  def filterNot(pred: (T) => Boolean): IndexedSeq[T]
     Definition Classes
       IterableOps → IterableOnceOps
110.  def finalize(): Unit
     Attributes
       protected[lang]
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.Throwable])
111.  def find(p: (T) => Boolean): Option[T]
     Definition Classes
       IterableOnceOps
112.  def findLast(p: (T) => Boolean): Option[T]
     Definition Classes
       SeqOps
113.  def flatMap[B](f: (T) => IterableOnce[B]): IndexedSeq[B]
     Definition Classes
       IterableOps → IterableOnceOps
114.  def flatten[B](implicit asIterable: (T) => IterableOnce[B]): IndexedSeq[B]
     Definition Classes
       IterableOps → IterableOnceOps
115.  def fold[A1 >: T](z: A1)(op: (A1, A1) => A1): A1
     Definition Classes
       IterableOnceOps
116.  def foldLeft[B](z: B)(op: (B, T) => B): B
     Definition Classes
       IterableOnceOps
117.  def foldRight[B](z: B)(op: (T, B) => B): B
     Definition Classes
       IndexedSeqOps → IterableOnceOps
118.  macro def forall(p: (T) => Bool): Bool

     Outputs true if p outputs true for every element.

     Outputs true if p outputs true for every element.

     Definition Classes
       VecLike
119.  def forall(p: (T) => Boolean): Boolean
     Definition Classes
       IterableOnceOps
120.  def foreach[U](f: (T) => U): Unit
     Definition Classes
       IterableOnceOps
121.  def fromSpecific(coll: IterableOnce[T]): IndexedSeq[T]
     Attributes
       protected
     Definition Classes
       IterableFactoryDefaults → IterableOps
122.  final def getClass(): Class[_ <: AnyRef]
     Definition Classes
       AnyRef → Any
     Annotations
       @native()
123.  def getElements: Seq[Data]

     Returns a Seq of the immediate contents of this Aggregate, in order.

     Returns a Seq of the immediate contents of this Aggregate, in order.

     Definition Classes
       Vec → Aggregate
124.  final def getWidth: Int

     Returns the width, in bits, if currently known.

     Returns the width, in bits, if currently known.

     Definition Classes
       Data
125.  def groupBy[K](f: (T) => K): Map[K, IndexedSeq[T]]
     Definition Classes
       IterableOps
126.  def groupMap[K, B](key: (T) => K)(f: (T) => B): Map[K, IndexedSeq[B]]
     Definition Classes
       IterableOps
127.  def groupMapReduce[K, B](key: (T) => K)(f: (T) => B)(reduce: (B, B) => B): Map[K, B]
     Definition Classes
       IterableOps
128.  def grouped(size: Int): Iterator[IndexedSeq[T]]
     Definition Classes
       IterableOps
129.  def hasSeed: Boolean

     returns

       Whether either autoName or suggestName has been called

     Definition Classes
       HasId
130.  def hashCode(): Int
     Definition Classes
       VecLike → HasId → Seq → AnyRef → Any
131.  def head: T
     Definition Classes
       IndexedSeqOps → IterableOps
132.  def headOption: Option[T]
     Definition Classes
       IndexedSeqOps → IterableOps
133.  def indexOf[B >: T](elem: B): Int
     Definition Classes
       SeqOps
     Annotations
       @deprecatedOverriding()
134.  def indexOf[B >: T](elem: B, from: Int): Int
     Definition Classes
       SeqOps
135.  def indexOfSlice[B >: T](that: Seq[B]): Int
     Definition Classes
       SeqOps
     Annotations
       @deprecatedOverriding()
136.  def indexOfSlice[B >: T](that: Seq[B], from: Int): Int
     Definition Classes
       SeqOps
137.  macro def indexWhere(p: (T) => Bool): UInt

     Outputs the index of the first element for which p outputs true.

     Outputs the index of the first element for which p outputs true.

     Definition Classes
       VecLike
138.  def indexWhere(p: (T) => Boolean): Int
     Definition Classes
       SeqOps
     Annotations
       @deprecatedOverriding()
139.  def indexWhere(p: (T) => Boolean, from: Int): Int
     Definition Classes
       SeqOps
140.  def indices: Range
     Definition Classes
       SeqOps
141.  def init: IndexedSeq[T]
     Definition Classes
       IterableOps
142.  def inits: Iterator[IndexedSeq[T]]
     Definition Classes
       IterableOps
143.  def instanceName: String
     Definition Classes
       HasId → InstanceId
144.  def intersect[B >: T](that: Seq[B]): IndexedSeq[T]
     Definition Classes
       SeqOps
145.  def isDefinedAt(idx: Int): Boolean
     Definition Classes
       SeqOps
146.  def isEmpty: Boolean
     Definition Classes
       SeqOps → IterableOnceOps
147.  final def isInstanceOf[T0]: Boolean
     Definition Classes
       Any
148.  def isLit: Boolean
     Definition Classes
       Data
149.  def isTraversableAgain: Boolean
     Definition Classes
       IterableOps → IterableOnceOps
150.  final def isWidthKnown: Boolean

     Returns whether the width is currently known.

     Returns whether the width is currently known.

     Definition Classes
       Data
151.  def iterableFactory: SeqFactory[IndexedSeq]
     Definition Classes
       IndexedSeq → IndexedSeq → Seq → Seq → Iterable → Iterable → IterableOps
152.  def iterator: Iterator[T]
     Definition Classes
       IndexedSeqOps → IterableOnce
153.  def knownSize: Int
     Definition Classes
       IndexedSeqOps → IterableOnce
154.  def last: T
     Definition Classes
       IndexedSeqOps → IterableOps
155.  def lastIndexOf[B >: T](elem: B, end: Int): Int
     Definition Classes
       SeqOps
156.  def lastIndexOfSlice[B >: T](that: Seq[B]): Int
     Definition Classes
       SeqOps
     Annotations
       @deprecatedOverriding()
157.  def lastIndexOfSlice[B >: T](that: Seq[B], end: Int): Int
     Definition Classes
       SeqOps
158.  macro def lastIndexWhere(p: (T) => Bool): UInt

     Outputs the index of the last element for which p outputs true.

     Outputs the index of the last element for which p outputs true.

     Definition Classes
       VecLike
159.  def lastIndexWhere(p: (T) => Boolean): Int
     Definition Classes
       SeqOps
     Annotations
       @deprecatedOverriding()
160.  def lastIndexWhere(p: (T) => Boolean, end: Int): Int
     Definition Classes
       SeqOps
161.  def lastOption: Option[T]
     Definition Classes
       IterableOps
162.  def lazyZip[B](that: Iterable[B]): LazyZip2[T, B, Vec.this.type]
     Definition Classes
       Iterable
163.  val length: Int
     Definition Classes
       Vec → SeqOps
164.  final def lengthCompare(that: Iterable[_]): Int
     Definition Classes
       IndexedSeqOps → SeqOps
165.  final def lengthCompare(len: Int): Int
     Definition Classes
       IndexedSeqOps → SeqOps
166.  final def lengthIs: SizeCompareOps
     Definition Classes
       SeqOps
     Annotations
       @inline()
167.  def lift: (Int) => Option[T]
     Definition Classes
       PartialFunction
168.  def litOption: Option[BigInt]

     Return an Aggregate's literal value if it is a literal, None otherwise.

     Return an Aggregate's literal value if it is a literal, None otherwise. If any element of the aggregate is not a literal (or DontCare), the result isn't a literal.

     returns

       an Aggregate's literal value if it is a literal, None otherwise.

     Definition Classes
       Aggregate → Data
     Note

       DontCare is allowed and will be replaced with 0. Use litValue to disallow DontCare.

169.  def litValue: BigInt

     Return an Aggregate's literal value if it is a literal, otherwise an exception is thrown.

     Return an Aggregate's literal value if it is a literal, otherwise an exception is thrown. If any element of the aggregate is not a literal with a defined width, the result isn't a literal.

     returns

       an Aggregate's literal value if it is a literal, exception otherwise.

     Definition Classes
       Aggregate → Data
170.  def map[B](f: (T) => B): IndexedSeq[B]
     Definition Classes
       IndexedSeqOps → IterableOps → IterableOnceOps
171.  def max[B >: T](implicit ord: Ordering[B]): T
     Definition Classes
       IterableOnceOps
172.  def maxBy[B](f: (T) => B)(implicit ord: Ordering[B]): T
     Definition Classes
       IterableOnceOps
173.  def maxByOption[B](f: (T) => B)(implicit ord: Ordering[B]): Option[T]
     Definition Classes
       IterableOnceOps
174.  def maxOption[B >: T](implicit ord: Ordering[B]): Option[T]
     Definition Classes
       IterableOnceOps
175.  def min[B >: T](implicit ord: Ordering[B]): T
     Definition Classes
       IterableOnceOps
176.  def minBy[B](f: (T) => B)(implicit ord: Ordering[B]): T
     Definition Classes
       IterableOnceOps
177.  def minByOption[B](f: (T) => B)(implicit ord: Ordering[B]): Option[T]
     Definition Classes
       IterableOnceOps
178.  def minOption[B >: T](implicit ord: Ordering[B]): Option[T]
     Definition Classes
       IterableOnceOps
179.  final def mkString: String
     Definition Classes
       IterableOnceOps
     Annotations
       @inline()
180.  final def mkString(sep: String): String
     Definition Classes
       IterableOnceOps
     Annotations
       @inline()
181.  final def mkString(start: String, sep: String, end: String): String
     Definition Classes
       IterableOnceOps
182.  final def ne(arg0: AnyRef): Boolean
     Definition Classes
       AnyRef
183.  def newSpecificBuilder: Builder[T, IndexedSeq[T]]
     Attributes
       protected
     Definition Classes
       IterableFactoryDefaults → IterableOps
184.  def nonEmpty: Boolean
     Definition Classes
       IterableOnceOps
     Annotations
       @deprecatedOverriding()
185.  def notWaivedOrSqueezedOrExcluded: Boolean

     True if no members are waived or squeezed or excluded

     True if no members are waived or squeezed or excluded

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
186.  final def notify(): Unit
     Definition Classes
       AnyRef
     Annotations
       @native()
187.  final def notifyAll(): Unit
     Definition Classes
       AnyRef
     Annotations
       @native()
188.  def occCounts[B](sq: Seq[B]): Map[B, Int]
     Attributes
       protected[collection]
     Definition Classes
       SeqOps
189.  macro def onlyIndexWhere(p: (T) => Bool): UInt

     Outputs the index of the element for which p outputs true, assuming that the there is exactly one such element.

     Outputs the index of the element for which p outputs true, assuming that the there is exactly one such element.

     The implementation may be more efficient than a priority mux, but incorrect results are possible if there is not exactly one true element.

     Definition Classes
       VecLike
     Note

       the assumption that there is only one element for which p outputs true is NOT checked (useful in cases where the condition doesn't always hold, but the results are not used in those cases)

190.  def orElse[A1 <: Int, B1 >: T](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
     Definition Classes
       PartialFunction
191.  def padTo[B >: T](len: Int, elem: B): IndexedSeq[B]
     Definition Classes
       SeqOps
192.  def parentModName: String
     Definition Classes
       HasId → InstanceId
193.  def parentPathName: String
     Definition Classes
       HasId → InstanceId
194.  def partition(p: (T) => Boolean): (IndexedSeq[T], IndexedSeq[T])
     Definition Classes
       IterableOps
195.  def partitionMap[A1, A2](f: (T) => Either[A1, A2]): (IndexedSeq[A1], IndexedSeq[A2])
     Definition Classes
       IterableOps
196.  def patch[B >: T](from: Int, other: IterableOnce[B], replaced: Int): IndexedSeq[B]
     Definition Classes
       SeqOps
197.  def pathName: String
     Definition Classes
       HasId → InstanceId
198.  def permutations: Iterator[IndexedSeq[T]]
     Definition Classes
       SeqOps
199.  def prepended[B >: T](elem: B): IndexedSeq[B]
     Definition Classes
       IndexedSeqOps → SeqOps
200.  def prependedAll[B >: T](prefix: IterableOnce[B]): IndexedSeq[B]
     Definition Classes
       SeqOps
201.  def product[B >: T](implicit num: Numeric[B]): B
     Definition Classes
       IterableOnceOps
202.  def reduce[B >: T](op: (B, B) => B): B
     Definition Classes
       IterableOnceOps
203.  def reduceLeft[B >: T](op: (B, T) => B): B
     Definition Classes
       IterableOnceOps
204.  def reduceLeftOption[B >: T](op: (B, T) => B): Option[B]
     Definition Classes
       IterableOnceOps
205.  def reduceOption[B >: T](op: (B, B) => B): Option[B]
     Definition Classes
       IterableOnceOps
206.  def reduceRight[B >: T](op: (T, B) => B): B
     Definition Classes
       IterableOnceOps
207.  def reduceRightOption[B >: T](op: (T, B) => B): Option[B]
     Definition Classes
       IterableOnceOps
208.  macro def reduceTree(redOp: (T, T) => T, layerOp: (T) => T): T

     A reduce operation in a tree like structure instead of sequentially

     A reduce operation in a tree like structure instead of sequentially

     Example:

     1. A pipelined adder tree

            val sumOut = inputNums.reduceTree(
              (a: T, b: T) => RegNext(a + b),
              (a: T) => RegNext(a)
            )

209.  macro def reduceTree(redOp: (T, T) => T): T

     A reduce operation in a tree like structure instead of sequentially

     A reduce operation in a tree like structure instead of sequentially

     Example:

     1. An adder tree

            val sumOut = inputNums.reduceTree((a: T, b: T) => (a + b))

210.  def reverse: IndexedSeq[T]
     Definition Classes
       IndexedSeqOps → SeqOps
211.  def reverseIterator: Iterator[T]
     Definition Classes
       IndexedSeqOps → SeqOps
212.  def reversed: Iterable[T]
     Attributes
       protected
     Definition Classes
       IndexedSeqOps → IterableOnceOps
213.  def runWith[U](action: (T) => U): (Int) => Boolean
     Definition Classes
       PartialFunction
214.  def sameElements[B >: T](o: IterableOnce[B]): Boolean
     Definition Classes
       IndexedSeq → SeqOps
215.  def scan[B >: T](z: B)(op: (B, B) => B): IndexedSeq[B]
     Definition Classes
       IterableOps
216.  def scanLeft[B](z: B)(op: (B, T) => B): IndexedSeq[B]
     Definition Classes
       IterableOps → IterableOnceOps
217.  def scanRight[B](z: B)(op: (T, B) => B): IndexedSeq[B]
     Definition Classes
       IterableOps
218.  def search[B >: T](elem: B, from: Int, to: Int)(implicit ord: Ordering[B]): SearchResult
     Definition Classes
       IndexedSeqOps → SeqOps
219.  def search[B >: T](elem: B)(implicit ord: Ordering[B]): SearchResult
     Definition Classes
       IndexedSeqOps → SeqOps
220.  def segmentLength(p: (T) => Boolean, from: Int): Int
     Definition Classes
       SeqOps
221.  final def segmentLength(p: (T) => Boolean): Int
     Definition Classes
       SeqOps
222.  final def size: Int
     Definition Classes
       SeqOps → IterableOnceOps
223.  final def sizeCompare(that: Iterable[_]): Int
     Definition Classes
       SeqOps → IterableOps
224.  final def sizeCompare(otherSize: Int): Int
     Definition Classes
       SeqOps → IterableOps
225.  final def sizeIs: SizeCompareOps
     Definition Classes
       IterableOps
     Annotations
       @inline()
226.  def slice(from: Int, until: Int): IndexedSeq[T]
     Definition Classes
       IndexedSeqOps → IndexedSeqOps → IterableOps → IterableOnceOps
227.  def sliding(size: Int, step: Int): Iterator[IndexedSeq[T]]
     Definition Classes
       IterableOps
228.  def sliding(size: Int): Iterator[IndexedSeq[T]]
     Definition Classes
       IterableOps
229.  def sortBy[B](f: (T) => B)(implicit ord: Ordering[B]): IndexedSeq[T]
     Definition Classes
       SeqOps
230.  def sortWith(lt: (T, T) => Boolean): IndexedSeq[T]
     Definition Classes
       SeqOps
231.  def sorted[B >: T](implicit ord: Ordering[B]): IndexedSeq[T]
     Definition Classes
       SeqOps
232.  def span(p: (T) => Boolean): (IndexedSeq[T], IndexedSeq[T])
     Definition Classes
       IterableOps → IterableOnceOps
233.  def splitAt(n: Int): (IndexedSeq[T], IndexedSeq[T])
     Definition Classes
       IterableOps → IterableOnceOps
234.  def squeeze(members: (Vec[T]) => Data*): connectable.Connectable[Vec[T]]

     Select members of base to squeeze

     Select members of base to squeeze

     members

       functions given the base return a member to squeeze

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
235.  def squeeze: connectable.Connectable[Vec[T]]

     Adds base to squeezes

     Adds base to squeezes

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
236.  def squeezeAll: connectable.Connectable[Vec[T]]

     Squeeze all members of base

     Squeeze all members of base

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
237.  def squeezeAllAs[S <: Data](implicit ev: <:<[Vec[T], S]): connectable.Connectable[S]

     Squeeze all members of base and upcast to super type

     Squeeze all members of base and upcast to super type

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
238.  def squeezeEach[S <: Data](pf: PartialFunction[Data, Seq[Data]]): connectable.Connectable[Vec[T]]

     Programmatically select members of base to squeeze

     Programmatically select members of base to squeeze

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
239.  def startsWith[B >: T](that: IterableOnce[B], offset: Int): Boolean
     Definition Classes
       SeqOps
240.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S with EfficientSplit
     Definition Classes
       IndexedSeqOps → IterableOnce
241.  def stringPrefix: String
     Attributes
       protected[this]
     Definition Classes
       IndexedSeq → Seq → Iterable
242.  def suggestName(seed: => String): Vec.this.type

     Takes the first seed suggested.

     Takes the first seed suggested. Multiple calls to this function will be ignored. If the final computed name conflicts with another name, it may get uniquified by appending a digit at the end.

     Is a higher priority than `autoSeed`, in that regardless of whether `autoSeed` was called, suggestName will always take precedence.

     seed

       The seed for the name of this component

     returns

       this object

     Definition Classes
       HasId
243.  def sum[B >: T](implicit num: Numeric[B]): B
     Definition Classes
       IterableOnceOps
244.  final def synchronized[T0](arg0: => T0): T0
     Definition Classes
       AnyRef
245.  def tail: IndexedSeq[T]
     Definition Classes
       IterableOps
246.  def tails: Iterator[IndexedSeq[T]]
     Definition Classes
       IterableOps
247.  def take(n: Int): IndexedSeq[T]
     Definition Classes
       IndexedSeqOps → IterableOps → IterableOnceOps
248.  def takeRight(n: Int): IndexedSeq[T]
     Definition Classes
       IndexedSeqOps → IterableOps
249.  def takeWhile(p: (T) => Boolean): IndexedSeq[T]
     Definition Classes
       IterableOps → IterableOnceOps
250.  def tapEach[U](f: (T) => U): IndexedSeq[T]
     Definition Classes
       IterableOps → IterableOnceOps
251.  def to[C1](factory: Factory[T, C1]): C1
     Definition Classes
       IterableOnceOps
252.  final def toAbsoluteTarget: ReferenceTarget

     Returns a FIRRTL IsMember that refers to the absolute path to this object in the elaborated hardware graph

     Returns a FIRRTL IsMember that refers to the absolute path to this object in the elaborated hardware graph

     Definition Classes
       NamedComponent → InstanceId
253.  def toArray[B >: T](implicit arg0: ClassTag[B]): Array[B]
     Definition Classes
       IterableOnceOps
254.  final def toBuffer[B >: T]: Buffer[B]
     Definition Classes
       IterableOnceOps
     Annotations
       @inline()
255.  final def toIndexedSeq: IndexedSeq[T]
     Definition Classes
       IndexedSeq → IterableOnceOps
256.  def toList: List[T]
     Definition Classes
       IterableOnceOps
257.  def toMap[K, V](implicit ev: <:<[T, (K, V)]): Map[K, V]
     Definition Classes
       IterableOnceOps
258.  final def toNamed: ComponentName

     Returns a FIRRTL ComponentName that references this object

     Returns a FIRRTL ComponentName that references this object

     Definition Classes
       NamedComponent → InstanceId
     Note

       Should not be called until circuit elaboration is complete

259.  def toPrintable: Printable

     Default "pretty-print" implementation Analogous to printing a Seq Results in "Vec(elt0, elt1, ...)"

     Default "pretty-print" implementation Analogous to printing a Seq Results in "Vec(elt0, elt1, ...)"

     Definition Classes
       Vec → Data
260.  final def toRelativeTarget(root: Option[BaseModule]): ReferenceTarget

     Returns a FIRRTL ReferenceTarget that references this object, relative to an optional root.

     Returns a FIRRTL ReferenceTarget that references this object, relative to an optional root.

     If `root` is defined, the target is a hierarchical path starting from `root`.

     If `root` is not defined, the target is a hierarchical path equivalent to `toAbsoluteTarget`.

     Definition Classes
       NamedComponent
     Note

       If `root` is defined, and has not finished elaboration, this must be called within `atModuleBodyEnd`.

       ,

       The NamedComponent must be a descendant of `root`, if it is defined.

       ,

       This doesn't have special handling for Views.

261.  final def toSeq: Vec.this.type
     Definition Classes
       Seq → IterableOnceOps
262.  def toSet[B >: T]: Set[B]
     Definition Classes
       IterableOnceOps
263.  def toString(): String
     Definition Classes
       Vec → Seq → Function1 → Iterable → AnyRef → Any
264.  final def toTarget: ReferenceTarget

     Returns a FIRRTL ReferenceTarget that references this object

     Returns a FIRRTL ReferenceTarget that references this object

     Definition Classes
       NamedComponent → InstanceId
     Note

       Should not be called until circuit elaboration is complete

265.  def toVector: Vector[T]
     Definition Classes
       IterableOnceOps
266.  def transpose[B](implicit asIterable: (T) => Iterable[B]): IndexedSeq[IndexedSeq[B]]
     Definition Classes
       IterableOps
267.  def typeName: String

     Give this Vec a default, stable desired name using the supplied `Data` generator's `typeName`

     Give this Vec a default, stable desired name using the supplied `Data` generator's `typeName`

     Definition Classes
       Vec → Data
268.  def unapply(a: Int): Option[T]
     Definition Classes
       PartialFunction
269.  def unlift: PartialFunction[Int, B]
     Implicit
       This member is added by an implicit conversion from Vec[T] toUnliftOps[Int, B] performed by method UnliftOps in scala.Function1.This conversion will take place only if T is a subclass of Option[B] (T <: Option[B]).
     Definition Classes
       UnliftOps
270.  def unsafe: connectable.Connectable[Data]

     Connect to/from all fields regardless of Scala type, squeeze if necessary, and don't error if mismatched members

     Connect to/from all fields regardless of Scala type, squeeze if necessary, and don't error if mismatched members

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
271.  def unzip[A1, A2](implicit asPair: (T) => (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])
     Definition Classes
       IterableOps
272.  def unzip3[A1, A2, A3](implicit asTriple: (T) => (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])
     Definition Classes
       IterableOps
273.  def updated[B >: T](index: Int, elem: B): IndexedSeq[B]
     Definition Classes
       SeqOps
274.  def view: IndexedSeqView[T]
     Definition Classes
       IndexedSeqOps → SeqOps → IterableOps
275.  final def wait(): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException])
276.  final def wait(arg0: Long, arg1: Int): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException])
277.  final def wait(arg0: Long): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException]) @native()
278.  def waive(members: (Vec[T]) => Data*): connectable.Connectable[Vec[T]]

     Select members of base to waive

     Select members of base to waive

     members

       functions given the base return a member to waive

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
279.  def waiveAll: connectable.Connectable[Vec[T]]

     Waive all members of base

     Waive all members of base

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
280.  def waiveAllAs[S <: Data](implicit ev: <:<[Vec[T], S]): connectable.Connectable[S]

     Waive all members of base and static cast to a new type

     Waive all members of base and static cast to a new type

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
281.  def waiveAs[S <: Data](members: (Vec[T]) => Data*)(implicit ev: <:<[Vec[T], S]): connectable.Connectable[S]

     Select members of base to waive and static cast to a new type

     Select members of base to waive and static cast to a new type

     members

       functions given the base return a member to waive

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
282.  def waiveEach[S <: Data](pf: PartialFunction[Data, Seq[Data]])(implicit ev: <:<[Vec[T], S]): connectable.Connectable[S]

     Programmatically select members of base to waive and static cast to a new type

     Programmatically select members of base to waive and static cast to a new type

     Implicit
       This member is added by an implicit conversion from Vec[T] toConnectable[Vec[T]] performed by method toConnectableDefault in chisel3.Data.
     Definition Classes
       Connectable
283.  final def widthOption: Option[Int]

     Returns Some(width) if the width is known, else None.

     Returns Some(width) if the width is known, else None.

     Definition Classes
       Data
284.  def withFilter(p: (T) => Boolean): WithFilter[T, [_]IndexedSeq[_]]
     Definition Classes
       IterableOps
285.  def zip[B](that: IterableOnce[B]): IndexedSeq[(T, B)]
     Definition Classes
       IterableOps
286.  def zipAll[A1 >: T, B](that: Iterable[B], thisElem: A1, thatElem: B): IndexedSeq[(A1, B)]
     Definition Classes
       IterableOps
287.  def zipWithIndex: IndexedSeq[(T, Int)]
     Definition Classes
       IterableOps → IterableOnceOps

### Shadowed Implicit Value Members

1.  def :#=(producer: DontCare.type)(implicit sourceInfo: SourceInfo): Unit

   The "mono-direction connection operator", aka the "coercion operator".

   The "mono-direction connection operator", aka the "coercion operator".

   For `consumer :#= producer`, all leaf members of consumer (regardless of relative flip) are driven by the corresponding leaf members of producer (regardless of relative flip)

   Identical to calling :<= and :>=, but swapping consumer/producer for :>= (order is irrelevant), e.g.: consumer :<= producer producer :>= consumer

   Symbol reference:

   - ':' is the consumer side
   - '=' is the producer side
   - '#' means to ignore flips, always drive from producer to consumer

   The following restrictions apply:

   - The Chisel type of consumer and producer must be the "same shape" recursively:
     - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
     - All vector types are the same length
     - All bundle types have the same member names, but the flips of members can be different between producer and consumer
   - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs.

   Additional notes: - Connecting two `util.DecoupledIO`'s would connect `bits`, `valid`, AND `ready` from producer to consumer (despite `ready` being flipped) - Functionally equivalent to chisel3.:=, but different than Chisel.:=

   producer

     the right-hand-side of the connection, all members will be driving, none will be driven-to

   Implicit
     This member is added by an implicit conversion from Vec[T] toConnectableVecDefault[T] performed by method ConnectableVecDefault in chisel3.Data.This conversion will take place only if T is a subclass of Data (T <: Data).
   Shadowing
     This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
     To access this member you can use a type ascription:

         (vec: ConnectableVecDefault[T]).:#=(producer)(sourceInfo)

   Definition Classes
     ConnectableVecOperators
2.  final def :#=(producer: DontCare.type)(implicit sourceInfo: SourceInfo): Unit

   The "mono-direction connection operator", aka the "coercion operator".

   The "mono-direction connection operator", aka the "coercion operator".

   For `consumer :#= producer`, all leaf members of consumer (regardless of relative flip) are driven by the corresponding leaf members of producer (regardless of relative flip)

   Identical to calling :<= and :>=, but swapping consumer/producer for :>= (order is irrelevant), e.g.: consumer :<= producer producer :>= consumer

   Symbol reference:

   - ':' is the consumer side
   - '=' is the producer side
   - '#' means to ignore flips, always drive from producer to consumer

   The following restrictions apply:

   - The Chisel type of consumer and producer must be the "same shape" recursively:
     - All ground types are the same (UInt and UInt are same, SInt and UInt are not), but widths can be different (implicit trunction/padding occurs)
     - All vector types are the same length
     - All bundle types have the same member names, but the flips of members can be different between producer and consumer
   - The leaf members that are ultimately assigned to, must be assignable. This means they cannot be module inputs or instance outputs.

   Additional notes: - Connecting two `util.DecoupledIO`'s would connect `bits`, `valid`, AND `ready` from producer to consumer (despite `ready` being flipped) - Functionally equivalent to chisel3.:=, but different than Chisel.:=

   producer

     the right-hand-side of the connection, all members will be driving, none will be driven-to

   Implicit
     This member is added by an implicit conversion from Vec[T] toConnectableDefault[Vec[T]] performed by method ConnectableDefault in chisel3.Data.
   Shadowing
     This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
     To access this member you can use a type ascription:

         (vec: ConnectableDefault[Vec[T]]).:#=(producer)(sourceInfo)

   Definition Classes
     ConnectableOpExtension

### Deprecated Value Members

1.  def /:[B](z: B)(op: (B, T) => B): B
   Implicit
     This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
   Shadowing
     This implicitly inherited member is shadowed by one or more members in this class.
     To access this member you can use a type ascription:

         (vec: IterableOnceExtensionMethods[T])./:(z)(op)

   Definition Classes
     IterableOnceExtensionMethods
   Annotations
     @deprecated @inline()
   Deprecated

     (Since version 2.13.0) Use .iterator.foldLeft instead

2.  final def /:[B](z: B)(op: (B, T) => B): B
   Definition Classes
     IterableOnceOps
   Annotations
     @deprecated @inline()
   Deprecated

     (Since version 2.13.0) Use foldLeft instead of /:

3.  def :\[B](z: B)(op: (T, B) => B): B
   Implicit
     This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
   Shadowing
     This implicitly inherited member is shadowed by one or more members in this class.
     To access this member you can use a type ascription:

         (vec: IterableOnceExtensionMethods[T]).:\(z)(op)

   Definition Classes
     IterableOnceExtensionMethods
   Annotations
     @deprecated @inline()
   Deprecated

     (Since version 2.13.0) Use .iterator.foldRight instead

4.  final def :\[B](z: B)(op: (T, B) => B): B
   Definition Classes
     IterableOnceOps
   Annotations
     @deprecated @inline()
   Deprecated

     (Since version 2.13.0) Use foldRight instead of :\

5.  def aggregate[B](z: => B)(seqop: (B, T) => B, combop: (B, B) => B): B
   Definition Classes
     IterableOnceOps
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) `aggregate` is not relevant for sequential collections. Use `foldLeft(z)(seqop)` instead.

6.  def collectFirst[B](f: PartialFunction[T, B]): Option[B]
   Implicit
     This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
   Shadowing
     This implicitly inherited member is shadowed by one or more members in this class.
     To access this member you can use a type ascription:

         (vec: IterableOnceExtensionMethods[T]).collectFirst(f)

   Definition Classes
     IterableOnceExtensionMethods
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Use .iterator.collectFirst(...) instead

7.  def companion: IterableFactory[[_]IndexedSeq[_]]
   Definition Classes
     IterableOps
   Annotations
     @deprecated @deprecatedOverriding() @inline()
   Deprecated

     (Since version 2.13.0) Use iterableFactory instead

8.  def copyToBuffer(dest: Buffer[T]): Unit
   Implicit
     This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
   Shadowing
     This implicitly inherited member is shadowed by one or more members in this class.
     To access this member you can use a type ascription:

         (vec: IterableOnceExtensionMethods[T]).copyToBuffer(dest)

   Definition Classes
     IterableOnceExtensionMethods
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Use .iterator.copyToBuffer(...) instead

9.  final def copyToBuffer[B >: T](dest: Buffer[B]): Unit
   Definition Classes
     IterableOnceOps
   Annotations
     @deprecated @inline()
   Deprecated

     (Since version 2.13.0) Use `dest ++= coll` instead

10.  def count(f: (T) => Boolean): Int
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).count(f)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.count(...) instead

11.  def exists(f: (T) => Boolean): Boolean
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).exists(f)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.exists(...) instead

12.  def filter(f: (T) => Boolean): Iterator[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).filter(f)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.filter(...) instead

13.  def find(p: (T) => Boolean): Option[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).find(p)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.find instead

14.  def flatMap[B](f: (T) => IterableOnce[B]): IterableOnce[B]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).flatMap(f)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.flatMap instead or consider requiring an Iterable

15.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).fold(z)(op)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.fold instead

16.  def foldLeft[B](z: B)(op: (B, T) => B): B
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).foldLeft(z)(op)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.13.0) Use .iterator.foldLeft instead

17.  def foldRight[B](z: B)(op: (T, B) => B): B
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).foldRight(z)(op)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.13.0) Use .iterator.foldRight instead

18.  def forall(f: (T) => Boolean): Boolean
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).forall(f)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.forall(...) instead

19.  def foreach[U](f: (T) => U): Unit
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).foreach(f)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.13.0) Use .iterator.foreach(...) instead

20.  def formatted(fmtstr: String): String
    Implicit
      This member is added by an implicit conversion from Vec[T] toStringFormat[Vec[T]] performed by method StringFormat in scala.Predef.
    Definition Classes
      StringFormat
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.12.16) Use `formatString.format(value)` instead of `value.formatted(formatString)`, or use the `f""` string interpolator. In Java 15 and later, `formatted` resolves to the new method in String which has reversed parameters.

21.  def hasDefiniteSize: Boolean
    Definition Classes
      IterableOnceOps
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Check .knownSize instead of .hasDefiniteSize for more actionable information (see scaladoc for details)

22.  def isEmpty: Boolean
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).isEmpty

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.isEmpty instead

23.  def map[B](f: (T) => B): IterableOnce[B]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).map(f)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.map instead or consider requiring an Iterable

24.  def max(implicit ord: Ordering[T]): T
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).max(ord)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.max instead

25.  def maxBy[B](f: (T) => B)(implicit cmp: Ordering[B]): T
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).maxBy(f)(cmp)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.maxBy(...) instead

26.  def min(implicit ord: Ordering[T]): T
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).min(ord)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.min instead

27.  def minBy[B](f: (T) => B)(implicit cmp: Ordering[B]): T
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).minBy(f)(cmp)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.minBy(...) instead

28.  def mkString: String
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).mkString

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.mkString instead

29.  def mkString(sep: String): String
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).mkString(sep)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.mkString instead

30.  def mkString(start: String, sep: String, end: String): String
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).mkString(start, sep, end)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.mkString instead

31.  def nonEmpty: Boolean
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).nonEmpty

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.nonEmpty instead

32.  final def prefixLength(p: (T) => Boolean): Int
    Definition Classes
      SeqOps
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.13.0) Use segmentLength instead of prefixLength

33.  def product(implicit num: Numeric[T]): T
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).product(num)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.product instead

34.  def reduce(f: (T, T) => T): T
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).reduce(f)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.reduce(...) instead

35.  def reduceLeft(f: (T, T) => T): T
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).reduceLeft(f)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.reduceLeft(...) instead

36.  def reduceLeftOption(f: (T, T) => T): Option[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).reduceLeftOption(f)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.reduceLeftOption(...) instead

37.  def reduceOption(f: (T, T) => T): Option[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).reduceOption(f)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.reduceOption(...) instead

38.  def reduceRight(f: (T, T) => T): T
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).reduceRight(f)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.reduceRight(...) instead

39.  def reduceRightOption(f: (T, T) => T): Option[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).reduceRightOption(f)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.reduceRightOption(...) instead

40.  final def repr: IndexedSeq[T]
    Definition Classes
      IterableOps
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use coll instead of repr in a collection implementation, use the collection value itself from the outside

41.  def reverseMap[B](f: (T) => B): IndexedSeq[B]
    Definition Classes
      SeqOps
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .reverseIterator.map(f).to(...) instead of .reverseMap(f)

42.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).sameElements(that)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.sameElements instead

43.  def seq: Vec.this.type
    Definition Classes
      Iterable
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Iterable.seq always returns the iterable itself

44.  def size: Int
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).size

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.size instead

45.  def sum(implicit num: Numeric[T]): T
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).sum(num)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.sum instead

46.  def to[C1](factory: Factory[T, C1]): C1
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).to(factory)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.to(factory) instead

47.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).toArray(arg0)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.toArray

48.  def toBuffer[B >: A]: Buffer[B]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).toBuffer

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.to(ArrayBuffer) instead

49.  def toIndexedSeq: IndexedSeq[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).toIndexedSeq

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.toIndexedSeq instead

50.  final def toIterable: Iterable[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).toIterable

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.13.0) Use .iterator.to(Iterable) instead

51.  final def toIterable: Vec.this.type
    Definition Classes
      Iterable → IterableOps
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.7) toIterable is internal and will be made protected; its name is similar to `toList` or `toSeq`, but it doesn't copy non-immutable collections

52.  def toIterator: Iterator[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).toIterator

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.13.0) Use .iterator instead

53.  final def toIterator: Iterator[T]
    Definition Classes
      IterableOnceOps
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.13.0) Use .iterator instead of .toIterator

54.  def toList: List[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).toList

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.to(List) instead

55.  def toMap[K, V](implicit ev: <:<[T, (K, V)]): Map[K, V]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).toMap(ev)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.to(Map) instead

56.  def toSeq: Seq[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).toSeq

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.13.0) Use .iterator.to(Seq) instead

57.  def toSet[B >: A]: Set[B]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).toSet

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.13.0) Use .iterator.to(Set) instead

58.  def toStream: Stream[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).toStream

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.13.0) Use .iterator.to(LazyList) instead

59.  final def toStream: Stream[T]
    Definition Classes
      IterableOnceOps
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.13.0) Use .to(LazyList) instead of .toStream

60.  final def toTraversable: Traversable[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).toTraversable

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.13.0) Use .iterator.to(Iterable) instead

61.  final def toTraversable: Traversable[T]
    Definition Classes
      IterableOps
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) toTraversable is internal and will be made protected; its name is similar to `toList` or `toSeq`, but it doesn't copy non-immutable collections

62.  def toVector: Vector[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).toVector

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.13.0) Use .iterator.to(Vector) instead

63.  final def union[B >: T](that: Seq[B]): IndexedSeq[B]
    Definition Classes
      SeqOps
    Annotations
      @deprecated @inline()
    Deprecated

      (Since version 2.13.0) Use `concat` instead

64.  def view(from: Int, until: Int): IndexedSeqView[T]
    Definition Classes
      IndexedSeqOps → IterableOps
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .view.slice(from, until) instead of .view(from, until)

65.  def withFilter(f: (T) => Boolean): Iterator[T]
    Implicit
      This member is added by an implicit conversion from Vec[T] toIterableOnceExtensionMethods[T] performed by method iterableOnceExtensionMethods in scala.collection.IterableOnce.
    Shadowing
      This implicitly inherited member is shadowed by one or more members in this class.
      To access this member you can use a type ascription:

          (vec: IterableOnceExtensionMethods[T]).withFilter(f)

    Definition Classes
      IterableOnceExtensionMethods
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use .iterator.withFilter(...) instead

66.  def →[B](y: B): (Vec[T], B)
    Implicit
      This member is added by an implicit conversion from Vec[T] toArrowAssoc[Vec[T]] performed by method ArrowAssoc in scala.Predef.This conversion will take place only if T is a subclass of Option[Nothing] (T <: Option[Nothing]).
    Definition Classes
      ArrowAssoc
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use `->` instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.

### Inherited from VecLike[T]

### Inherited from IndexedSeq[T]

### Inherited from IndexedSeqOps[T, IndexedSeq, IndexedSeq[T]]

### Inherited from IndexedSeq[T]

### Inherited from IndexedSeqOps[T, [_]IndexedSeq[_], IndexedSeq[T]]

### Inherited from Seq[T]

### Inherited from SeqOps[T, [_]IndexedSeq[_], IndexedSeq[T]]

### Inherited from Seq[T]

### Inherited from Equals

### Inherited from SeqOps[T, [_]IndexedSeq[_], IndexedSeq[T]]

### Inherited from PartialFunction[Int, T]

### Inherited from (Int) => T

### Inherited from Iterable[T]

### Inherited from IterableFactoryDefaults[T, [x]IndexedSeq[x]]

### Inherited from IterableOps[T, [_]IndexedSeq[_], IndexedSeq[T]]

### Inherited from IterableOnceOps[T, [_]IndexedSeq[_], IndexedSeq[T]]

### Inherited from IterableOnce[T]

### Inherited from Aggregate

### Inherited from Data

### Inherited from SourceInfoDoc

### Inherited from NamedComponent

### Inherited from HasId

### Inherited from InstanceId

### Inherited from AnyRef

### Inherited from Any

### Inherited by implicit conversion UnliftOps fromVec[T] to UnliftOps[Int, B]

### Inherited by implicit conversion iterableOnceExtensionMethods fromVec[T] to IterableOnceExtensionMethods[T]

### Inherited by implicit conversion DataEquality fromVec[T] to DataEquality[Vec[T]]

### Inherited by implicit conversion toConnectableDefault fromVec[T] to Connectable[Vec[T]]

### Inherited by implicit conversion ConnectableVecDefault fromVec[T] to ConnectableVecDefault[T]

### Inherited by implicit conversion ConnectableDefault fromVec[T] to ConnectableDefault[Vec[T]]

### Inherited by implicit conversion any2stringadd fromVec[T] to any2stringadd[Vec[T]]

### Inherited by implicit conversion StringFormat fromVec[T] to StringFormat[Vec[T]]

### Inherited by implicit conversion Ensuring fromVec[T] to Ensuring[Vec[T]]

### Inherited by implicit conversion ArrowAssoc fromVec[T] to ArrowAssoc[Vec[T]]

### connection

### Ungrouped

### SourceInfoTransformMacro

These internal methods are not part of the public-facing API!
The equivalent public-facing methods do not have the `do_` prefix or have the same name. Use and look at the documentation for those. If you want left shift, use `<<`, not `do_<<`. If you want conversion to a Seq of Bools look at the `asBools` above, not the one below. Users can safely ignore every method in this group!
🐉🐉🐉 Here be dragons... 🐉🐉🐉
These `do_X` methods are used to enable both implicit passing of SourceInfo while also supporting chained apply methods. In effect all "normal" methods that you, as a user, will use in your designs, are converted to their "hidden", `do_*`, via macro transformations. Without using macros here, only one of the above wanted behaviors is allowed (implicit passing and chained applies)---the compiler interprets a chained apply as an explicit 'implicit' argument and will throw type errors.
The "normal", public-facing methods then take no SourceInfo. However, a macro transforms this public-facing method into a call to an internal, hidden `do_*` that takes an explicit SourceInfo by inserting an `implicitly[SourceInfo]` as the explicit argument.