pseudonom-

I'm not sure if they will meet your standards, but Idris and ATS strive to be practical dependently typed languages:

http://www.ats-lang.org/Examples.html http://www.idris-lang.org/

Attoparsec is pretty fast. http://www.serpentine.com/blog/2014/05/31/attoparsec/

Care to elaborate on what you like about its syntax? I can imagine preferring it to Haskell or Lisp, but not thinking it's beautiful.

That sort of unprincipled, implicit conversion is generally frowned upon (by Elm, Haskell, ML, &c.). It reduces type safety.

If all you want is syntactic sugar, Elm has infix lift operators so:

    let p = lift2 (+) Mouse.x Mouse.y

becomes:

    let p = (+) <~ Mouse.x ~ Mouse.y

If you don't like that, Haskell has `do` notation. If Elm also had it, you could do:

    let p = do
      x <- Mouse.x
      y <- Mouse.y
      return (x + y)

Pi doesn't make much sense as a signal (a time-varying value).

Well, it sounds like what you're looking for is property based testing. You can setup something like QuickCheck to run at compilation.

> One where "a = b / c" won't even compile if c might be 0.

Dependently typed languages can provide this.

As another point to triangulate from, Haskell is also whitespace-sensitive and I have never had a non-trivial whitespace error in it.

My understanding is that there's a fundamental trade-off between expressivity and efficiency (while maintaining referential transparency):

https://blogs.janestreet.com/breaking-down-frp/ http://people.seas.harvard.edu/~chong/abstracts/CzaplickiC13... http://www.testblogpleaseignore.com/wp-content/uploads/2012/...

bitemyapp seems to have pretty clear opinions on Haskell vs Clojure: http://bitemyapp.com/posts/2014-04-29-meditations-on-learnin...

I think the point of the above comment is that Go doesn't even include those decades old features.

I made a little website to do this a few months ago:

http://angler.herokuapp.com/

Ha. I made a little website to automatically suggest Anglo-Saxon words a few months ago:

http://angler.herokuapp.com/

Maybe for reversible computing? [0]

[0] https://en.wikipedia.org/wiki/Reversible_computing

As a sort of side note, why is it

    filter p (x :: xs) with (filter p xs)
        | (_ ** xs') = if p x then (_ ** x :: xs') else (_ ** xs')

rather than

    filter p (x :: xs) = if p x then (_ ** x :: snd (filter p xs)) else (_ ** snd (filter p xs))

?

I've used Elm a fair bit which is, in many ways, similar (compile-to-JS, statically typed, purely fuctional language). Between expressive types, a REPL, etc., I have never felt compelled to try to debug the generated Javascript.

My impression is that Fay has been in (at least moderate) use the longest. GHCJS seems to be getting a lot more viable lately. Elm (which is only Haskellish rather than fully Haskell-compatible) isn't listed on that page, but is getting quite nice.

Ur/Web's [0] pretty obscure but also does this. As does Opa [1].

[0] http://impredicative.com/ur/

[1] http://opalang.org/