Favor immutability by converting attributes to sets TL;DR: Using sets for attributes simplifies your code and makes state management easier Problems Addressed Mutability
Complexity
Attributes become polluted
Setters Related Code Smells https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-vii-8dk31x0 https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-vi-cmj31om Steps Identify attributes representing states
Replace the attributes with sets: one for each state
Adjust methods to move items between sets instead of mutating attributes Sample Code Before class Bill {
  amount: number;
  paid: boolean;

  constructor(amount: number) {
    this.amount = amount;
    this.paid = false;
  }

  pay() {
    if (!this.paid) {
      this.paid = true;
    }
  }
}

const bill = new Bill(100);
console.log(bill.paid); // false
bill.pay();
console.log(bill.paid); // true After // 1. Identify attributes representing states

class Accountant {  
   // 2. Replace the attributes with sets: one for each state
  unpaidBills: Set<Bill>;
  paidBills: Set<Bill>;

  constructor() {
    this.unpaidBills = new Set();
    this.paidBills = new Set();
  }

  addBill(bill: Bill) {
    this.unpaidBills.add(bill);
  }

  payBill(bill: Bill) {    
    // 3. Adjust methods to move items
    // between sets instead of mutating attributes
    if (this.unpaidBills.has(bill)) {
      this.unpaidBills.delete(bill);
      this.paidBills.add(bill);
    }
  }
}

class Bill {
  amount: number;

  constructor(amount: number) {
    this.amount = amount;
  }
}

const bill = new Bill(100);
const accountant = new Accountant();
manager.addBill(bill);
console.log(accountant.unpaidBills.has(bill)); // true
manager.payBill(bill);
console.log(accountant.paidBills.has(bill)); // true Type [x]Semi-Automatic Safety This refactoring is safe when your attributes don't rely on specific indexing behavior. Since sets don't maintain element order, check if your logic depends on order. Why is the code better? Entities are immutable in the essence. Using sets ensures uniqueness and simplifies logic. You no longer need to check for duplicates before adding elements. Operations like union, intersection, and difference become straightforward, making your code more maintainable and flexible. Limitations Sets don't preserve element order. If your logic depends on sequence, converting to a set may not be appropriate and you should use an Ordered Collection or Array AI Refactoring You can prompt your AI assistants to make this refactoring for you. Try Them! Without Proper Instructions

With Specific Instructions



ChatGPT

ChatGPT



Claude

Claude



Perplexity

Perplexity



Copilot

Copilot



Gemini

Gemini Tags Mutability Related Refactorings https://hackernoon.com/refactoring-remove-setters-codesmell?embedable=true See also https://hackernoon.com/is-it-crystal-clear-for-everybody-that-a-date-should-not-mutate-wuoy3z03?embedable=true Credits Image by Angelo Giordano in Pixabay This article is part of the Refactoring Series. https://maximilianocontieri.com/how-to-improve-your-code-with-easy-refactorings?embedable=true Favor immutability by converting attributes to sets Favor immutability by converting attributes to sets TL;DR: Using sets for attributes simplifies your code and makes state management easier TL;DR: Using sets for attributes simplifies your code and makes state management easier Problems Addressed Mutability Complexity Attributes become polluted Setters Mutability Complexity Attributes become polluted Setters Related Code Smells https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-vii-8dk31x0 https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-vii-8dk31x0 https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-vi-cmj31om https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-vi-cmj31om Steps Identify attributes representing states Replace the attributes with sets: one for each state Adjust methods to move items between sets instead of mutating attributes Identify attributes representing states Replace the attributes with sets: one for each state Adjust methods to move items between sets instead of mutating attributes Sample Code Before class Bill {
  amount: number;
  paid: boolean;

  constructor(amount: number) {
    this.amount = amount;
    this.paid = false;
  }

  pay() {
    if (!this.paid) {
      this.paid = true;
    }
  }
}

const bill = new Bill(100);
console.log(bill.paid); // false
bill.pay();
console.log(bill.paid); // true class Bill {
  amount: number;
  paid: boolean;

  constructor(amount: number) {
    this.amount = amount;
    this.paid = false;
  }

  pay() {
    if (!this.paid) {
      this.paid = true;
    }
  }
}

const bill = new Bill(100);
console.log(bill.paid); // false
bill.pay();
console.log(bill.paid); // true After // 1. Identify attributes representing states

class Accountant {  
   // 2. Replace the attributes with sets: one for each state
  unpaidBills: Set<Bill>;
  paidBills: Set<Bill>;

  constructor() {
    this.unpaidBills = new Set();
    this.paidBills = new Set();
  }

