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.:=

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.:=

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

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 <>

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