Record & Tuple: Immutable Data Structures in JS

Rate this content
Bookmark

Record & Tuple is a proposed feature for JavaScript that aims to introduce new immutable value types. Records are immutable key/value structures and Tuples are immutable sequences of data. In this talk, Robin, one of the champions of the proposal will introduce the feature, show how it can be used and explain how this feature is advancing in the TC39 standardization process.

This talk has been presented at JSNation 2022, check out the latest edition of this JavaScript Conference.

FAQ

Robin is a JavaScript infrastructure worker at Bloomberg and a TC39 delegate for Bloomberg. He actively participates in the standardization process of the JavaScript language and is a co-author and co-champion of the Record and Tuple proposal.

The Record and Tuple feature in JavaScript provides immutable data structures, enhancing data handling by ensuring immutability and offering value-based equality checks, as opposed to the traditional reference-based checks in JavaScript objects and arrays.

Records in JavaScript are immutable and use value-based equality checks. Unlike objects, they do not memorize the insertion order and are created with a hash symbol prefix, ensuring their properties cannot be changed after creation.

No, JavaScript records and tuples cannot contain objects or functions due to their immutable nature. They are designed to only store primitive values and other records or tuples.

New methods such as toReversed, toSorted, with, and toSplice have been introduced for tuples. These methods enable operations similar to traditional array methods but return a new tuple instead of modifying the original in place.

You can convert objects or arrays into records or tuples using the record and array constructors. However, this conversion is shallow, and any nested objects would need to be manually converted to maintain immutability.

As of the latest update, the Record and Tuple proposal is at stage 2 within TC39. This indicates that the committee expects the feature to be developed and eventually included in the JavaScript language, although further changes are likely before final approval.

Robin Ricard
Robin Ricard
24 min
16 Jun, 2022

Comments

Sign in or register to post your comment.

Video Summary and Transcription

Today's Talk introduces the concept of record and tuple in JavaScript, which provide a new way to handle data. The Talk explores the references and mutability of objects, strings, and numbers in JavaScript. It discusses the limitations of freezing objects and proposes record and tuple as a solution. The Talk also covers methods and syntax for tuples, the status of the proposal, and acknowledges the contributions of various individuals. Overall, the Talk aims to redefine how data is handled in JavaScript and encourages waiting for broader browser support before implementing these features.

1. Introduction to Record and Tuple in JavaScript

Short description:

Today, we're going to talk about record and tuple, a new feature in JavaScript that will redefine the way you handle data. We'll cover objects, strings, and numbers, and discuss their references and mutability. Let's start with strings.

And join us at the React Jam. Here are a few of the things you'll find out. Thanks. So let's begin.

So thank you for coming. I'm Robin. Today, we're going to talk about record and tuple, and this is about new feature in JavaScript that we're coming to you with on the next event. And we're going to look at how we can improve it. And this is about new feature in JavaScript that hopefully you'll be able to use, I guess, soon. And it's hopefully going to redefine the way you handle data in JavaScript.

So again, I'm Robin. I work at Bloomberg. I do JavaScript infrastructure, and so I work with thousands of developers in my company to improve their JavaScript experience. I'm also TC39 delegate for Bloomberg. That means that I get to participate in the standardization process of the JavaScript language. And also I'm one of the coauthors and cochampions of Record and Tuple. That's a good thing because today we're going to talk about them.

Okay. What are we going to cover today? First, we're not going to talk about Record and Tuple, but the objects and the types you know and love in JavaScript today. Then we're going to look at Record and Tuple. And finally I'm going to tell you when and if you can use them. Okay.

So, let's start with objects. You already used them and we're also going to talk about other types. Such as strings, numbers. Very basic stuff but nevertheless, it's important to take some time to look at them. We're also going to talk about how they're being referenced and how they're mutable in some ways. Let's start with primitives. And in this case we have strings. On the first line, we create a string.

2. Understanding JavaScript References and Mutability

Short description:

In JavaScript, primitive values like strings and numbers are compared based on their exact characters. Objects, on the other hand, are compared based on their references in memory. Changing a character in a string or mutating the internals of an object is possible, but objects can be frozen to make them immutable. However, freezing is non-recursive, so arrays inside objects can still be mutated. This can be useful when adding or modifying keys in an object. Mutating things can be tricky, so let's explore an example using the initConnections function from a library.

On the second line, we create a second string. Or do we create a new one or is it the same string? That's the question. For JavaScript when you put a primitive value in a variable and you basically use that variable somewhere else and compare it, if the value inside matches exactly the same characters, in the case of a string, it's going to tell you this is the same value.

The same thing goes for numbers. For objects, on the first line here, I'm creating an object. On the second line, I'm creating a second object. Whether they have the same internal stuff in them is irrelevant here. At every line, I create a new reference to a new object and essentially we're going to point to another place in the memory. So we have two references to two different places. For JavaScript, those are not the same thing, they're completely unequal and they're not going to match.

So I don't know if you tried to change one character in string. But if you try to do it, at least in strict mode, this is not going to work out. You're going to have an exception and you're not going to be able to mutate the internals of the string. But I'm pretty sure you already done that with objects and changed the internals of an object by just setting something at a specific key. So here I'm just changing the name key and everything goes well. But some of you might know that you can freeze objects. That makes them basically immutable. So why would we need record intubal? We'll get to that later. But yeah, I can freeze my object and now I can change keys. So that's it. Just done. Mission accomplished. Except that it's non-recursive. So if I want to actually mutate the array inside of that object, I can. Actually that's a good thing here because I wanted to add my colleague Ashley to the champion group because he's been participating a lot on making record intubal amazing.

Okay. So before we go further, some of you might know that mutating things sometimes is a sleep free slope. And so if you know that this is a problem, this next part is going to be, yeah, duh. But it's still an interesting example here that I want to show you. So here, let's say I get this initConnections function from a library.

QnA