Every non-dependent typing relation is also a dependently typed relation so I think things are already the way you want, unless you have a certain example in mind.
What I want is to be able to specify and have (when possible) automatically proven arbitrary assertions anywhere in the code without necessarily making sure that every possible presupposition is proven from the ground up. Just like in Typescript, I can add a type at any point where there was only "any", and have a small portion of the program typed without typing the whole thing
This doesn't even exist in TypeScript. If I change
function foo(a: any) { return baz(a); }
to function foo(a: number) { return baz(a); }
whoever calls foo has to still prove (or assert) that the argument is a number.Is that what you're after, asserting a dependent type? For example being able to change:
function divByTwo(a: number): number { return a/2; }
to function divByTwo(a: even_number): number { return a/2; }
You want every place divByTwo is called to also automatically supply a proof that the argument is even?You can also use stuff like ! when you don't want to prove your array indices (it might crash or substitute a dummy value if you're wrong).