Iterators: Difference between revisions

Also, I'm making the assumption that the "Print the first, fourth, and fifth elements of each container" were intended to be one-indexed (i.e print the strings at offsets zero, three, and four)

PrintAll:

Purple:

dc.b "Purple",0

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

dim list$ = {{"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}, {"Red","Orange","Yellow","Green","Blue","Purple"}}

dim ind = {1,4,5}

print

end

<pre>Igual que la entrada de FreeBASIC.</pre>

=={{header|C++}}==

#include <list>

#include <string>

FirstFourthFifth(colors.rbegin());

}

{{out}}

<pre>All elements:

=={{header|F_Sharp|F#}}==

//Iterators. Nigel Galloway: Januuary 30th., 2022

let N,G=[|"Sunday"; "Monday"; "Tuesday"; "Wednesday"; "Thursday"; "Friday"; "Saturday"|],["Red"; "Orange"; "Yellow"; "Green"; "Blue"; "Purple"]

let X=(N|>Array.rev|>Seq.ofArray).GetEnumerator() in printfn $"{next X} {(advance X 3; next X)} {next X}"

let X=(G|>List.rev|>Seq.ofList).GetEnumerator() in printfn $"{next X} {(advance X 3; next X)} {next X}"

{{out}}

<pre>

=={{header|FreeBASIC}}==

Dim As String list(1 To 2, 1 To 7) = {_

{"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}, _

Print list(2, Ubound(list,2)-ind(m)); " ";

Next m

{{out}}

<pre>

Still, one approach here might be:

This gives us:

dow

┌──────┬───────┬─────────┬────────┬──────┬────────┬──────┐

│ ││ │└──────┴───────────────────────┘││

│ │└──────┴────────────────────────────────┘│

Here, the implementation's array indexing would see the linked list representation as a two element array. To index arbitrary elements from the linked list, we might map back from the linked list representation to a flat array representation, perhaps using <S:0 (which is a no-op on our array of days of week).

monday tuesday wednesday thursday friday saturday sunday

echo ;:inv <S:0 col

sunday friday thursday

echo ;:inv _1 _3 _4 {<S:0 col

The downside of this approach is that the programmer must understand the data (to know to map all relevant list structures to the desired form). For example, we might instead say that a linked list is not merely an unbalanced binary tree, but must always have its data elements in the left node. That would give us this implementation for col:

col=: '' ]F..(,<) ;:'red orange yellow green blue purple'

┌──────┬───────────────────────────────────────┐

│purple│┌────┬────────────────────────────────┐│

│ ││ │└─────┴────────────────────────┘││

│ │└────┴────────────────────────────────┘│

This creates an issue that a single element nested list looks very much like a flat array. To prevent that from being a problem, we include an empty element at the end of our flat array:

dow=: a:,~;:'monday tuesday wednesday thursday friday saturday sunday'

┌──────┬───────┬─────────┬────────┬──────┬────────┬──────┬┐

│monday│tuesday│wednesday│thursday│friday│saturday│sunday││

Now everything is the same as before, except that we need to explicitly ignore the empty trailing element:

sunday friday thursday

echo ;:inv _2 _4 _5 {<S:0 col

That said, we now also have the opportunity to implement a different kind of normalization routine, which takes advantage of the difference in representation (if we had a need for that...).

For example:

nextLink=: {{ (1;x) #~ (L.y) > #x }}

more=: {{'`next val more'=. ops['ops list position'=. y

more position

With this approach, one of the task examples could look like this:

printAll=: {{

while. more y do.

monday

value iterate^:3 DOW

(Except that this approach does not support negative indexing, so indexing from the end of a list would, for the general case, require either extending the system with explicit support for a length operation or iterating once over the list to determine the list length.)

extensive set of functions which act on lists and vectors. Julia's Iterators can implement

the C++ example:

function PrintContainer(iterator)

FirstFourthFifth(reverse(days))

FirstFourthFifth(reverse(colors))

<pre>

All elements:

five builtin data types it is not an issue for a routine to "know" what it is doing.<br>

Something along the lines of [[Same_fringe#Phix]] could perhaps also be used to implement custom iterators.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">procedure</span> <span style="color: #000000;">print_all</span><span style="color: #0000FF;">(</span><span style="color: #004080;">object</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">printFirstFourthFifth</span><span style="color: #0000FF;">(</span><span style="color: #000000;">days</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">printFirstFourthFifth</span><span style="color: #0000FF;">(</span><span style="color: #000000;">colors</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>

Originally I used keys of 1..6 on the colours dictionary, but that looked suspicious.

Note that the keys here are a mix of int/flt/string/seq, but still carefully "in order".

We can create our own iterators by implementing the ''iterator protocol''. The iterator protocol requires us to implement an <code>__iter__</code> method and a <code>__next__</code> method, as demonstrated by the <code>MyIterable</code> and <code>MyIterator</code> classes below.

from collections import deque

from typing import Iterable

if __name__ == "__main__":

main()

{{out}}

The following example iterates though a hash of Positional Iterable objects and demonstrates both using explicit iterators, and object slice operations on each; then has a semi contrived example of where directly using iterators may be actually useful in Raku; collating unique ascending values from several infinite sequence generators.

array => [<Sunday Monday Tuesday Wednesday Thursday Friday Saturday>],

list => <Red Orange Yellow Green Blue Purple>,

}

{{out}}

<pre>Note: here we are iterating over the %positional-iterable-types hash, but

=={{header|Ring}}==

{{incorrect|Ring|The task is specifically about ''iterators'', not [[wp:Iterator#Contrasting_with_indexing|counting loops with indexing]].}}

list = [["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],

["Red","Orange","Yellow","Green","Blue","Purple"]]

see "done..." +nl

{{out}}

<pre>

The iterator protocol methods are not usually called directly as Wren's 'for' statement (and the Sequence methods) call them automatically under the hood. However, in the spirit of this task, they are called directly.

// Use iterators to print all elements of the sequence.

System.print("\nReverse first, fourth, and fifth elements:")

printFirstFourthFifth.call(days[-1..0])

{{out}}

as XPL0 can come to meeting the requirements of the task.

\\ Use iterators to print all of the elements of any container that supports

\\ iterators. It print elements starting at 'start' up to, but not

FirstFourthFifth(@Days(7-1), -1);

FirstFourthFifth(@Colors(6-1), -1);

{{out}}