Implementing IEnumerable in JavaScript / TypeScript

Question

I'm trying to implement the C# keyword yield with in JavaScript/TypeScript (doesn't matter which): For example, I would like to implement the code:

//using System.Collections;  
//using System.Diagnostics; 
public static void Process()
{
    // Display powers of 2 up to the exponent of 8:  
    foreach (int number in Power(2, 8))
    {
        Debug.Write(number.ToString() + " ");
    }
    // Output: 2 4 8 16 32 64 128 256
}


public static IEnumerable Power(int baseNumber, int highExponent)
{
    int result = 1;

    for (int counter = 1; counter <= highExponent; counter++)
    {
        result = result * baseNumber;
        yield return result;
    }
}

in JavaScript.

The end goal is to implement a function written in C# from another question I asked about on stackoverflow, in JavaScript:

public static IEnumerable<string> SplitByCharacterType(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentNullException(nameof(input));

    StringBuilder segment = new StringBuilder();
    segment.Append(input[0]);
    var current = Char.GetUnicodeCategory(input[0]);

    for (int i = 1; i < input.Length; i++)
    {
        var next = Char.GetUnicodeCategory(input[i]);
        if (next == current)
        {
            segment.Append(input[i]);
        }
        else
        {
            yield return segment.ToString();
            segment.Clear();
            segment.Append(input[i]);
            current = next;
        }
    }
    yield return segment.ToString();
}

Any ideas?

Answer 1

I don't think there's a reasonable way to make this work in the context of a for loop that preserves the C# semantics of lazy evaluation during the "move next" operation. You can simulate this reasonably with closures, though.

(TypeScript code):

function getPowers(base: number, maxExponent: number) {
    var currentExponent = 1;
    return function() {
        if(currentExponent > maxExponent) {
            return undefined;
        } else {
            return Math.pow(base, currentExponent++);
        }
    }
}

// Simple test
var p = getPowers(2, 8);
var n: number;
while((n = p()) !== undefined) {
    console.log(n);
}

// Demonstrate that multiple instances work
var p2 = getPowers(2, 3);
var p3 = getPowers(3, 3);
while(true) {
    var n2 = p2();
    var n3 = p3();
    if((n2 || n3) === undefined) break;

    console.log(n2 + ", " + n3);
}

Answer 2

I know it's many years later, but generators & iterators now exist in TypeScript, so this is now possible. You can read more of the details here: https://github.com/Microsoft/TypeScript/wiki/What%27s-new-in-TypeScript#typescript-23

I'm the original author of the SplitByCharacterType, so I figured I'd also give it a stab to try and re-implement in JS. The hardest problem is the lack of a native ability to differentiate character type (ex: GetUnicodeCategory). unicode-categories looks like it could be used to identify the character category. There is also an answer here for this. I'm going to use the second option as it looks more comprehensive. Note, that the getType() method used here is coming from that answer.

function* splitByCharacterType(input) {
    if (!input || !input.length) 
        return;

    var segment = [input[0]];
    var current = getType(input[0]);

    for (var i = 1; i < input.length; i++) {
        var item = input[i];
        var next = getType(item);
        if (next == current) {
            segment.push(item);
        } else {
            yield segment.join("");
            segment = [item];
            current = next;
        }
    }
    yield segment.join("");
}

This was also an interesting page on the subject: http://inimino.org/~inimino/blog/javascript_cset

Answer 3

Some versions of JavaScript include yield but it's not widely supported (although Firefox does support it).

You might be able to improvise an alternative, although the hallmark of true 'yield' is multiple active callstacks, which requires threads (which is why yield can be simulated in Java) but standard JS doesn't have threads either.

You could look at Web Workers http://en.wikipedia.org/wiki/Web_worker but I suspect this will be far too heavyweight and restrictive for most applications benefitting from yield.

Answer 4

@Lajos Arpad: Having an array is not the same as having an IEnumerable. The core of this interface is on demand evaluation of the next element within an iteration.

+1 for Ryan.

Maybe the example could have been better in a sense that the call to the getPowers function should not have a maxExponent parameter. That is simply not required for a lazy evaluating IEnumerable. The consumer can pick as many powers as it wants to have.

Ryans example would also work in an unbounded scenario whereas any implementation with arrays must fail.

Answer 5

So here is an example showing how an enumeration can be unbounded in its definition but bounded on the consumer side by reading only several elements:

        function getPowers(base) {
            var currentExponent = 1;
            return function () {
                return Math.pow(base, currentExponent++);
            }
        }

        function test() {
            // Simple test
            var p = getPowers(2);
            var elem = document.getElementById("a");
            elem.innerHTML = "<p>" + p() + "<p>" + p() + "<p>" + p() + "<p>" + p() + "<p>" + p() + "<p>" + p() + "<p>" + p();
        }