top | item 44042917

(no title)

reuben364 | 9 months ago

Thinking out aloud here.

One pattern that I have frequently used in EMACS elisp is that redefining a top-level value overwrites that value rather than shadowing it. Basically hot reloading. This doesn't work in a dependently typed context as the type of subsequent definitions can depend on values of earlier definitions.

    def t := string
    def x: t := "asdf"
    redef t := int
redefining t here would cause x to fail to type check. So the only options are to either shadow the variable t, or have redefinitions type-check all terms whose types depend on the value being redefined.

Excluding the type-level debugging they mention, I think a lean style language-server is a better approach. Otherwise you are basically using an append-only ed to edit your environment rather than a vi.

discuss

order

wk_end|9 months ago

I've fantasized about some kind of a dependently-typed Smalltalk-like thing before, and in those fantasies the solution would be that changes would be submitted in the form of transactions - they wouldn't be live until you bundled them all together into one big change that would be fully type-checked, as you describe.

kscarlet|9 months ago

The only option that you described is called "hyperstatic global environment".

And it is called that for a reason, it is not very dynamic :) and probably too static to the taste of many Lisp and all Smalltalk fans.

resize2996|9 months ago

> EMACS elisp

I used this to write the front end for an ATM machine.

extrabajs|9 months ago

I don’t see the connection to dependent types. But anyway, is ‘redef’ part of your language? What type would you give it?

reuben364|9 months ago

I just wrote redef to emphasize that I'm not shadowing the original definition.

    def a := 1
    def f x := a * x
    -- at this point f 1 evaluates to 1
    redef a := 2
    -- at this point f 1 evaluates to 2
But with dependent types, types can depend on prior values (in the previous example the type of x depends on the value t in the most direct way possible, as the type of x is t). If you redefine values, the subsequent definitions may not type-check anymore.