Support functors for lambda parameters

[schveiguy]

I would recommend we think about supporting @CyberShadow's idea for lambdas in a future version of phobos, instead of or in addition to compile-time lambda parameters:

https://forum.dlang.org/post/qnigarkuxxnqwdernhzv@forum.dlang.org

Apologies if this has already come up elsewhere...

[jmdavis]

I don't know that we want to get rid of alias parameters, but I do think that we definitely want to add some kind of functor support for the cases where alias parameters don't work.

[schveiguy]

Did you look at the forum post? If you haven't, I thought that made the use cases and mechanisms really clear.

Using functors can easily remove the requirement for even one context for most things. And it places the onus of storing those pieces on the functor, not on the function being called.

regarding the overloads, you don't need any. From the post:

struct Pred(alias fn)
{
   auto opCall(Args...)(Args args) { return fn(args); }
}

provides the same features as the current setup.

[crazymonkyyy]

Did you look at the forum post? If you haven't, I thought that made the use cases and mechanisms really clear.

skimmed read, not what im asking, jmd also swapped from "runtime lambda not fitting inside alias'ed lamdas" to "functor"

I saw some mechanisms that suggest dual context was in play; my solutions to dual context are using static variables and variants on map that can mixin more data into the range; not classes and Ive been told repeatably I dont understand what monads are where n people will give me nlogn definitions

The forum post seems to imply that runtime lamdas means he can make class based functors(which I don't use classes so..., idk) while I use:

auto mixinmap(string front_,string body_="",R,Args...)(R r,Args args){
	struct range{
		R r;
		size_t i;
		mixin(body_);
		bool dirty=true;
		auto calcfront(){
			auto a=r.front;
			mixin(front_);
		}
		typeof(calcfront()) store;
		auto front(){
			if(dirty){
				store=calcfront;
				dirty=false;
			}
			return store;
		}
		void popFront(){
			r.popFront;
			dirty=true;
			i++;
		}
		bool empty(){
			return r.empty;
		}
	}
	return range(r,0,args);
}

so Im trying to parse whats being said when all'y'all use the word functor as a class based thingy that isnt a lamda, and expect a "you don't understand monads" if I suggest one of my hacks being used instead of snar's or the class-based code

[CyberShadow]

A functor is any type that can be called like a function. This can be a function pointer, delegate, struct with opCall, or class with opCall. The structs and classes may or may not have a context pointer; when they do, it can be passed in via a template alias parameter, which is how you get a functor from a contextful alias lambda.

[crazymonkyyy]

could it be summerized as "have a unittest for map that tests a struct with an opCall passed at runtime" then

[CyberShadow]

Maybe, but note that you can't just pass a struct value (or, well, any value) as an alias parameter. You can pass a struct variable as an alias, but that comes with all of its problems (if it's on the stack, it will require a GC closure, etc.).

Edit: Ah, I had actually written a nice unit test which illustrates this:

@nogc unittest
{
	import std.algorithm.comparison : equal;
	import std.range : iota, only;
	import std.typecons : tuple;

	// Simple map. Delegates are functors too!
	assert(5.iota.map((int n) => n + 1).equal(only(1, 2, 3, 4, 5)));

	// Now with an explicit functor object (no indirect call):
	assert(5.iota.map(functor!((int n) => n + 1)).equal(only(1, 2, 3, 4, 5)));

	// With state (in @nogc !!!)
	int addend = 1;
	assert(5.iota.map(functor!((addend, n) => n + addend)(addend)).equal(only(1, 2, 3, 4, 5)));

	// Aggregate state with tuples:
	auto p = functor!((state, n) => (n + state.addend) * state.factor)(
		tuple!("addend", "factor")(1, 2)
	);
	assert(5.iota.map(p).equal(only(2, 4, 6, 8, 10)));

	// ... or just pass multiple parameters:
	auto q = functor!((addend, factor, n) => (n + addend) * factor)(1, 2);
	assert(5.iota.map(q).equal(only(2, 4, 6, 8, 10)));
}

[CyberShadow]

I've expanded on this concept a bit in ae, there is an ae.utils.functor package (which also implements some things from std.algorithm using functors, and provides some composition tools):

https://ae.dpldocs.info/ae.utils.functor.html
https://github.com/CyberShadow/ae/tree/master/utils/functor

[ichordev]

If the enum parameter DIP ever gets accepted, the 'functor' parameter might be another good use-case for auto enum.