Generator (computer programming): Difference between revisions

Revision as of 14:34, 10 August 2015

Latest revision as of 09:03, 12 August 2025

(128 intermediate revisions by 74 users not shown)

Line 1:

{{Short description|Routine that generates a sequence of values}}

{{other uses|Generator (disambiguation)#Computing}}

{{Refimprove|date=July 2007}}

In [[computer science]], a '''generator''' is a special [[subroutine|routine]] that can be used to control the [[iteration]] behaviour of a [[control flow#Loops|loop]]. In fact, allAll generators are also [[iterator]]s.<ref>http[https://stackoverflow.com/questionsq/1022564/what- What is- the- difference- between- an-iterator- Iterator and- a-generator Generator?]</ref> A generator is very similar to a [[Function (computer programming)|function]] that returns an [[Array (data structure)|array]], in that a generator has [[Parameter (computer programming)|parameters]], can be called, and generates a sequence of values. However, instead of building an array containing all the values and returning them all at once, a generator ''yields'' the values one at a time, which requires less [[Computer memory|memory]] and allows the caller to get started processing the first few values immediately. In short, a generator ''looks like'' a function but ''behaves like'' an [[iterator]].

Generators can be implemented in terms of more expressive [[control flow]] constructs, such as [[coroutine]]s or first-class [[continuation]]s.<ref>{{cite web

Line 11 ⟶ 12:

| title = General ways to traverse collections in Scheme

| url = http://okmij.org/ftp/Scheme/enumerators-callcc.html

}}</ref> Generators, also known as semicoroutines,<ref name="Ralston2000">{{cite book|author=Anthony Ralston|title=Encyclopedia of computer science|url=httphttps://books.google.com/books?id=yQ9LAQAAIAAJ|accessdateaccess-date=11 May 2013|year=2000|publisher=Nature Pub. Group|isbn=978-1-56159-248-7}}</ref> are a special case of (and weaker than) coroutines, in that they always yield control back to the caller (when passing a value back), rather than specifying a coroutine to jump to; see [[Coroutine#Comparison with generatorsGenerators|comparison of coroutines with generators]].

==Uses==

Line 19 ⟶ 20:

Because generators compute their yielded values only on demand, they are useful for representing [[Stream (computing)|streams]], such as sequences that would be expensive or impossible to compute at once. These include e.g. infinite sequences and live data streams.

When eager evaluation is desirable (primarily when the sequence is finite, as otherwise evaluation will never terminate), one can either convert to a [[List (abstract data type)|list]], or use a parallel construction that creates a list instead of a generator. For example, in Python a generator <code>g</code> can be evaluated to a list <code>l</code> via <code>l = list(g)</code>, while in [[F Sharp programming language|F#]] the [[sequence expression]] <code>seq { ... }</code> evaluates lazily (a generator or sequence) but <code>[ ... ]</code> evaluates eagerly (a list).

In the presence of generators, loop constructs of a language – such as for and while – can be reduced into a single loop ... end loop construct; all the usual loop constructs can then be comfortably simulated by using suitable generators in the right way. For example, a ranged loop like <code>for x = 1 to 10</code> can be implemented as iteration through a generator, as in Python's <code>for x in range(101, 110)</code>. Further, <code>break</code> can be implemented as sending ''finish'' to the generator and then using <code>continue</code> in the loop.

==Languages providing generators==

==Timeline==

Generators first appeared in [[CLU (programming language)|CLU]] (1975),<ref>{{cite web

| last = Liskov

| first = Barbara

| authorlinkauthor-link = Barbara Liskov

| date = April 1992

| title = A History of CLU

| url = http://www.lcs.mit.edu/publications/pubs/pdf/MIT-LCS-TR-561.pdf

| access-date = 2006-01-05

| format = pdf

| archive-url = https://web.archive.org/web/20030917041834/http://www.lcs.mit.edu/publications/pubs/pdf/MIT-LCS-TR-561.pdf

}}</ref> were a prominent feature in the string manipulation language [[Icon (programming language)|Icon]] (1977) and are now available in [[Python (programming language)|Python]],<ref name=python>

| archive-date = 2003-09-17

| url-status = dead

}}</ref> were a prominent feature in the string manipulation language [[Icon (programming language)|Icon]] (1977) and are now available in [[Python (programming language)|Python]] (2001),<ref name=python>

Python Enhancement Proposals:

[https://www.python.org/dev/peps/pep-0255/ PEP 255: Simple Generators],

Line 40 ⟶ 44:

</ref> [[C Sharp (programming language)|C#]],<ref>

[http://msdn.microsoft.com/en-us/library/9k7k7cf0.aspx yield (C# Reference)]

</ref> [[Ruby (programming language)|Ruby]], the[[PHP]],<ref>{{Cite upcomingweb|url=https://www.php.net/manual/en/language.generators.overview.php|title version= ofPHP: Generators overview - Manual}}</ref> [[ECMAScript]] (Harmony/as of [[ECMAScript#6th_Edition_–_ECMAScript_2015|ES6/ES2015]]), and other languages. In CLU and C#, generators are called ''iterators'', and in Ruby, ''enumerators''.

===Lisp===

The final [[Common Lisp]] standard does not natively provide generators, yet various library implementations exist, such as [httphttps://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node347.html#SECTION003400000000000000000 SERIES] documented in CLtL2 or [https://web.archive.org/web/20110723043455/http://cliki.net/pygen pygen].

===CLU===

A yield statement is used to implement iterators over user-defined data abstractions.<ref name=Liskov1977>{{cite journal | id citeseerx= {{citeseerx|10.1.1.112.656}} | last1 = Liskov | first1 = B. | last2 = Snyder | first2 = A. | last3 = Atkinson | first3 = R. | last4 = Schaffert | first4 = C. | title = Abstraction mechanisms in CLU | journal = Communications of the ACM | volume = 20 | issue = 8 | year = 1977 | accessdatepages = 564–576 | access-date = <!-- 24 May 2013 --> | doi = 10.1145/359763.359789 | s2cid = 17343380 }}</ref>

<sourcesyntaxhighlight lang="text">

string_chars = iter (s: string) yields (char);

index: int := 1;

Line 63 ⟶ 67:

...

end;

</syntaxhighlight>

</source>

===Icon===

Line 70 ⟶ 74:

Printing squares from 0 to 20 can be achieved using a co-routine by writing:

<sourcesyntaxhighlight lang="icon">

local squares, j

squares := create (seq(0) ^ 2)

Line 78 ⟶ 82:

else

break

</syntaxhighlight>

</source>

However, most of the time custom generators are implemented with the "suspend" keyword which functions exactly like the "yield" keyword in CLU.

===C===

[[C (programming language)|C]] does not have generator functions as a [[language construct]], but, as they are a subset of [[coroutines]], it is simple to implement them using any framework that implements stackful coroutines, such as libdill.<ref>{{cite web|url=http://libdill.org|title=Structured Concurrency for C}}</ref> On POSIX platforms, when the cost of [[context switching]] per iteration is not a concern, or full [[Parallel_computing|parallelism]] rather than merely [[Concurrency (computer_science)|concurrency]] is desired, a very simple generator function framework can be implemented using [[pthreads]] and [[Anonymous_pipe|pipes]].

===C++===

It is possible to introduce generators into C++ using pre-processor macros. The resulting code might have aspects that are very different from native C++., but the generator syntax can be very uncluttered.<ref>{{Cite Aweb|url very= goodhttp://www.codeproject.com/KB/cpp/cpp_generators.aspx|title example= canGenerators bein foundC++|date at= 21 September 2008|access-date = 9 January 2012|archive-date = 7 February 2019|archive-url = https://web.<ref>httparchive.org/web/20190207185018/https://www.codeproject.com/KB/cpp/cpp_generators.aspx|url-status = dead}}</ref> The set of pre-processor macros defined in this source allow generators defined with the syntax as in the following example:

<sourcesyntaxhighlight lang="cpp">$generator(descent) {

int i;

$generator(descent)

{

// place for all variables used in the generator

int i; // our counter

// place the constructor of our generator, e.g.

Line 99 ⟶ 104:

$emit(int) // will emit int values. Start of body of the generator.

for (i = 10; i > 0; --i)

$yield(i); // a.k.a.similar to yield in Python,

// returns next number in [1..10], reversed.

$stop; // stop, end of sequence. End of body of the generator.

};</syntaxhighlight>

};

</source>

This can then be iterated using:

<sourcesyntaxhighlight lang="cpp">int main(int argc, char* argv[]) {

int main(int argc, char* argv[])

{

descent gen;

for (int n; gen(n);) // "get next" generator invocation

printf("next number is %d\n", n);

return 0;

}</syntaxhighlight>

}

</source>

Moreover, [[C++11]] allows [[foreach loop]]s to be applied to any class that provides the <code>begin</code> and <code>end</code> functions. It's then possible to write generator-like classes by defining both the iterable methods (<code>begin</code> and <code>end</code>) and the iterator methods (<code>operator!=</code>, <code>operator++</code> and <code>operator*</code>) in the same class. For example, it is possible to write the following program:

<sourcesyntaxhighlight lang="cpp">#include <iostream>

#include <iostream>

int main() {

for (int i: range(10)) {

{

for (int i: range(10))

{

std::cout << i << std::endl;

}

return 0;

}</syntaxhighlight>

}

</source>

A basic range implementation would look like that:

<sourcesyntaxhighlight lang="cpp">

class range {

{

private:

int last;

Line 155 ⟶ 152:

int operator*() const { return iter; }

};

</syntaxhighlight>Furthermore, [[C++20]] formally introduced support for coroutines,<ref>{{Cite web |title=Coroutines (C++20) - cppreference.com |url=https://en.cppreference.com/w/cpp/language/coroutines.html |access-date=2025-07-16 |website=en.cppreference.com}}</ref> which can be used to implement generators.<ref>{{Cite web |last=Carter |first=Casey |last2=Baker |first2=Lewis |last3=Jabot |first3=Corentin |title=std::generator implementation in C++20 |url=https://godbolt.org/z/5hcaPcfvP |access-date=2025-07-16 |website=godbolt.org |language=en}}</ref> [[C++23]] introduced [https://en.cppreference.com/w/cpp/coroutine/generator.html std::generator] in the standard library, making it much easier to implement generators. For example, a basic range generator can be implemented as:<syntaxhighlight lang="cpp">

</source>

#include <generator>

std::generator<int> range(int n) {

for (int i = 0; i < n; ++i) {

co_yield i;

}

}

</syntaxhighlight>It can be iterated using [[foreach loop]]s:<syntaxhighlight lang="cpp">#include <iostream>

int main() {

for (int i: range(10)) {

std::cout << i << std::endl;

}

return 0;

}</syntaxhighlight>

===Perl===

Line 161 ⟶ 173:

Perl does not natively provide generators, but support is provided by the [https://metacpan.org/module/Coro::Generator Coro::Generator] module which uses the [https://metacpan.org/module/Coro Coro] co-routine framework. Example usage:

<sourcesyntaxhighlight lang="perl">

use strict;

use warnings;

Line 181 ⟶ 193:

print $letters->(), "\n" for (0..15);

</syntaxhighlight>

</source>

===Raku===

Example parallel to Icon uses Raku (formerly/aka Perl 6) Range class as one of several ways to achieve generators with the language.

Printing squares from 0 to 20 can be achieved by writing:

<syntaxhighlight lang="raku">

for (0 .. *).map(* ** 2) -> $i {

last if $i > 20;

say $i

}

</syntaxhighlight>

However, most of the time custom generators are implemented with "gather" and "take" keywords in a lazy context.

===Tcl===

Line 187 ⟶ 213:

In [[Tcl]] 8.6, the generator mechanism is founded on named [[coroutine]]s.

<sourcesyntaxhighlight lang="Tcltcl">

proc generator {body} {

coroutine gen[incr ::disambiguator] apply {{script} {

Line 210 ⟶ 236:

puts [$count]

}

</syntaxhighlight>

</source>

===Haskell===

In [[Haskell (programming language)|Haskell]], with its [[lazy evaluation]] model, everything is a generator - every datum created with a [[Non-strict evaluation|non-strict]] data constructor is generated on demand. For example,

<sourcesyntaxhighlight lang="haskell">

countFrom :: Integer -> [Integer]

countfrom n = n : countfrom (n+1)

countFrom n = n : countFrom (n + 1)

from10to20 :: [Integer]

-- Example use: printing out the integers from 10 to 20.

test1from10to20 = mapM_ print $ takeWhile (<= 20) $ countfromcountFrom 10

primes = 2 : 3 : nextprime 5 where[Integer]

primes = 2 : 3 : nextPrime 5

nextprime n | b = n : nextprime (n+2)

where

| otherwise = nextprime (n+2)

nextPrime n

where b = all ((/= 0).(rem n)) $ takeWhile ((<= n).(^2)) $ tail primes

| notDivisible n = n : nextPrime (n + 2)

</source>

| otherwise = nextPrime (n + 2)

notDivisible n =

all ((/= 0) . (rem n)) $ takeWhile ((<= n) . (^ 2)) $ tail primes

</syntaxhighlight>

where <code>(:)</code> is a non-strict list constructor, ''cons'', and <code>$</code> is just a ''"called-with"'' operator, used for parenthesization. This uses the standard adaptor function,

<sourcesyntaxhighlight lang="haskell">

takeWhile p [] = []

takeWhile p (x:xs) | p x = x : takeWhile p xs

| otherwise = []

</syntaxhighlight>

</source>

which re-fetcheswalks valuesdown agreeablethe withlist aand stops on the first element that doesn't satisfy the predicate,. andIf stopsthe requestinglist newhas valuesbeen aswalked soonbefore asuntil athat non-agreeablepoint, oneit is encountered.just Thea sharedstrict storage[[data accessstructure]], isbut usedif asany apart hadn't been walked through before, it will universalbe mediatorgenerated inon Haskelldemand. List comprehensions can be freely used:

<sourcesyntaxhighlight lang="haskell">

test2squaresUnder20 = mapM_ print $ takeWhile (<= 20) [x * x | x <- countfromcountFrom 10]

test3squaresForNumbersUnder20 = mapM_ print [x * x | x <- takeWhile (<= 20) $ countfromcountFrom 10]

</syntaxhighlight>

</source>

===Racket===

[[Racket (programming language)|Racket]] provides several related facilities for generators. First, its for-loop forms work with ''sequences'', which are a kind of a producer:

<sourcesyntaxhighlight lang="schemeracket">

(for ([i (in-range 10 20)])

(printf "i = ~s\n" i))

</syntaxhighlight>

</source>

and these sequences are also first-class values:

<sourcesyntaxhighlight lang="schemeracket">

(define 10-to-20 (in-range 10 20))

(for ([i 10-to-20])

(printf "i = ~s\n" i))

</syntaxhighlight>

</source>

Some sequences are implemented imperatively (with private state variables) and some are implemented as (possibly infinite) lazy lists. Also, new struct definitions can have a property that specifies how they can be used as sequences.

But more directly, Racket comes with a generator library for a more traditional generator specification. For example,

<sourcesyntaxhighlight lang="schemeracket">

#lang racket

(require racket/generator)

Line 262 ⟶ 293:

(define g (ints-from 10))

(list (g) (g) (g)) ; -> '(10 11 12)

</syntaxhighlight>

</source>

Note that the Racket core implements powerful continuation features, providing general (re-entrant) continuations that are composable, and also delimited continuations. Using this, the generator library is implemented in Racket.

===PHP===

[[File:UML generator in PHP.svg|thumb|UML class diagram depiction of the inheritance chain of the Generator class in PHP]]

The community of PHP implemented generators in PHP 5.5. Details can be found in the original [https://wiki.php.net/rfc/generators RFC about Generator].

The community of [[PHP]] implemented generators in PHP 5.5. Details can be found in the original [https://wiki.php.net/rfc/generators Request for Comments: Generators].

Infinite Fibonacci sequence:

<source lang="php">

<syntaxhighlight lang="php">

function fibonacci() {

function fibonacci(): Generator

{

$last = 0;

$current = 1;

Line 283 ⟶ 317:

echo $number, "\n";

}

</syntaxhighlight>

</source>

Fibonacci sequence with limit:

<syntaxhighlight lang="php">

function fibonacci(int $limit): Generator

{

yield $a = $b = $i = 1;

while (++$i < $limit) {

yield $a = ($b = $a + $b) - $a;

}

}

foreach (fibonacci(10) as $number) {

echo "$number\n";

}

</syntaxhighlight>

Any function which contains a <span style="font-family: 'Courier New';">yield</span> statement is automatically a generator function.

===Ruby===

Ruby supports generators (starting from version 1.9) in the form of the built-in Enumerator class.

<sourcesyntaxhighlight lang="ruby">

# Generator from an Enumerator object

chars = Enumerator.new(['A', 'B', 'C', 'Z'])

Line 301 ⟶ 353:

100.times { puts count.next }

</syntaxhighlight>

</source>

===Java===

Java has had a standard interface for implementing iterators since its early days, and since Java 5, the "foreach" construction makes it easy to loop over objects that provide the <ttcode>java.lang.Iterable</ttcode> interface. (The [[Java collections framework]] and other collections frameworks, typically provide iterators for all collections.)

<syntaxhighlight lang="java">

However, [[Java (programming language)|Java]] does not have generators built into the language. This means that creating iterators is often much trickier than in languages with built-in generators, especially when the generation logic is complex. Because all state must be saved and restored every time an item is to be yielded from an iterator, it is not possible to store state in local variables or use built-in looping routines, as when generators are available; instead, all of this must be manually simulated, using object fields to hold local state and loop counters.

record Pair(int a, int b) {};

Even simple iterators built this way tend to be significantly bulkier than those using generators, with a lot of [[boilerplate code]].

Iterable<Integer> myIterable = Stream.iterate(new Pair(1, 1), p -> new Pair(p.b, p.a + p.b))

The original example above could be written in '''Java 7''' as:

.limit(10)

<source lang="Java">

.map(p -> p.a)::iterator;

// Iterator implemented as anonymous class. This uses generics but doesn't need to.

for (int i: new Iterable<Integer>() {

@Override

public Iterator<Integer> iterator() {

return new Iterator<Integer>() {

int counter = 1;

myIterable.forEach(System.out::println);

@Override

public boolean hasNext() {

return counter <= 100;

}

</syntaxhighlight>

@Override

public Integer next() {

return counter++;

}

Or get an Iterator from the '''Java 8''' super-interface BaseStream of Stream interface.

@Override

<syntaxhighlight lang="java">

public void remove() {

throw new UnsupportedOperationException();

}

};

}

}) {

System.out.println(i);

}

</source>

record Pair(int a, int b) {};

An infinite Fibonacci sequence could also be written int '''Java 7''' as an Iterator:

<source lang="java">

Iterable<Integer> fibo = new Iterable<Integer>() {

@Override

public Iterator<Integer> iterator() {

return new Iterator<Integer>() {

int a = 1, b = 1;

int total;

// Save the iterator of a stream that generates fib sequence

@Override

Iterator<Integer> myGenerator = Stream

public boolean hasNext() {

// Generates Fib return true;sequence

.iterate(new Pair(1, 1), p -> new Pair(p.b, p.a + p.b))

}

.map(p -> p.a).iterator();

// Print the first 5 elements

@Override

for (int i = 0; i < 5; public Integer next(i++) {

System.out.println(myGenerator.next());

total = a + b;

a = b;

b = total;

return total;

}

@Override

public void remove() {

throw new UnsupportedOperationException();

}

};

}

};

// this could then be used as...

for (int f: fibo) {

System.out.println("next Fibonacci number is " + f);

if (someCondition(f)) break;

}

</source>

System.out.println("done with first iteration");

// Print the next 5 elements

Also a infinite Fibonacci sequence could also be written using '''java 8''' Stream interface:

for (int i = 0; i < 5; i++) {

<source lang="java">

System.out.println(myGenerator.next());

Stream.generate(new Supplier<Integer>() {

int a = 1, b = 2;

public Integer get() {

int temp = a;

a = b;

b = a + temp;

return temp;

}

}).forEach(System.out::print);

</source>

Or get an Iterator from the '''Java 8''' super-interface BaseStream of Stream interface.

<source lang="java">

public Iterable<Integer> fibonacci(int limit){

return ()->{

return Stream.generate(new Supplier<Integer>() {

int a = 1, b = 2;

public Integer get() {

int temp = a;

a = b;

b = a + temp;

return temp;

}

}).limit(limit).iterator();

}

}

</syntaxhighlight>

Output:

// this could then be used as...

<syntaxhighlight lang="console">

for (int f: fibonacci(10)) {

1

System.out.println(f);

1

}

2

</source>

3

5

done with first iteration

8

13

21

34

55

</syntaxhighlight>

===C#===

An example C# 2.0 generator (the <code>yield</code> is available since C# version 2.0):

Both of these examples utilize generics, but this is not required. yield keyword also helps in implementing custom stateful iterations over a collection as discussed in this discussion.<ref>{{Cite web|url=https://stackoverflow.com/a/15977474 |title=What is the yield keyword used for in C#?|website=stackoverflow.com|access-date=2018-01-01}}</ref>

Both of these examples utilise Generics, but this is not required.

<sourcesyntaxhighlight lang="csharp">

// Method that takes an iterable input (possibly an array)

// and returns all even numbers.

public static IEnumerable<int> GetEven(IEnumerable<int> numbers)
{

foreach (int inumber in numbers) {

{
if ((inumber % 2) == 0) {

{
yield return inumber;

}

}

}

</syntaxhighlight>

</source>

It is possible to use multiple <code>yield return</code> statements and they are applied in sequence on each iteration:

<sourcesyntaxhighlight lang="csharp">

public class CityCollection : IEnumerable<string>
{

public IEnumerator<string> GetEnumerator() {

{

yield return "New York";

yield return "Paris";

Line 439:

}

}

</syntaxhighlight>

</source>

===XL===

In [[XL (programming language)|XL]], iterators are the basis of 'for' loops:

<sourcesyntaxhighlight lang="text">

import IO = XL.UI.CONSOLE

Line 457:

for I in 1..5 loop

IO.WriteLn "I=", I

</syntaxhighlight>

</source>

===F#===

{{seefurther information|Sequence expression}}

[[F Sharp (programming language)|F#]] provides generators via ''[[sequence expression]]s,'' since version 1.9.1.<ref name="seq">{{cite web | url = http://blogs.msdn.com/dsyme/archive/2007/09/22/some-details-on-f-computation-expressions-aka-monadic-or-workflow-syntax.aspx | title = Some Details on F# Computation Expressions | accessdateaccess-date = 2007-12-14}}</ref> These can define a sequence (lazily evaluated, [[sequential access]]) via <code>seq { ... }</code>, a list (eagerly evaluated, sequential access) via <code>[ ... ]</code> or an array (eagerly evaluated, indexed access) via <code>[| ... |]</code> that contain code that generates values. For example,

<sourcesyntaxhighlight lang="fsharp">

seq { for b in 0 .. 25 do

if b < 15 then

yield b * b }

</syntaxhighlight>

</source>

forms a sequence of squares of numbers from 0 to 14 by filtering out numbers from the range of numbers from 0 to 25.

===Python===

Generators were added to [[Python (programming language)|Python]] in version 2.2 in 2001.<ref name="python"/> An example generator:

<sourcesyntaxhighlight lang="python">

from typing import Iterator

def countfrom(n):

def countfrom(n: int) -> Iterator[int]:

while True:

yield n

Line 480 ⟶ 482:

# Example use: printing out the integers from 10 to 20.

# Note that this iteration terminates normally, despite

# countfrom() being written as an infinite loop.

Line 490 ⟶ 492:

# Another generator, which produces prime numbers indefinitely as needed.

import itertools

def primes() -> Iterator[int]:

"""Generate prime numbers indefinitely as needed."""

yield 2

n = 3

p = [2]

while True:

# ThisIf worksdividing n by all the numbers in Pythonp, up to and 2.5+including sqrt(n),

if# notproduces any(na %non-zero fremainder ==then 0 for fn inis prime.

if all(n % f > 0 for f in itertools.takewhile(lambda f: f * f <= n, p)):

yield n

p.append(n)

n += 2

</syntaxhighlight>

</source>

In Python, a generator can be thought of as an [[iterator]] that contains a frozen [[stack frame]]. Whenever the iterator's <code>next()</code> method is called on the iterator, Python resumes the frozen frame, which executes normally until the next <code>yield</code> statement is reached. The generator's frame is then frozen again, and the yielded value is returned to the caller.

PEP 380 (implemented in Python 3.3) adds the <ttcode>yield from</ttcode> expression, allowing a generator to delegate part of its operations to another generator or iterable.<ref name="pep380">[https://www.python.org/dev/peps/pep-0380/ PEP 380 -- Syntax for Delegating to a Subgenerator]</ref>

====Generator expressions====

Python has a syntax modeled on that of [[list comprehension]]s, called a generator expression that aids in the creation of generators.

The following extends the first example above by using a generator expression to compute squares from the <code>countfrom</code> generator function:

<sourcesyntaxhighlight lang="python">

squares = (n n* n for n in countfrom(2) )

for j in squares:

Line 520 ⟶ 524:

else:

break

</syntaxhighlight>

</source>

===ECMAScript===

[[ECMAScript|ECMAScript 6]] (AKAa.k.a. Harmony) will featureintroduced generator functions.

An infinite Fibonacci sequence can be written using a function generator:

<sourcesyntaxhighlight lang="javascript">

function* fibonacci(limit) {

// inspired by: http://wiki.ecmascript.org/doku.php?id=harmony:generators

function* fibonacci() {

let [prev, curr] = [0, 1];

while (true!limit || curr <= limit) {

yield curr;

[prev, curr] = [curr, prev + curr];

Line 538 ⟶ 541:

}

// bounded by upper limit 10

var gen = fibonacci();

for (const n of fibonacci(10)) {

console.log(gen.next().value); // 1

console.log(gen.next().valuen); // 1

}

console.log(gen.next().value); // 2

console.log(gen.next().value); // 3

// generator without an upper bound limit

console.log(gen.next().value); // 5

for (const n of fibonacci()) {

console.log(gen.next().value); // 8

console.log(n);

</source>

if (n > 10000) break;

}

// manually iterating

let fibGen = fibonacci();

console.log(fibGen.next().value); // 1

console.log(fibGen.next().value); // 1

console.log(fibGen.next().value); // 2

console.log(fibGen.next().value); // 3

console.log(fibGen.next().value); // 5

console.log(fibGen.next().value); // 8

// picks up from where you stopped

for (const n of fibGen) {

console.log(n);

if (n > 10000) break;

}

</syntaxhighlight>

===R===

The iterators package can be used for this purpose.<ref>[https://stackoverflow.com/a/16028448 Generator functions in R]</ref><ref>{{Cite web|url=http://cartesianfaith.wordpress.com/2013/01/05/infinite-generators-in-r/|title=Infinite generators in R|date=5 January 2013}}</ref>

<syntaxhighlight lang="r">

library(iterators)

# Example ------------------

abc <- iter(c('a','b','c'))

nextElem(abc)

</syntaxhighlight>

===Smalltalk===

Example in [[Pharo|Pharo Smalltalk]]:

The [[Golden ratio]] generator below returns to each invocation 'goldenRatio next' a better approximation to the Golden Ratio.

<syntaxhighlight lang="Smalltalk">

goldenRatio := Generator on: [ :g | | x y z r |

x := 0.

y := 1.

[

z := x + y.

r := (z / y) asFloat.

x := y.

y := z.

g yield: r

] repeat

].

goldenRatio next.

</syntaxhighlight>

The expression below returns the next 10 approximations.

<syntaxhighlight lang="Smalltalk">

Character cr join: ((1 to: 10) collect: [ :dummy | ratio next ]).

</syntaxhighlight>

See more in [https://medium.com/concerning-pharo/pharos-hidden-gem-generator-c51ef88aec26 A hidden gem in Pharo: Generator].

==See also==

Line 561 ⟶ 624:

==References==

* Stephan Murer, [[Steve Omohundro|Stephen Omohundro]], David Stoutamire and Clemens Szyperski: Iteration abstraction in [[Sather]]. ''ACM Transactions on Programming Languages and Systems'', 18(1):1-15 (1996) [http://portal.acm.org/citation.cfm?doid=225540.225541]

{{Authority control}}

[[Category:Programming constructs]]

[[Category:Articles with example Python (programming language) code]]

[[Category:Articles with example Haskell code]]

[[Category:Articles with example Ruby code]]

Line 572 ⟶ 637:

[[Category:Articles with example Racket code]]

[[Category:Iteration in programming]]

[[Category:Articles with example R code]]