Is there a way to pass the block of code into the macro?

[dadhi]

@qwertie

Imagine I want such a macro to expand into the for loop:

define #for($items, $block) {
   var temp# = $items;
   for (var i = 0; i < temp#.Length; ++i) {
       it = temp#[i];
       $block
   }
}

and I want to call it like this:

var nums =  new[] { 1, 2, 3 };
var sum = 0;
#for(nums, { sum += it; }); // where `it` is referring to the variable defined by the macro.

// maybe to call it even better like this:
#for nums { sum += it; }

// or like this:
#for (nums, sum += it);

The syntax is imaginary... I just want less noise.

[qwertie]

As you may know, EC# has a fixed syntax that cannot be changed by a macro. However, that syntax includes something called "block-call expressions" which have the form identifier { ... } or identifier (arguments) { ... }. The braced block at the end becomes the last argument to the method or macro mentioned. (There is also a "block-call statement" which is a statement of the form identifier { ... } or identifier (arguments) { ... } - this is not considered to be an expression because no semicolon is required nor recognized at the end.)

Therefore you can simply call #for (nums) { sum += it; }.

Please note that #for is also the name of the built-in for loop, e.g. #for(int i = 0, i < Count, i++, {...}) means for(int i = 0; i < Count; i++) {...}. But this #for expects four arguments; it does not conflict with your #for macro that takes two arguments.

[qwertie]

Your version of the macro doesn't support nested loops, so I tried writing my own macro for this. My version has a loop counter named # (the number sign, because it's a number, see?)

[Passive]
define (for#($item in $collection) { $(..block); })
{
	int #unique# = 0;
	foreach (var $item in $collection) {
		replace (# => #unique#) {
			$(..block);
		}
		++#unique#;
	}
}
[PriorityFallback]
define (for#($collection) { $(..block); })
{
	for# (it in $collection) {
		$(..block);
	}
}

for# (listA) {
	Console.WriteLine("Now processing listA[" + # + "]");
	for# (b in listB) {
		c[#] += it * b;
	}
}

// Generated from Untitled.ecs by LeMP 2.9.0.3.

int _num10 = 0;
foreach (var it in listA) {
	Console.WriteLine("Now processing listA[" + _num10 + "]");
	int _num11 = 0;
	foreach (var b in listB) {
		c[_num11] += it * b;
		++_num11;
	}
	++_num10;
}

The generated It looks okay, but LeMP reports an error that c[#] ambiguously uses the macro #, which of course is true. The alternative to define(#) { #unique#; } is replace (# => #unique#);, but this doesn't work either, because c[#] ends up referring to the outer loop counter rather than the inner loop counter as you would expect. So maybe this macro needs some compile-time C# code to work right, but it's a good start.

Something non-obvious here is the reason I wrote "Now processing listA[" + # + "]" instead of $"Now processing listA[{#}]". This is because EC# doesn't actually support interpolated strings yet. So while $"Now processing listA[{#}]" would be legal, it would be an ordinary string so # would not be replaced with #unique#.

[qwertie]

So I've had this idea in my head that # would be used for implicit variables whose meaning is meant to be clear in context, as for example in #113 where I proposed that # refer to the result of the previous expression in the pipeline. However, as we see here, # could sometimes have multiple meanings in a given context, so one needs a reliable method of determining which # is intended... which proved to be nontrivial for this for#-loop.

So here's an alternate version of the macro (well, two macros) that I actually think is better:

[Passive]
define (for#($item in $collection) { $(..block); })
{
   {
      int $(out concatId($item, #)) = 0;
      foreach (var $item in $collection) {
         $(..block);
         ++concatId($item, #);
      }
   }
}
[PriorityFallback]
define (for#($collection) { $(..block); })
{
   for# (it in $collection) {
      $(..block);
   }
}

// Example
for# (listA) {
   Console.WriteLine("Now processing listA[" + it# + "]");
   for# (b in listB) {
      c[b#] += it * b;
   }
}

In this version, each loop counter is named after the corresponding loop variable to avoid name collisions. I've had to use the $(out ...) macro, which is a no-op in order to use concatId($item, #) as a variable name. Output:

// Generated from Untitled.ecs by LeMP 2.9.0.3.

// Example
{
	int it_num = 0;
	foreach (var it in listA) {
		Console.WriteLine("Now processing listA[" + it_num + "]");
		{
			int b_num = 0;
			foreach (var b in listB) {
				c[b_num] += it * b;
				++b_num;
			}
		}
		++it_num;
	}
}

Edit: I enclosed each loop in a braced block to avoid compiler errors if you use the same loop variable name twice, e.g.

for# (listA) {
   Console.WriteLine("listA[" + it# + "] = " + it);
}
for# (listB) {
   Console.WriteLine("listB[" + it# + "] = " + it);
}

[dadhi]

Man, this is a way more polished and ready for the usage without the hesitation. Cool that such concepts can be done externally by anyone.
Btw,

• The idea for such loop I got from the programming language Jai, where... tabadam, it is also implemented as a macro (compile-time gen).
• The thing with the last argument to function can be written as a block is also implemented in Kotlin.

[qwertie]

I think the first time I saw a "block as last argument" feature was Ruby. Though in Ruby it's a closure and here it is not.

[dadhi]

@qwertie Cool I have expected the thing with the block as a last argument and happy that it is already implemented.