Well, it's been a month since I announced the whole Visi thing.  When I announces, I had a barely functional type checker and inferencer and a barely functional expression evaluator.

That's all changed in the last month.  As I've gotten my Haskell Foo on and gone with an existing implementation of Hindley-Milner type checking rather than trying to write my own from first principals, I've made a ton of progress with the Visi language.

For example, Visi can implement Factorial:

fact n = if n == 0 then 1 else n * fact n - 1
res = fact 10 //  testResults [("res", DoubleValue 3628800)] . checkResults)

The above code is taken right out of the Visi test suite.  Parsing, type checking, and computation works

Visi supports inner functions.  Rather than having an explicit "let" in the Visi syntax, you can define a local function 'fact' is referenced inside the 'f' function.  The local 'fact' function is passed, partially applied, to the 'app' function and correctly applied:

fact n = n & \"hello\" {-  propper scoping this fact is not the inner fact -}
f n = {- Test partially applied functions -}
  fact n = if n == 0 then 1 else n * fact(n - 1)
  app n fact
app v f = f v
res = f 8 // testResults [("res", DoubleValue 40320.0)] . checkResults)

Local functions close over scope.  For example, 'f' returns a local function that takes two parameters and references the 'b' variable and computes the product of the three variables.  The 'q' function applies 'f' to 8 and 'z' applies 'f' to 10.  WIth these functions, we can apply or partially apply the functions:

f b = {- test that the function closes over local scope -}
  timesb n m = n * b * m
app v f = f v
q = f 8
z = f 10
res = (app 9 (app 8 q)) - ((z 8 9) + (z 1 1)) // testResults [("res", DoubleValue (-154))] . checkResults)

Note, too, the clean syntax.  No line-end characters.  No "let" keyword (although variable shadowing is possible and not yet flagged as an error).

So, check out the tests to get a better sense of both the Visi language and the test harness that I'm using for Test Driven Development.