Title: Design Meeting Notes, 10/13/2017 · Issue #19169 · microsoft/TypeScript · GitHub
Open Graph Title: Design Meeting Notes, 10/13/2017 · Issue #19169 · microsoft/TypeScript
X Title: Design Meeting Notes, 10/13/2017 · Issue #19169 · microsoft/TypeScript
Description: Immutability No concrete ideas yet, but here's the background. Many users prefer to program in a very immutable style. If you think about the differences between C# and F#, one of the the things that makes functional programming easier i...
Open Graph Description: Immutability No concrete ideas yet, but here's the background. Many users prefer to program in a very immutable style. If you think about the differences between C# and F#, one of the the things th...
X Description: Immutability No concrete ideas yet, but here's the background. Many users prefer to program in a very immutable style. If you think about the differences between C# and F#, one of the the thing...
Opengraph URL: https://github.com/microsoft/TypeScript/issues/19169
X: @github
Domain: github.com
{"@context":"https://schema.org","@type":"DiscussionForumPosting","headline":"Design Meeting Notes, 10/13/2017","articleBody":"# Immutability\r\n\r\n* No concrete ideas yet, but here's the background.\r\n* Many users prefer to program in a very immutable style.\r\n* If you think about the differences between C# and F#, one of the the things that makes functional programming easier in the latter is immutability by default.\r\n* But JavaScript doesn't have a library that's amenable to using immutable data structures.\r\n* So what might the world look like here?\r\n * Perhaps some way to declare an immutable type is mutable?\r\n * Perhaps a way to say all fields declared in a type are immutable by default, mutable as an opt-in.\r\n * But even that's not enough for us - we use a \"lazy initialization\" pattern where after creation we set the value of a field exactly once.\r\n* What about something that differentiates the API layer versus within the compilation itself?\r\n * Depends what's considered your code and what's considered external code in some cases, and we don't have a way of indicating what's part of the API.\r\n * *\\[\\[Now we're derailing into how you expose your public API surface]]*\r\n * Then should we have opaque types?\r\n * Well you can sort of do it today.\r\n * The idea of immutability has some of the benefits of and is related to generally restricting access to the internals of your programs.\r\n\r\n# Experimental Stage 1/2 Proposals\r\n\r\n* If you use decorators today, you get a warning that decorators are experimental.\r\n * But many users are not aware that their decorators are experimental because they start off with a `tsconfig` that already turns `--experimentalDecorators` on!\r\n* Generally we only take stage 3 features now.\r\n* Idea\r\n * Don't do anything without an `--experimentalStage1Or2` flag (bikeshed on name later)\r\n * Give a warning all the time which you cannot turn off.\r\n* The thing is, nobody uses these features to *experiment* with. They're putting this code into production.\r\n * So now you're dangling this feature under people's noses but giving a warning that people will become numb to.\r\n* Conclusion: we can put branches on GitHub, but we don't want to put people in difficult upgrade paths.\r\n\r\n# Match types\r\n\r\nStill in prototyping phase.\r\n\r\n```ts\r\ntype X\u003cT> = match (T) {\r\n number: \"a\",\r\n string: \"b\",\r\n else: \"c\"\r\n}\r\n\r\ntype A = X\u003cnumber>; // has type `\"a\"` - matches with `number`\r\ntype B = X\u003c1 | \"hello\">; // has type `\"a\" | \"b\"` - `\"hello\"` and `1` are subtypes of `number` and `string`\r\ntype C = X\u003cobject> // has type `\"c\"` - fell into the `else` branch\r\n```\r\n\r\nOne concern (a.k.a. a feature!) is that this allows us to branch.\r\n\r\n```ts\r\ntype Conditional\u003cC, T, F> = match (C) {\r\n true: T,\r\n false: F,\r\n}\r\n```\r\n\r\nThis all arose from discussion around the `awaited` type PR where many people requested a more general solution.\r\nWith `awaited`, we'd have functionality like so:\r\n\r\n```ts\r\ntype X = awaited Promise\u003cPromise\u003cnumber>>;\r\n// X = number\r\n```\r\n\r\nWe need a way to introduce type parameters to emulate this\r\n\r\n```ts\r\ntype Awaited\u003cT> = match (T) {\r\n PromiseLike\u003cinfer U>: Awaited\u003cU>,\r\n else: T,\r\n}\r\n```\r\n\r\nWe would need to add some recursion checks like we do in other resolution algorithms.\r\n\r\nMain question: what about the higher order type relationships? It's effectively like trying to relate two switch statements.","author":{"url":"https://github.com/DanielRosenwasser","@type":"Person","name":"DanielRosenwasser"},"datePublished":"2017-10-13T21:19:05Z","url":"https://github.com/microsoft/TypeScript/issues/19169"}
| react-profiling | 0 |
| react-import-map | react,react-dom,react-dom/client,react-dom/profiling,react-is,react/compiler-runtime,react/jsx-dev-runtime,react/jsx-runtime,scheduler@b8488ee2c322 |
| route-pattern | /_view_fragments/issues/show/:user_id/:repository/:id/issue_layout(.:format) |
| route-controller | voltron_issues_fragments |
| route-action | issue_layout |
| fetch-nonce | v2:4f0152c2-88c7-8557-8e67-f973adc47091 |
| current-catalog-service-hash | 81bb79d38c15960b92d99bca9288a9108c7a47b18f2423d0f6438c5b7bcd2114 |
| request-id | 84C2:65478:A148FD:D8233B:6B00EA98 |
| html-safe-nonce | 09c6f89470f59d8647d7fa234043c3422502bd91f4c839922840fe0640094389 |
| visitor-payload | eyJyZWZlcnJlciI6IiIsInJlcXVlc3RfaWQiOiI4NEMyOjY1NDc4OkExNDhGRDpEODIzM0I6NkIwMEVBOTgiLCJ2aXNpdG9yX2lkIjoiNzQwNTQ4Njc4MjY3MjM0OTY4IiwicmVnaW9uX2VkZ2UiOiJpYWQiLCJyZWdpb25fcmVuZGVyIjoiaWFkIn0= |
| visitor-hmac | fbbe7a63b13af03e0317a2875b6f57679e4c290c78d122cd852747948d70b259 |
| hovercard-subject-tag | issue:265421853 |
| github-keyboard-shortcuts | repository,issues,copilot |
| google-site-verification | Apib7-x98H0j5cPqHWwSMm6dNU4GmODRoqxLiDzdx9I |
| octolytics-url | https://collector.github.com/github/collect |
| analytics-location | / |
| fb:app_id | 1401488693436528 |
| apple-itunes-app | app-id=1477376905, app-argument=https://github.com/_view_fragments/issues/show/microsoft/TypeScript/19169/issue_layout |
| twitter:image | https://opengraph.githubassets.com/640837d45b80eb4e3af8d8c31a0a1e3a80370d8176b187255f549d81687a43e7/microsoft/TypeScript/issues/19169 |
| twitter:card | summary_large_image |
| og:image | https://opengraph.githubassets.com/640837d45b80eb4e3af8d8c31a0a1e3a80370d8176b187255f549d81687a43e7/microsoft/TypeScript/issues/19169 |
| og:image:alt | Immutability No concrete ideas yet, but here's the background. Many users prefer to program in a very immutable style. If you think about the differences between C# and F#, one of the the things th... |
| og:image:width | 1200 |
| og:image:height | 600 |
| og:site_name | GitHub |
| og:type | object |
| og:author:username | DanielRosenwasser |
| hostname | github.com |
| expected-hostname | github.com |
| None | 4ef498cbabcbe3c50befc7a5b743e7072ee770b4daf0e15e54801180d1fa91fc |
| turbo-cache-control | no-preview |
| go-import | github.com/microsoft/TypeScript git https://github.com/microsoft/TypeScript.git |
| octolytics-dimension-user_id | 6154722 |
| octolytics-dimension-user_login | microsoft |
| octolytics-dimension-repository_id | 20929025 |
| octolytics-dimension-repository_nwo | microsoft/TypeScript |
| octolytics-dimension-repository_public | true |
| octolytics-dimension-repository_is_fork | false |
| octolytics-dimension-repository_network_root_id | 20929025 |
| octolytics-dimension-repository_network_root_nwo | microsoft/TypeScript |
| turbo-body-classes | logged-out env-production page-responsive |
| disable-turbo | false |
| browser-stats-url | https://api.github.com/_private/browser/stats |
| browser-errors-url | https://api.github.com/_private/browser/errors |
| release | 9983dd5da06943f833c971dd5b6bc988e2858be5 |
| ui-target | full |
| theme-color | #1e2327 |
| color-scheme | light dark |
| react-app-name | issues |
Links:
Viewport: width=device-width