TypeScript VS rescript

Supporting operator overloading is part of the linked TS issue [1]. But I'm more curious: why did operator overloading in ES6 itself [2] die?

[1] https://github.com/microsoft/TypeScript/issues/42218

[2] https://github.com/tc39/proposal-operator-overloading

The TypeScript handbook covers Partial, Required, Pick, and keyof with their full type definitions. React documentation covers useState typing patterns. MDN Web Docs is a useful reference for the underlying JavaScript form event handling. For a reference covering all built-in utility types with production patterns for API layers, form handling, and configuration objects, see this guide to TypeScript utility types at TypeScript Utility Types: Practical Code Snippets and Patterns.

# My Awesome Package [](https://www.npmjs.com/package/@armorbreak/my-awesome-package) [](https://opensource.org/licenses/MIT) [](https://www.typescriptlang.org/) > A brief tagline that explains what this does in one sentence. ## Installation \`\`\`bash npm install @armorbreak/my-awesome-package \`\`\` ## Quick Start \`\`\`typescript import { formatList, truncate } from '@armorbreak/my-awesome-package'; console.log(formatList(['apple', 'banana', 'cherry'])); // => 'apple, banana, and cherry' console.log(truncate('This is very long text', 10)); // => 'This is...' \`\`\` ## API Reference ### \`formatList(items, options?)\` Formats an array into a human-readable string. | Parameter | Type | Default | |-----------|------|---------| | \`items\` | \`string[]\` | (required) | | \`options.prefix\` | \`string\` | \`''\` | | \`options.separator\` | \`string\` | \`', '\` | | \`options.maxLength\` | \`number\` | \`Infinity\` | ### \`truncate(text, maxLength, suffix?)\` Truncates text to fit within a character limit. ## Contributing PRs welcome! Please read the [contributing guidelines](CONTRIBUTING.md). ## License MIT © [Your Name](https://github.com/yourusername)

Meet my new codemod, ignore-lint-errors. It helps us ignore lint errors from eslint, stylelint, and typescript (glint for Ember projects).

For teams using TypeScript, adding strict TypeScript checks alongside ESLint catches the type-related issues that AI-generated code is most prone to, particularly around null handling and return type precision.

TypeScript type errors from AI suggestions are common, especially when the tool generates code that interfaces with an existing typed module it did not see in full context.

While the feedback was overwhelmingly positive, I noticed that despite having TypeScript support, many developers were hesitant simply because of "ReScript" in the name. So after months of dedicated development, I'm excited to present you Sury - a TypeScript-first schema validation library that brings all those amazing features while staying true to its ReScript roots 🔥

When I see this it makes me want to run for ReasonML/ReScript/Elm/PureScript.

Sum types (without payloads on the instances they are effectively enums) should not require a evening filling ceremonial dance event to define.

https://reasonml.github.io/

https://rescript-lang.org/

https://elm-lang.org/

https://www.purescript.org/

(any I forgot?)

It's nice that TS is a strict super set of JS... But that's about the only reason TS is nice. Apart from that the "being a strict super set" hampers TS is a million and one ways.

To my JS is too broken to fix with a strict super set.

Interestingly, you probably think that calling eval itself is slow, and I thought this myself. However, it was actually not as slow as I expected. For example, creating a simple nested object schema and calling the parser once happened to be 1.8 times faster with ReScript Schema using eval than Zod. I really put a lot of effort into making it as fast as possible, and I have to thank the ReScript language and the people behind it for allowing me to write very performant and safe code.

Fortunately, the OCaml compiler is very modular, and there have been efforts to make things more... reasonable.

- Reason, a different syntactic frontend for regular OCaml: https://reasonml.github.io/

- ReScript, a language with OCaml semantics that compiles into: JS https://rescript-lang.org/ (I suppose it's a reincarnation of js-of-ocaml).

Elm, ReScript, F#, Ocaml, Scala… it’s just normal to name your types, then use them places. In fact, you’ll often create the types _before_ the code, even if you’re not really practicing DDD (Domain Driven Design). Yes, you’ll do many after the fact when doing functions, or you start testing things and decide to change your design, and make new types. Either way, it’s just “the norm”. You then do the other norms like “name your function” and “name your variables”. I’m a bit confused why it’s only 2 out of 3 (variables and functions, not types) in this TypeScript Angular project. I’ll have to look at other internal Angular projects and see if it’s common there as well.