Static typing and parallelism in successors to E

[jonathan.s.shapiro]

I'm thinking about an application scripting language for a project I'm toying with. It won't come as any surprise to this list that I strongly favor static typing, though in this project I may be forced out of that rut; if I stick with static types I'll certainly need both an "any" type and union types. For other reasons, I'm heading in the direction of a language that is pure, functional, and (probably) terminating by design. Depending on how it practically limits expression, the terminating part may be set aside, but I'd like to push on it for a bit and see how it goes. 

One of the things that E did very well was to present the user with the appearance of a conventional sequential language that (mostly) hid a promise-based, event-driven language underneath. This leads me to ask:

1. Are there subsequent/derivative work that has merged the E event-driven approach into a statically typed language that I should look at?

2. Given the assumption that computation will be pure, there is a significant opportunity for parallel execution. has anyone looked at pursuing this sort of direction in an E-like language?

Before somebody suggests it: I'm well overdue to look at Erlang, and I'll be doing so. I'm wondering what else to look at.

Thanks!

Jonathan

[William ML Leslie]

I'm not aware of a clear answer to your question.

It sounds like you might like https://akka.io/ together with Scala. I
don't know if I'd call it an "application scripting" language as the
JVM is a big thing to embed, but that might not be a problem for you.
As you know Scala does not include a totality checker.

I can think of less-mature projects that might fit the bill (e.g.,
there's a BEAM backend for the pure, dependently-typed language Idris:
https://github.com/lenary/idris-erlang) but that could be a support
burden.

If Matt has ideas, I'd suggest trying those first.

--
William Leslie

Notice:
Likely much of this email is, by the nature of copyright, covered
under copyright law. You absolutely MAY reproduce any part of it in
accordance with the copyright law of the nation you are reading this
in. Any attempt to DENY YOU THOSE RIGHTS would be illegal without
prior contractual agreement.

[Dan Connolly]

On Sun, Jan 19, 2020 at 11:08 AM jonathan.s.shapiro <jonathan....@gmail.com> wrote:

I'm thinking about an application scripting language for a project I'm toying with. It won't come as any surprise to this list that I strongly favor static typing, though in this project I may be forced out of that rut; if I stick with static types I'll certainly need both an "any" type and union types. For other reasons, I'm heading in the direction of a language that is pure, functional, and (probably) terminating by design.

Among actively developed languages, https://dhall-lang.org/ is the only one I can think of that is terminating (aside from idris, which seems an odd fit for an app scripting language). It's also statically typed and embeddable. I don't think it has union types.

https://docs.dhall-lang.org/howtos/How-to-integrate-Dhall.html

One of the things that E did very well was to present the user with the appearance of a conventional sequential language that (mostly) hid a promise-based, event-driven language underneath. This leads me to ask:

1. Are there subsequent/derivative work that has merged the E event-driven approach into a statically typed language that I should look at?

Wyvern is "capability safe" and has a sound static type system, but I don't know what support it has for promises and event loops.

https://github.com/wyvernlang/wyvern/wiki/Wyvern:-A-Language-for-Usable-Design-Driven-Assurance

The active E successors are SES and monte (http://www.monte-language.org/) . Monte has guards. I started playing around with Hindly-Milner static analysis layered on top, though I didn't get very far: https://gist.github.com/dckc/30cdcfde271cf7f02f2e1e13984f7b30

w.r.t. SES, Typescript and flow both have good support for union types.

And there are some JS engines much smaller than v8. I'm having a lot of fun with moddable xs. https://github.com/Moddable-OpenSource/moddable . But there's also https://github.com/robertkrimen/otto and https://duktape.org/

 

2. Given the assumption that computation will be pure, there is a significant opportunity for parallel execution. has anyone looked at pursuing this sort of direction in an E-like language?

MarkM told me Intel did some work on parallel JS, where the programmer makes some purity declarations and the runtime reverts to a slow path if the purity declarations are violated. I have not seen details (and I don't know that they're widely available.)

 

Before somebody suggests it: I'm well overdue to look at Erlang, and I'll be doing so. I'm wondering what else to look at.

I'm overdue on that front myself.

--

Dan Connolly

http://www.madmode.com/

[Mark S. Miller]

It was very clever. All gone. AFAIK, sunk without a trace. A shame.

 

 

Before somebody suggests it: I'm well overdue to look at Erlang, and I'll be doing so. I'm wondering what else to look at.

I'm overdue on that front myself.

--

Dan Connolly

http://www.madmode.com/

--
You received this message because you are subscribed to the Google Groups "e-lang" group.
To unsubscribe from this group and stop receiving emails from it, send an email to e-lang+un...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/e-lang/CAD2YivZK2x9MRDBFEs_thG1ciixx6Wj%3D-SXdEp1AODK9RbkLMw%40mail.gmail.com.

--

  Cheers,
  --MarkM