Discussion What would you like anonymous functions to look like?

[tooltiperror]

Just a hypothetical question here.

What would you like vJASS Anonymous functions to look like if we had them?

call TimerStart(...,
anonymous function takes nothing returns nothing
    call DestroyTimer(GetExpiredTimer())
endfunction)

That's the only way I could imagine them, but still I'd like to know what people think.

 

[Hatebreeder]

It's be nice if you briefly explained what anonymous functions are, or what you mean.

EDIT: I'm guessing you mean something like private public ?

 

[Weep]

Well, if they are what I think they are, also ForGroup and maybe ForForce...

I wouldn't even want a function declaration, just something like:

local integer id = 'hpea'
set GROUP = GroupEnumSomethingSomething()
call ForGroup(g, 
    if GetUnitTypeId(GetEnumUnit()) == id then
        call KillUnit(GetEnumUnit())
    endif
)

...with variables being autopassed. If that too much, maybe:

call TimerStart(t, 1., true,
    callback inherits this, id, t, g
        call Stuff()
    endcallback
)

 

[luorax]

@Hatebreeder
No. Anonymous functions are hmm, anonymous functions
The best way to define them is tooltiperror's example: He doesn't define/declare the function, he defines it when he calls it. It doesn't have name, it contains the definition only. That's something like a "local function".
In the real programming languages functions're just like the other object types: there're function pointers, and so on. That's why we can use anonymus functions (as i know)

 

[Lyerae]

[ljass]call TimerStart(function({DestroyTimer(GetExpiredTimer())}));[/ljass]

Or...

// C-like for clarity.
function Test() {
    TimerStart(function({ 
        DestroyTimer(GetExpiredTimer());
    });
}

 

[luorax]

call TimerStart(CreateTimer(), 0.01, true, function{
                                                call DestroyTimer(GetExpiredTimer())});

That's how I imagine it.

@Lyerae
This is a bit more C-like in my view:

// C-like for clarity.
void Test() {
    TimerStart(void({ 
        DestroyTimer(GetExpiredTimer());
    });
}

Or even:

// C-like for clarity.
nothing Test() {
    TimerStart(nothing({ 
        DestroyTimer(GetExpiredTimer());
    });
}

But this one look a bit weird. The first one looks better.

 

[Hatebreeder]

@Hatebreeder
No. Anonymous functions are hmm, anonymous functions
The best way to define them is tooltiperror's example: He doesn't define/declare the function, he defines it when he calls it. It doesn't have name, it contains the definition only. That's something like a "local function".
In the real programming languages functions're just like the other object types: there're function pointers, and so on. That's why we can use anonymus functions (as i know)

I see what you did there :3

This will come in quite handy =P Then I won't need to attach Data to functions indirectly or use a roundabout.
However, just [LJASS] function(....) [/LJASS] is enough. not need for anonymous keyword; if you really want it use the anonymous keyword, please make it "anon function(....)"

 

[Darthfett]

What about a 'lambda' keyword?

call ForGroup(g,
    lambda takes nothing returns nothing
        call RemoveUnit(GetEnumUnit())
    endlambda
)

 

[Lyerae]

	
<b>@Lyerae</b>
&lt;snip&gt;
But this one look a bit weird. The first one looks better.

Well I had used the C-like syntax to make what I had typed easier to read, since reading JASS like that could get a little confusing.

 

[Sevion]

call TimerStart(..., function { DestroyTimer(GetExpiredTimer()) } )

Or even

call TimerStart(..., { DestroyTimer(GetExpiredTimer()) } )

 

[Uberplayer]

vJass doesn't use {} so there's no need to use them for anonymous functions.

 

[Sgqvur]

function ...
.
.
.
call TimerStart(t, +INF, false,
    code takes unit u
        call KillUnit(u)
    endcode
               )
.
.
.
endfunction

 

[Sevion]

[ljass]code[/ljass] is a type. It'd be confusing.

@Uberplayer

I know it doesn't. Which is why it'd be a good choice. It won't conflict with anything and will be easier to write (preprocessor-wise).

 

[Trollvottel]

ForGroup(g, 
           do
               call AMAZINGSTUFFWITHUNICORNS(x)
           enddo
)

 

[Sevion]

No, that idea sucks. The unicorns will never do anything with you :-/

Plus, it uses ForGroup.

But I like that do.

Do want anonymous functions.

 

[Sgqvur]

>code is a type. It'd be confusing.

code is a type but it is a type that you [almost] never explicitly declare and use. In that viewpoint it is almost completely useless to the mapper.

Also other languages use the same keyword in different contexts to mean different things which of course [should] makes sense.

I am not saying that "code ... endcode" makes much sense, but it is kinda short and makes little nonsense.

 

[Sevion]

It would still create confusion.

However little that may be.

When doing something like this, you should create as little conflict and confusion as possible :-/

 

[Sgqvur]

Kinda off-topic:

Can some one explain the connection/difference between
anonymous functions and closures? It's a foggy concept for me.

 

[tooltiperror]

There are two ways to create and kill a unit with KillUnit.

local unit u=CreateUnit(...)
call KillUnit(u)

// vs. 

call KillUnit(CreateUnit(...))

The first way is sort of like a normal function. It is declared, then used. Because we set the unit to a variable, we can also keep track of it, or you could think of it as having a label/name, so it is not "anonymous".

An anonymous function would be a function that has no name, and is declared when it needs to be used. Let's say with anonymous functions we could do something like this.

//Non-anonymous:
function filter takes nothing returns nothing
    return false
endfunction

call Filter(function filter)

//Anonymous:

call Filter(
anonymous function
    return false
endfunction)

Something like that. In Javascript, it looks better, like this.

function init()
{
    /*call*/ function(){
        // anonymous function
    }
}

I commented out "call" because JS doesn't use that keyword.

 

[Sevion]

I think we should just keep out the "call" if you're going to make anonymous functions in JASS.