Before we introduce continuations we need to build some infrastructure. Below is a trampoline that operates on Iteration objects. An iteration is a computation that can either Yield a new value or it can be Done. sealed trait Iteration[+R] case class Yield[+R](result: R, next: () => Iteration[R]) extends Iteration[R] case object Done extends Iteration[Nothing] def … Read more
A method using yield return must be declared as returning one of the following two interfaces: IEnumerable<SomethingAppropriate> IEnumerator<SomethingApropriate> (thanks Jon and Marc for pointing out IEnumerator) Example: public IEnumerable<AClass> YourMethod() { foreach (XElement header in headersXml.Root.Elements()) { yield return (ParseHeader(header)); } } yield is a lazy producer of data, only producing another item after the … Read more
What are the cases where use of yield will be limiting, unnecessary, get me into trouble, or otherwise should be avoided? It’s a good idea to think carefully about your use of “yield return” when dealing with recursively defined structures. For example, I often see this: public static IEnumerable<T> PreorderTraversal<T>(Tree<T> root) { if (root == … Read more
Yes, you can do this: def infinity(start): yield start for x in infinity(start + 1): yield x This will error out once the maximum recursion depth is reached, though. Starting from Python 3.3, you’ll be able to use def infinity(start): yield start yield from infinity(start + 1) If you just call your generator function recursively … Read more
Generators exist in C++, just under another name: Input Iterators. For example, reading from std::cin is similar to having a generator of char. You simply need to understand what a generator does: there is a blob of data: the local variables define a state there is an init method there is a “next” method there … Read more
It is something that F# supports with yield! for a whole collection vs yield for a single item. (That can be very useful in terms of tail recursion…) Unfortunately it’s not supported in C#. However, if you have several methods each returning an IEnumerable<ErrorInfo>, you can use Enumerable.Concat to make your code simpler: private static … Read more
You can improve performance if you unroll recurse to stack, so you will have only one iterator: public IEnumerable<Foo> GetAll() { Stack<Foo> FooStack = new Stack<Foo>(); FooStack.Push(this); while (FooStack.Count > 0) { Foo Result = FooStack.Pop(); yield return Result; foreach (Foo NextFoo in Result.MyChildren) FooStack.Push(NextFoo); } }
The two options I know of is Aviad Ben Dov’s infomancers-collections library from 2007 and Jim Blackler’s YieldAdapter library from 2008 (which is also mentioned in the other answer). Both will allow you to write code with yield return-like construct in Java, so both will satisfy your request. The notable differences between the two are: … Read more
It specifies that an iterator has come to an end. You can think of yield break as a return statement which does not return a value. For example, if you define a function as an iterator, the body of the function may look like this: for (int i = 0; i < 5; i++) { … Read more
Seemingly, yield is syntactic sugar for wrapping what it returns to in a callback and assigning the result value appropriately (and at least in the case of co, throwing the error argument to the callback) No, yield is no syntactic sugar. It’s the core syntax element of generators. When that generator is instantiated, you can … Read more