News for hackers. Stuff that matters.
Re:Why Do React Hooks Rely on Call Order? by WorldMaker on Thursday December 13, 2018 @05:12PM (#18676621)
> It's a shame that relying on call-order indexing is the solution because it's magical.

I've been thinking about this a lot since Hooks were introduced, and I'm increasingly of the opinion that it isn't that magical. Order of operations is incredibly important in the functions we write, especially in a language like JS that makes no effort for strict "pure" side-effect free functions. The order of a console.log or a return versus an increment matters in JS. We write a lot of procedural code in JS where order matters (a lot) already.

In that matter, Hooks can just melt into the "procedural" background of JS.

That said, I still feel like I want a better solution than "lint errors" for things like accidental branches of a Hook. I don't have any more of a proposal for how that would work or what that would mean than the article here, though, unfortunately.

Re:Why Do React Hooks Rely on Call Order? by politician on Thursday December 13, 2018 @05:25PM (#18676693)
> I still feel like I want a better solution than "lint errors" for things like accidental branches of a Hook.

The best I can come up with is Sweet.js (hygenic macros), but can you imagine what outrage that would provoke?

Re:Why Do React Hooks Rely on Call Order? by WorldMaker on Friday December 14, 2018 @12:37PM (#18682685)
Yeah, macros/DSLs might be a bridge too far for a lot of users.

I keep trying to figure out if there is a way to push it into a type safety problem in Typescript, at least. A compile error would be preferable to a lint error, even if not everyone uses a typing compiler like Typescript.

If there were some way that you could get use* functions to narrow to `never` in any branch or branch-like position, that would be cool. Unfortunately, I can't think of a natural way in the type system to do that that would work in even a plurality of cases. Which drops back to it needing to be a context-sensitive linter rule.

Re:Why Do React Hooks Rely on Call Order? by politician on Friday December 14, 2018 @01:41PM (#18683325)
You might be able to use ES6 annotations to mark use* functions such that a bespoke Babel plugin can assert that the the control flow AST only contains functions so annotated in non-branching positions.

Basically, lint, but at transpile time.

Re:Why Do React Hooks Rely on Call Order? by WorldMaker on Friday December 14, 2018 @07:18PM (#18686117)
Similarly, tslint operates best as a Typescript plugin and so lint rules in Typescript still can happen at transpile time and aren't necessarily that much different in practice from compiler errors. Still bugs me a little that there's not a higher-kinded type or pattern that I can come up with to do it "for real" in the compilation.