  addBill(bill: Bill) {
    this.unpaidBills.add(bill);
  }

  payBill(bill: Bill) {    
    // 3. Adjust methods to move items
    // between sets instead of mutating attributes
    if (this.unpaidBills.has(bill)) {
      this.unpaidBills.delete(bill);
      this.paidBills.add(bill);
    }
  }
}

class Bill {
  amount: number;

  constructor(amount: number) {
    this.amount = amount;
  }
}

const bill = new Bill(100);
const accountant = new Accountant();
manager.addBill(bill);
console.log(accountant.unpaidBills.has(bill)); // true
manager.payBill(bill);
console.log(accountant.paidBills.has(bill)); // true // 1. Identify attributes representing states

class Accountant {  
   // 2. Replace the attributes with sets: one for each state
  unpaidBills: Set<Bill>;
  paidBills: Set<Bill>;

  constructor() {
    this.unpaidBills = new Set();
    this.paidBills = new Set();
  }

  addBill(bill: Bill) {
    this.unpaidBills.add(bill);
  }

  payBill(bill: Bill) {    
    // 3. Adjust methods to move items
    // between sets instead of mutating attributes
    if (this.unpaidBills.has(bill)) {
      this.unpaidBills.delete(bill);
      this.paidBills.add(bill);
    }
  }
}

class Bill {
  amount: number;

  constructor(amount: number) {
    this.amount = amount;
  }
}

const bill = new Bill(100);
const accountant = new Accountant();
manager.addBill(bill);
console.log(accountant.unpaidBills.has(bill)); // true
manager.payBill(bill);
console.log(accountant.paidBills.has(bill)); // true Type [x]Semi-Automatic [x] Semi-Automatic [x] Safety This refactoring is safe when your attributes don't rely on specific indexing behavior. Since sets don't maintain element order, check if your logic depends on order. Why is the code better? Entities are immutable in the essence. Using sets ensures uniqueness and simplifies logic. You no longer need to check for duplicates before adding elements. Operations like union, intersection, and difference become straightforward, making your code more maintainable and flexible. Limitations Sets don't preserve element order. If your logic depends on sequence, converting to a set may not be appropriate and you should use an Ordered Collection or Array AI Refactoring You can prompt your AI assistants to make this refactoring for you. Try Them! Without Proper Instructions

With Specific Instructions



ChatGPT

ChatGPT



Claude

Claude



Perplexity

Perplexity



Copilot

Copilot



Gemini

Gemini Without Proper Instructions

With Specific Instructions ChatGPT

ChatGPT Claude

Claude Perplexity

Perplexity Copilot

Copilot Gemini

Gemini Without Proper Instructions With Specific Instructions Without Proper Instructions Without Proper Instructions With Specific Instructions With Specific Instructions ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT Claude Claude Claude Claude Claude Claude Claude Claude Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Copilot Copilot Copilot Copilot Copilot Copilot Copilot Copilot Gemini Gemini Gemini Gemini Gemini Gemini Gemini Gemini Tags Mutability Mutability Related Refactorings https://hackernoon.com/refactoring-remove-setters-codesmell?embedable=true https://hackernoon.com/refactoring-remove-setters-codesmell?embedable=true See also https://hackernoon.com/is-it-crystal-clear-for-everybody-that-a-date-should-not-mutate-wuoy3z03?embedable=true https://hackernoon.com/is-it-crystal-clear-for-everybody-that-a-date-should-not-mutate-wuoy3z03?embedable=true Credits Image by Angelo Giordano in Pixabay Angelo Giordano Pixabay This article is part of the Refactoring Series. https://maximilianocontieri.com/how-to-improve-your-code-with-easy-refactorings?embedable=true https://maximilianocontieri.com/how-to-improve-your-code-with-easy-refactorings?embedable=true

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Code Smell 276 - Untested Regular Expressions

Ethereum and Smart Contracts Explained in 5 Levels of Difficulty

Buy My Book

Share your ideas with me!

Refactoring 017 - Convert Attributes to Sets

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

10 Predictions About the Future of Finance

106 Stories To Learn About Clean Code

100 Pieces of Programming Advice from the Book Clean Code by Robert Martin

110 Stories To Learn About Refactoring

3 Things Coding And Prose Writing Have In Common According To Cory House

4 Simple Habits For Engineering Teams To Beat Technical Debt

10 Predictions About the Future of Finance

106 Stories To Learn About Clean Code

100 Pieces of Programming Advice from the Book Clean Code by Robert Martin

110 Stories To Learn About Refactoring

3 Things Coding And Prose Writing Have In Common According To Cory House

4 Simple Habits For Engineering Teams To Beat Technical Debt

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps