Module shipyard::iterators

Structs

Chunk1

Chunk iterator over a single component.
Returns slices size long except for the last one that might be smaller.

Chunk2

Chunk iterator over 2 components.
Returns a tuple of size long slices and not single elements.
The last chunk’s length will be smaller than size if size does not divide the iterator’s length perfectly.

Chunk3

Chunk iterator over 3 components.
Returns a tuple of size long slices and not single elements.
The last chunk’s length will be smaller than size if size does not divide the iterator’s length perfectly.

Chunk4

Chunk iterator over 4 components.
Returns a tuple of size long slices and not single elements.
The last chunk’s length will be smaller than size if size does not divide the iterator’s length perfectly.

Chunk5

Chunk iterator over 5 components.
Returns a tuple of size long slices and not single elements.
The last chunk’s length will be smaller than size if size does not divide the iterator’s length perfectly.

Chunk6

Chunk iterator over 6 components.
Returns a tuple of size long slices and not single elements.
The last chunk’s length will be smaller than size if size does not divide the iterator’s length perfectly.

Chunk7

Chunk iterator over 7 components.
Returns a tuple of size long slices and not single elements.
The last chunk’s length will be smaller than size if size does not divide the iterator’s length perfectly.

Chunk8

Chunk iterator over 8 components.
Returns a tuple of size long slices and not single elements.
The last chunk’s length will be smaller than size if size does not divide the iterator’s length perfectly.

Chunk9

Chunk iterator over 9 components.
Returns a tuple of size long slices and not single elements.
The last chunk’s length will be smaller than size if size does not divide the iterator’s length perfectly.

Chunk10

Chunk iterator over 10 components.
Returns a tuple of size long slices and not single elements.
The last chunk’s length will be smaller than size if size does not divide the iterator’s length perfectly.

ChunkExact1

Chunk iterator over a single component.
Returns slices size long, to get the remaining items (if any) use the remainder method.

ChunkExact2

Chunk iterator over 2 components.
Returns a tuple of size long slices and not single elements.
ChunkExact will always return a slice with the same length.
To get the remaining items (if any) use the remainder method.

ChunkExact3

Chunk iterator over 3 components.
Returns a tuple of size long slices and not single elements.
ChunkExact will always return a slice with the same length.
To get the remaining items (if any) use the remainder method.

ChunkExact4

Chunk iterator over 4 components.
Returns a tuple of size long slices and not single elements.
ChunkExact will always return a slice with the same length.
To get the remaining items (if any) use the remainder method.

ChunkExact5

Chunk iterator over 5 components.
Returns a tuple of size long slices and not single elements.
ChunkExact will always return a slice with the same length.
To get the remaining items (if any) use the remainder method.

ChunkExact6

Chunk iterator over 6 components.
Returns a tuple of size long slices and not single elements.
ChunkExact will always return a slice with the same length.
To get the remaining items (if any) use the remainder method.

ChunkExact7

Chunk iterator over 7 components.
Returns a tuple of size long slices and not single elements.
ChunkExact will always return a slice with the same length.
To get the remaining items (if any) use the remainder method.

ChunkExact8

Chunk iterator over 8 components.
Returns a tuple of size long slices and not single elements.
ChunkExact will always return a slice with the same length.
To get the remaining items (if any) use the remainder method.

ChunkExact9

Chunk iterator over 9 components.
Returns a tuple of size long slices and not single elements.
ChunkExact will always return a slice with the same length.
To get the remaining items (if any) use the remainder method.

ChunkExact10

Chunk iterator over 10 components.
Returns a tuple of size long slices and not single elements.
ChunkExact will always return a slice with the same length.
To get the remaining items (if any) use the remainder method.

Loose2

Loose iterator over 2 components.

Loose3

Loose iterator over 3 components.

Loose4

Loose iterator over 4 components.

Loose5

Loose iterator over 5 components.

Loose6

Loose iterator over 6 components.

Loose7

Loose iterator over 7 components.

Loose8

Loose iterator over 8 components.

Loose9

Loose iterator over 9 components.

Loose10

Loose iterator over 10 components.

NonPacked2

Non packed iterator over 2 components.

NonPacked3

Non packed iterator over 3 components.

NonPacked4

Non packed iterator over 4 components.

NonPacked5

Non packed iterator over 5 components.

NonPacked6

Non packed iterator over 6 components.

NonPacked7

Non packed iterator over 7 components.

NonPacked8

Non packed iterator over 8 components.

NonPacked9

Non packed iterator over 9 components.

NonPacked10

Non packed iterator over 10 components.

ParLoose2parallel

Loose parallel iterator over 2 components.

ParLoose3parallel

Loose parallel iterator over 3 components.

ParLoose4parallel

Loose parallel iterator over 4 components.

ParLoose5parallel

Loose parallel iterator over 5 components.

ParLoose6parallel

Loose parallel iterator over 6 components.

ParLoose7parallel

Loose parallel iterator over 7 components.

ParLoose8parallel

Loose parallel iterator over 8 components.

ParLoose9parallel

Loose parallel iterator over 9 components.

ParLoose10parallel

Loose parallel iterator over 10 components.

ParNonPacked2parallel

Non packed parallel iterator over 2 components.

ParNonPacked3parallel

Non packed parallel iterator over 3 components.

ParNonPacked4parallel

Non packed parallel iterator over 4 components.

ParNonPacked5parallel

Non packed parallel iterator over 5 components.

ParNonPacked6parallel

Non packed parallel iterator over 6 components.

ParNonPacked7parallel

Non packed parallel iterator over 7 components.

ParNonPacked8parallel

Non packed parallel iterator over 8 components.

ParNonPacked9parallel

Non packed parallel iterator over 9 components.

ParNonPacked10parallel

Non packed parallel iterator over 10 components.

ParTight1parallel

Tight parallel iterator over a single component.

ParTight2parallel

Tight parallel iterator over 2 components.
Tight iterators are fast but are limited to components tightly packed together.

ParTight3parallel

Tight parallel iterator over 3 components.
Tight iterators are fast but are limited to components tightly packed together.

ParTight4parallel

Tight parallel iterator over 4 components.
Tight iterators are fast but are limited to components tightly packed together.

ParTight5parallel

Tight parallel iterator over 5 components.
Tight iterators are fast but are limited to components tightly packed together.

ParTight6parallel

Tight parallel iterator over 6 components.
Tight iterators are fast but are limited to components tightly packed together.

ParTight7parallel

Tight parallel iterator over 7 components.
Tight iterators are fast but are limited to components tightly packed together.

ParTight8parallel

Tight parallel iterator over 8 components.
Tight iterators are fast but are limited to components tightly packed together.

ParTight9parallel

Tight parallel iterator over 9 components.
Tight iterators are fast but are limited to components tightly packed together.

ParTight10parallel

Tight parallel iterator over 10 components.
Tight iterators are fast but are limited to components tightly packed together.

ParUpdate1parallel

Update parallel iterator over a single component.

Tight1

Tight iterator over a single component.

Tight2

Tight iterator over 2 components.
Tight iterators are fast but are limited to components tightly packed together.

Tight3

Tight iterator over 3 components.
Tight iterators are fast but are limited to components tightly packed together.

Tight4

Tight iterator over 4 components.
Tight iterators are fast but are limited to components tightly packed together.

Tight5

Tight iterator over 5 components.
Tight iterators are fast but are limited to components tightly packed together.

Tight6

Tight iterator over 6 components.
Tight iterators are fast but are limited to components tightly packed together.

Tight7

Tight iterator over 7 components.
Tight iterators are fast but are limited to components tightly packed together.

Tight8

Tight iterator over 8 components.
Tight iterators are fast but are limited to components tightly packed together.

Tight9

Tight iterator over 9 components.
Tight iterators are fast but are limited to components tightly packed together.

Tight10

Tight iterator over 10 components.
Tight iterators are fast but are limited to components tightly packed together.

Update1

Update iterator over a single component.

Update2

Update iterator over 2 components.

Update3

Update iterator over 3 components.

Update4

Update iterator over 4 components.

Update5

Update iterator over 5 components.

Update6

Update iterator over 6 components.

Update7

Update iterator over 7 components.

Update8

Update iterator over 8 components.

Update9

Update iterator over 9 components.

Update10

Update iterator over 10 components.

Enums

Iter1

Iterator over a single component.

Iter2

Iterator over 2 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

Iter3

Iterator over 3 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

Iter4

Iterator over 4 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

Iter5

Iterator over 5 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

Iter6

Iterator over 6 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

Iter7

Iterator over 7 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

Iter8

Iterator over 8 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

Iter9

Iterator over 9 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

Iter10

Iterator over 10 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

ParIter1

Parallel iterator over a single component.

ParIter2

Parallel iterator over 2 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

ParIter3

Parallel iterator over 3 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

ParIter4

Parallel iterator over 4 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

ParIter5

Parallel iterator over 5 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

ParIter6

Parallel iterator over 6 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

ParIter7

Parallel iterator over 7 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

ParIter8

Parallel iterator over 8 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

ParIter9

Parallel iterator over 9 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.

ParIter10

Parallel iterator over 10 components.
This enum allows to abstract away what kind of iterator you really get. That doesn’t mean the performance will suffer, the compiler will (almost) always optimize it away.