var singleValue = 2;
var arrayValue = [1, 2, 3];

var singleResult = square(singleValue);
var arrayResult = square.apply_to(arrayValue);

// arrays are iterated over in parallel, stopping when the first array ends
var actionResult = doAction(each in arrayA, transformValue(each in arrayB));

// doAction's second parameter is an array
var actionResult = foreach (a in arrayA) { doAction(a, foreach (b in arrayB) }

// doAction's second parameter is a single element
var actionResult = foreach (a in arrayA) { foreach (b in arrayB) { doAction(a, b) } }

// Additional qualifier to provide an index value
var actionResult = foreach indexed (a,i in arrayA) { doAction(a, arrayB[i]) }

// parallel loop, by default it uses the minimum of the N array lengths you pass it
var actionResult = foreach parallel (a in arrayA defaultA, b in arrayB) { doAction(a, b) }

// But if you DO want to do something for the elements that are only present in one array, you can provide a default selector:
var actionResult = foreach parallel (a in arrayA default defaultA, b in arrayB) { doAction(a, b) }
var actionResult = foreach parallel (a in arrayA, b in arrayB default defaultB) { doAction(a, b) }
var actionResult = foreach parallel (a in arrayA default defaultA, b in arrayB default defaultB) { doAction(a, b) }

// Control over whether you get an array or an array-of-arrays out:
var actionResult = foreach         (a in arrayA) { foreach (b in arrayB) { a * b } }
var actionResult = foreach flatten (a in arrayA) { foreach (b in arrayB) { a * b } }

does lisp work like that (i hear it is quite flexible)?

i prefer

dest = source.map(function).map(function2)

looking at

dest = function(each source<T>)

it would seam that if function takes T then we don't need each but then its hard to distinquish.

i think

dest = function2.each(function.each(source))

is fine but it reads backwards so (borrowing pipelining from fsharp)

dest = source |> function.each |> function2.each

is the alternative form.

I dont really see the difference to any of it but things should read in the order they are done imo.

// doAction's second parameter is a single element
var actionResult = foreach<A> foreach<B> doAction(in<A> arrayA, in<B> arrayB)

// Additional qualifier to provide an index value
var actionResult = foreach key idx doAction(in arrayA, arrayB[idx])

// Control over whether you get an array or an array-of-arrays out:
var actionResult = foreach<A>         foreach<B> in<A> arrayA * in<B> arrayB
var actionResult = foreach<A> flatten foreach<B> in<A> arrayA * in<B> arrayB

//My way
var actionResult = foreach (a in arrayA) { doAction(a, a) }

//Your way
var actionResult = foreach<A> doAction(in<A> arrayA, in<A> arrayA)

//or if you want to make the grammar more complicated to allow eliding repeated array identifiers:
var actionResult = foreach<A> doAction(in<A> arrayA, in<A>)

//My way:
var actionResult = foreach indexed (a,indexA in arrayA) { foreach indexed (b,indexB in arrayB) { doIndexedAction(a, indexA, b, indexB) } }

//Your way (I changed it so that 'idx' is now a keyword like 'in', which saves a massive amount of space):
// Also changed nested foreaches without flattening so they can be combined in a comma-list
var actionResult = foreach<A,B> doIndexedAction(in<A> arrayA, idx<A>, in<B> arrayB, idx<B>)

// or something like that?

// The amount of <A> <B> correlation and elided array identifiers you might end up having to support in the grammar seems very painful.

I've been thinking a lot about language design and thought of a way to handle for each loops.

function square(input: x) {
    return x * x;
}

var singleValue = 2;
var arrayValue = [1, 2, 3];

var singleResult = square(singleValue);
var arrayResult = square(each in arrayValue);
// arrayResult is [1, 4, 9]

The trouble with it is that it just does not compose that well. The standard functional map, reduce (Select, SelectMany, Aggregate in C# link) is the better way, sprinkle in a bit of partial application and you have a much more powerful toolbox.

There is a reason why map/reduce have appeared in so many languages either first class or via library, it is just a more powerful and flexible approach to loops. In modern C# for example there have been very few cases where I resort to foreach. If I do find myself typing foreach I look for a better solution as it normally means you are doing it wrong imho