Initialize conditionally with anon function

0-README.md

So let's say I'm building a website to tell me what I should wear based on the current weather (raining, sunny, snowing).

I only use the app once per day, and the weather won't change while I'm looking at the app, so the clothing choice should be constant.

I also want the code to be easy to read so other members of my team can easily understand the code.

1-let.ts

enum Weather {
    RAINING,
    SUNNY,
    SNOWING
}

enum Clothing {
    RAIN_COAT,
    SHIRT,
    COAT,
}

const weather: Weather = Weather.RAINING as Weather;

let shouldWear: Clothing

switch (weather) {
    case Weather.RAINING:
        shouldWear = Clothing.RAIN_COAT;
        break;
    case Weather.SUNNY:
        shouldWear = Clothing.SHIRT;
        break;
    case Weather.SNOWING:
        shouldWear = Clothing.COAT;
        break;
}

// This is easy to read and understand, but it's not using a const,
// so we lose the write protections and the implication that this won't change.

2-nestedTernary.ts

enum Weather {
    RAINING,
    SUNNY,
    SNOWING
}

enum Clothing {
    RAIN_COAT,
    SHIRT,
    COAT,
}

const weather: Weather = Weather.RAINING as Weather;

const shouldWear: Clothing = 
    weather === Weather.RAINING 
        ? Clothing.RAIN_COAT
        : weather === Weather.SNOWING
            ? Clothing.COAT
            : Clothing.SHIRT;

// This is constant, but nested ternaries are hard to read and understand.

3-func.ts

enum Weather {
  RAINING,
  SUNNY,
  SNOWING,
}

enum Clothing {
  RAIN_COAT,
  SHIRT,
  COAT,
}

function decideWhatToWear(weather: Weather): Clothing {
  switch (weather) {
    case Weather.RAINING:
      return Clothing.RAIN_COAT;
    case Weather.SUNNY:
      return Clothing.SHIRT;
    case Weather.SNOWING:
      return Clothing.COAT;
  }
}

const weather: Weather = Weather.RAINING as Weather;

const shouldWear: Clothing = decideWhatToWear(weather);

// This is constant and easy to read.

4-anonFunc.ts

enum Weather {
  RAINING,
  SUNNY,
  SNOWING,
}

enum Clothing {
  RAIN_COAT,
  SHIRT,
  COAT,
}

const weather: Weather = Weather.RAINING as Weather;

const shouldWear: Clothing = ((weather: Weather) => {
  switch (weather) {
    case Weather.RAINING:
      return Clothing.RAIN_COAT;
    case Weather.SUNNY:
      return Clothing.SHIRT;
    case Weather.SNOWING:
      return Clothing.COAT;
  }
})(weather);


// This is interesting because it has the constant and most of the readability benifits that you saw in the previous file.

// But now there is no seperation between the logic and where it's being used.
// This makes it extremely easy to remove the code as one block.

// And because the logic is encapsulated, it can't be reused (wich may be desireable in some cases).