immutable-js | Immutable persistent data collections for Javascript | Dataset library

Not sure if this breaks any of your functionality as I have little context of exactly what you are trying to do. But you can get rid of the error by saying that you want key of user in fromJS, like this:

I published the results of my work, I hope this will help someone(Sorry for my English :)).

Ditching immutable.js in favor of Immer did make sense (156 => 123):

Also, if anyone is interested, take a closer look at your chunks. As you can see from my question, in addition to Immutable, http-status.js was also "added" to the general First Load JS. This is a standard file with a set of response codes, from which I needed only one (I just wrote the number manually and removed the import), and the file where it was imported is distributed to the entire application. Additionally, I revised the connection of third-party scripts and used the internal optimization of fonts in next v10:

Also, in conjunction with immutable, json-immutable was used, which is no longer required, which removed 2 more small chunks.

And my previously problematic chunk now looks like this:

Finally: "First Load JS shared by all" has been reduced from 156 kB to 111kB (28.85%)

P.S. I have such a big _app.js chunk because I have Automatic Static Optimization disabled due to getInitialProps

First of clone your questions object by using ... ES6 operator

const clonedQuestion = {...questions}

Now for removing element from answers array

I remember implementing these semantics, and I certainly don't recall thinking about them giving rise to a persistent data structure at the time - although it does seems fair to attach that label to the result!

I don't think you'll find anywhere that explicitly spells out this exact behavior, however the most natural implementation of things that are required by the language quite naturally leads to it. Taking the ingredients:

• The infix:<,> operator is the List constructor in Raku
• When a List is created, it is non-committal with regards to laziness and flattening (these arise from how we use the List, which we don't - in general - know at the point of its construction)
• When we write (|$x, 1), the prefix:<|> operator constructs a Slip, which is a kind of List that should melt into its surrounding List. Thus what infix:<,> sees is a Slip and an Int.
• Making the Slip melt into the result List immediately would mean making a commitment about eagerness, which List construction alone should not do. Thus the Slip and everything after it is placed into the lazily evaluated ("non-reified") portion of the List.

This last of these is what gives rise to the observed persistent data structure style behavior.

I expect it would be possible to have a implementation that inspects the Slip and chooses to eagerly copy things that are known not to be lazy, and still be in compliance with the specification test suite. That would change the time complexity of your example. If you want to be defensive against that, then:

Instead of trying to work backwards based on the signatures of two particular hooks, let's try to make a more generalized function. Typescript should be able to infer the specific types based on which hook you pass in as an argument.

Start by thinking about what we know and what we don't know. The things that we don't know become the generics.

• A hook is a function which takes some arguments (A). There can be any number of arguments of any type (A extends any[]).
• It returns some object (R) which might have a property called 'data' (R extends { data?: any }).
• A reducer is a function which takes the data returned by the hook (R['data']) and maps it to some new value (M).
• The modified hook takes the same arguments (A) and returns an object with all of the hook returned values (R) and an additional property '_data' whose value is returned from the reducer (M) or might be undefined (R & { _data: M | undefined }).

Put that all together and we get this:

As you pointed out, the semantics are slightly different. In the example case they both provide an intersection of the ids, so

getName(): string , getName() is your method and part after : tells about return type. Basically part after : usually denotes about type . return type , variable type etc whatever you are using

TL/DR: I recommend immutable for anything bigger than a simple news-list, together with redux-saga. But I would and don't use it for component's local state.

We have a big React app (JS, not TypeScript) that has all the state as Immutable objects. The recommendation usually is the same as with redux and redux-saga: If you don't know why you need it, you probably don't. But here is the thing, if you start without it and later notice that it would be helpful, you are already deep in a mess and it's hard to switch over.

Immutable doesn't add obvious business value, but it reduces the chances of bugs and prevents you from doing things that might look good now but in the long run increase the cost of development. Especially when your dev team isn't an experienced bunch of seniors or generally tends to not strictly follow rules.

However, in my opinion, it is unecessary overkill for an components internal state, at least if business state is stored in your global redux state.

PS: Immutable is mature and probably doesn't need patches much, but it has to be said: Development of immutable essentially is stopped, they are discussing to bring in new people but who knows how that turns out. There are similar libraries which are more active

First of all, @types/immutable is no longer supported

This package has been deprecated

Author message:

This is a stub types definition for Facebook's Immutable (https://github.com/facebook/immutable-js). Facebook's Immutable provides its own type definitions, so you don't need @types/immutable installed!

After removing it, you should get nice type hints in your editor.

Working example: https://stackblitz.com/edit/typescript-vwetmv?file=index.ts

Update

Adding "target": "es2015" in compiler options removes the error.

See docs: Using TypeScript with Immutable.js v4

Immutable.js type definitions embrace ES2015. While Immutable.js itself supports legacy browsers and environments, its type definitions require TypeScript's 2015 lib. Include either "target": "es2015" or "lib": "es2015" in your tsconfig.json, or provide --target es2015 or --lib es2015 to the tsc command.