support recursive anonymous function

[SleepyRoy]

Update: A preliminary decision is to accept this. Syntax suggestions are wanted and welcome!

Local functions are very useful. Thanks to the recently implemented anonymous function, we can now write, e.g.,

fn func() {
    local := fn() {
        println('hello world')
    }
    local()
}

However, sometimes local functions need to be recursive, so please consider implementing recursive anonymous function. Here's a possible syntax.

fn func() {
    local := fn(n int) {
        if n>1 {
            fn(n-1)
        }
        println('hello world')
    }
    local(10)
}

A more real example:

// example: a binary tree
struct Empty {}
struct Node {value int  left Tree  right Tree}
Type Tree = Empty | Node 

get_size_of_tree := fn (tree Tree) int {
	return match tree {
		Empty { 0 }
		Node { 1 + fn(tree.left) + fn(tree.right) }
	}
}
size := get_size_of_tree(tree)

[ntrel]

V doesn't allow local fn declarations, but in this case it would be better for the parser than fn(n-1):

    fn local(n int) {
        if n>1 {
            local(n-1)
        }
        println('hello world')
    }

[JalonSolov]

"All other languages do it" is still not a valid reason.

[mindplay-dk]

You see posts like this though?

"but it worked there, why doesn't it work here?"

Why shouldn't first class functions have features and syntax consistent with regular functions? Why are there two kinds of functions in the first place? And then you need to have some expert come in and explain the intricacies and details of why - stuff that doesn't help that person be more productive, just things they need to remember and work around.

Consistency is something to strive for in any programming language. You can argue it adds complexity to the implementation, but in this case I'd argue it simplifies the language - being more consistent means fewer surprises, less learning curve.

[JalonSolov]

Anonymous functions are an adjunct to V. They were never planned originally. Then people wanted closures, so those were added. Then they wanted anonymous functions, and those were added.

Only enough was added to make each one work... V was not redesigned at those points.

It would take a large amount of effort to go back and redesign V to treat anonymous functions the same as regular functions, allowing recursion, etc.

That's what I've been trying to convey all along... this late in the game, can you give a single, solid reason why V should go through that much upheaval to support this small bit of functionality, when you can already get the same thing just by creating a regular function?

One of V's main tenets, and the first one listed on the home page is "Simple". It is simple to create a regular function. It is not simple to go back and redesign parts of the compiler to add functionality that is already covered by the simple functionality that is already there.

[Wajinn]

In this case, in agreement with JalonSolov. It's understandable for team V to be very careful about adding features, at this point. Especially those that would be difficult to implement, add excessive complexity, or create stability issues.

[mindplay-dk]

Yeah, that's totally fair. I'm arguing the point as a language consumer. I have no idea what it's like to work on this codebase. ☺️

[SleepyRoy]

@ntrel but I remember local fn declaration examples like this worked...

fn func() {
    local := fn() {
        println('hello world')
    }
    local()
}

[ntrel]

local := fn() {

That works (I meant you can't have named function declarations inside a function). In the body of the anonymous function above, you can't use the name local because it hasn't been defined yet. Anyway, another solution would be to have a special name like self: self(n-1).

[SleepyRoy]

@ntrel yes that makes sense. I think we could simply use fn as such a special name.

[ntrel]

fn(ident) looks like a function type to the parser. It's best to avoid syntax that requires special tests to tell the difference.

[SleepyRoy]

Update: A preliminary decision is to accept this. Syntax suggestions are wanted and welcome!

[mindplay-dk]

Having calls like fn(x) is not very semantic.

And what happens if you have functions within functions and need to call the outermost fn?

My suggestion would be an optional means of declaring a symbol, e.g.:

// example: a binary tree
struct Empty {}
struct Node {value int  left Tree  right Tree}
Type Tree = Empty | Node 

get_size_of_tree := fn count_nodes(tree Tree) int {
	return match tree {
		Empty { 0 }
		Node { 1 + count_nodes(tree.left) + count_nodes(tree.right) }
	}
}
size := get_size_of_tree(tree)

The symbol count_nodes in this example would be locally scoped, and calls like count_nodes(tree.left) actually look and sound like what they are.

fn(ident) looks like a function type to the parser.

It also looks ambiguous to a person.

Recursive functions in other langs typically need a name, e.g. in JavaScript - so this wouldn't be surprising to most people.

This seems more consistent with function syntax/semantics (in V) in general.