Is there a visual programming environment that implements lambda calculus (either untyped or simply typed)?

Not specifically, but in my experience a natural way to introduce the lambda calculus visually is via templating. Starting with some diagram (essentially equivalent to an expression tree), let the person pull out some part of it leaving a whole. So from

here we go round the mulberry bush

we can go to:

(here we go round _) (the mulberry bush)

As soon as you try to pull something else out, you see the ambiguity:

(here _ go round _) (the mulberry bush) (we)

In text we use lambdas and variables to order how the blanks get filled in

(\ _what_ _who_ . here _who_ go round _what_ _what_ _what_) (the mulberry bush) (we)

and so on. Immediately, I think of three things that are — um, off — about conventional notation: 1.

(\ variable . expression) value

quickly puts a lot of space between

variable

and

value

. 2. Being able to repeat a variable is so easy to do with text, that you can easily fail to realize how significant an operation it is. 3. Likewise, the between

f (g h)

and

(f g) h

much bigger than the notation suggests. So it certainly would be neat to see a spacial lambda calculus that specifically addresses these problems.

Would either http://www.lamdu.org or https://hazel.org qualify? (I think this question would be fine to post on #thinking-together.)

Here's a paper on a lambda calculus based formalism for visual programs. (Haven't read it) https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=ca25ecf69726cde7e4e735fbc9a6805daa4ca9df

Came across https://inet.run/ today on HN. Had never heard of Interaction nets before: https://en.wikipedia.org/wiki/Interaction_nets