orta · March 14, 2023 01:53
diff --git a/0 ~ Intro.md b/0 ~ Intro.md
diff --git a/01 ~ Beginner 1.ts b/01 ~ Beginner 1.ts
 // You're making an app which connects to a database
 // of local ghosts and their favourite haunts.

 // You are creating the client which connects to that database,
 // and you have an API response generated for you automatically.

 // When you start trying to display the hauntings, you realize
 // that you don't know how to type the parameter and just use `any`.

 // `any` has its place, but a colleague recommended that you can
 // use 'Indexed Types' to remove the 'any' without changing the
 // GhostAPIResponse type.

 type GhostAPIResponse = {
  name: string
  birthDate?: string
  deathDate?: string
  bio: string

  hauntings: Array<{ title: string, provenance: string, location: string }>
 }

 const displayGhost = (ghost: GhostAPIResponse) => {
  console.log(`Name: ${ghost.name}`)
  if (ghost.birthDate) console.log(`Birthday: ${ghost.birthDate}`)
  if (ghost.deathDate) console.log(`Died: ${ghost.deathDate}`)
  console.log(`\nBio: ${ghost.bio}`)

  console.log(`\nArtworks:`)
  ghost.hauntings.forEach(artwork => {
    displayHauntings(artwork)
  })
 }

 // Your goal: remove this any, without changing GhostAPIResponse
 const displayHauntings = (haunting: any) => {
  console.log(` - Title: ${haunting.title}`)
  console.log(`   ${haunting.location}`)
  console.log(`   ${haunting.provemance}`)
 }

diff --git a/02 ~ Intermediate 1.ts b/02 ~ Intermediate 1.ts
 // Your kids have returned home with a whole bag
 // full of halloween loot, and you've taken the time to 
 // make a description of all of them:

 type SnackBars = { 
  name: "Short Chocolate Bars"
  amount: 4
  candy: true
 }

 type Gumballs = { 
  name: "Gooey Gumballs"
  color: "green" | "purples"
  candy: true
 }

 type Apples = { 
  name: "Apples"
  candy: true
 }

 type Cookies = { 
  name: "Cookies"
  candy: true
  peanuts: true
 }

 type SnickersBar = { 
  name: "Snickers Bar"
  candy: true
  peanuts: true
 }

 type Toothpaste = { 
  name: "Toothpaste"
  minty: true
  trick: true
 }

 type Pencil = { 
  name: "Pencil"
  trick: true
 }

 // You create a single pile of all the results, and want to use
 // this to share out the winnings among your kids. 

 type ResultsFromHalloween = SnackBars | Gumballs | Apples | SnickersBar | Cookies | Toothpaste | Pencil

 // You're first going to need to separate out the candy from the treats,
 // you can do that via conditional types.

 // type AllCandies = ...
 // type AllTricks = ...

 // Almost there, but little 'Bobby Tables' cannot have peanuts. Can
 // you make a list of candies just for him?

 // type AllCandiesWithoutPeanuts = ...
diff --git a/03 ~ Answers 1.md b/03 ~ Answers 1.md
diff --git a/05~ Day 2.md b/05~ Day 2.md
diff --git a/06 ~ Beginner 2.ts b/06 ~ Beginner 2.ts
 // You've been keeping a diary of your trick or treat
 // results for your street, they generally fall into 
 // three categories: treats, tricks and no-shows.

 // Can you make three types which can describe of
 // these results?

 const treats = [
  { location: "House 1", result: "treat", treat: { candy: "Lion Bar" } },
  { location: "House 3", result: "treat", treat: { candy: "Mars Bar" } },
  { location: "House 4", result: "treat", treat: { baked: "Cookies", candy: "Reese's" } }
 ]

 const tricks = [
  { location: "House 2", result: "trick", trick: "Magic" },
  { location: "House 7", result: "trick", trick: "Surprised" }
 ]

 const noShows = [
  { location: "House 6", result: "no-show" }
 ]

 // Now that you have the types, can you make them
 // not duplicate 'location' and 'result' by using 
 // a union for 'result' and a new intersection type?
diff --git a/07 ~ Intermediate 2.ts b/07 ~ Intermediate 2.ts
 // Dang, COVID19 has really put a bind on the nature of trick or treating.
 // Your block has opt-ed to instead do a trunk or treat instead.

 // In a rush to prepare for the event, you hardcoded the
 // results into the 'TrunkOrTreatResults' type which is already
 // out of date - it's missing a few properties!
 // Can you rewrite 'TrunkOrTreatResults' as an object type that
 // stays in sync with the strings in 'trunkOrTreatSpots'?

 const trunkOrTreatSpots = [
  'The Park', 
  'House #1', 
  'House #2',
  'Corner Shop',
  'Place of Worship',
 ] as const


 type TrunkOrTreatResults = {
    "The Park": {
        done: boolean,
        who: string,
        loot: Record<string, any>
    },
    "House #1" : {
        done: boolean,
        who: string,
        loot: Record<string, any>
    },
    "House #2": {
        done: boolean,
        who: string,
        loot: Record<string, any>
    }
 }

 function makeTODO(spots: typeof trunkOrTreatSpots): TrunkOrTreatResults {
    return spots.reduce((prev, current) => {
        return {
            ...prev,
            [current]: {
                done: false,
                loot: {},
                who: ""
            }
        }
    }, {} as TrunkOrTreatResults)
 }

 // You can preview the results via "Run" above

 const todo = makeTODO(trunkOrTreatSpots)
 console.log(todo)

 // Works
 todo["The Park"].done = true

 // Should Work
 todo["Corner Shop"].loot = {}

 // Fails
 todo["House #3"].done = false


 // Spoiler-ish optional tips are a few lines below this 











 // Warning: Spoilers


 // 1. This is a mapped types problem





 // 2. There is a constraint on the mapped type argument





 // 3. You can re-use a part of the technique from the beginner challenge 1 to get the exact keys from
 //    the array: https://dev.to/typescript/type-treat-challenge-2-3n16
diff --git a/08 ~ Answers.md b/08 ~ Answers.md
diff --git a/10 ~ Day 3.md b/10 ~ Day 3.md
diff --git a/11 ~ Beginner 3.ts b/11 ~ Beginner 3.ts
 // You've been keeping a diary of your trick or treat
 // results for your street, they generally fall into 
 // three categories: treats, tricks and no-shows.

 // Can you make three types which can describe of
 // these results?

 const treats = [
  { location: "House 1", result: "treat", treat: { candy: "Lion Bar" } },
  { location: "House 3", result: "treat", treat: { candy: "Mars Bar" } },
  { location: "House 4", result: "treat", treat: { baked: "Cookies", candy: "Reese's" } }
 ]

 const tricks = [
  { location: "House 2", result: "trick", trick: "Magic" },
  { location: "House 7", result: "trick", trick: "Surprised" }
 ]

 const noShows = [
  { location: "House 6", result: "no-show" }
 ]

 // Now that you have the types, can you make them
 // not duplicate 'location' and 'result' by using 
 // a union for 'result' and a new intersection type?
diff --git a/12 ~ Intermediate 3.ts b/12 ~ Intermediate 3.ts
 // Dang, COVID19 has really put a bind on the nature of trick or treating.
 // Your block has opt-ed to instead do a trunk or treat instead.

 // In a rush to prepare for the event, you hardcoded the
 // results into the 'TrunkOrTreatResults' type which is already
 // out of date - it's missing a few properties!

 // Can you rewrite 'TrunkOrTreatResults' to an object type that
 // stays in sync with the strings in 'trunkOrTreatSpots'?

 const trunkOrTreatSpots = [
    'The Park', 
    'House #1', 
    'House #2',
    'Corner Shop',
    'Place of Worship',
  ] as const
  
  
  type TrunkOrTreatResults = {
      "The Park": {
          done: boolean,
          who: string,
          loot: Record<string, any>
      },
      "House #1" : {
          done: boolean,
          who: string,
          loot: Record<string, any>
      },
      "House #2": {
          done: boolean,
          who: string,
          loot: Record<string, any>
      }
  }
  
  function makeTODO(spots: typeof trunkOrTreatSpots): TrunkOrTreatResults {
      return spots.reduce((prev, current) => {
          return {
              ...prev,
              [current]: {
                  done: false,
                  loot: {},
                  who: ""
              }
          }
      }, {} as TrunkOrTreatResults)
  }
  
  // You can preview the results via "Run" above
  
  const todo = makeTODO(trunkOrTreatSpots)
  console.log(todo)
  
  // Works
  todo["The Park"].done = true
  
  // Should Work
  todo["Corner Shop"].loot = {}
  
  // Fails
  todo["House #3"].done = false
  
  
  // Spoiler-ish optional tips are a few lines below this 
  
  
  
  
  
  
  
  
  
  
  
  // Warning: Spoilers
  
  
  // 1. This is a mapped types problem
  
  
  
  
  
  // 2. There is a constraint on the mapped type argument
  
  
  
  
  
  // 3. You can re-use a part of the technique from the beginner challenge 1 to get the exact keys from
  //    the array: https://dev.to/typescript/type-treat-challenge-2-3n16
diff --git a/13 ~ Answers 3.md b/13 ~ Answers 3.md
diff --git a/15 ~ Day 4.md b/15 ~ Day 4.md
diff --git a/16 ~ Beginner 4.ts b/16 ~ Beginner 4.ts
 // No-one knows what is going on, but you think your workplace 
 // is haunted by a poltergeist. It kinda sucks.
 // 
 // Your objects keep getting changed behind the scenes,
 // stop this from happening by making your objects readonly
 // to stop this spooky behavior.

 type Rectory = {
  rooms: Room[]
  noises: any[]
 }

 type Room = {
  name: string
  doors: number
  windows: number
  ghost?: any
 }


 // http://www.unexplainedstuff.com/Ghosts-and-Phantoms/Famous-Haunted-Houses-and-Places-Epworth-rectory.html
 const epworthRectory = {
  // https://epwortholdrectory.org.uk/epworth-old-rectory-old/visit/virtual-tour/
  rooms: [
    { name: "Entrance Hall", doors: 5, windows: 2 },
    { name: "The Kitchen", doors: 2, windows: 3 },
    { name: "Parlour", doors: 2, windows: 3 },
    { name: "The Nursery", doors: 2, windows: 3 },
    { name: "The Attic", doors: 2, windows: 1 },
    { name: "The Study", doors: 2, windows: 2 },
    { name: "Master Bedroom", doors: 1, windows: 4 },
    { name: "Bedroom 2", doors: 2, windows: 3 }
  ]
 }


 // This code should cause compiler errors
 function haunt(rectory: Rectory) {
  const room = rectory.rooms[Math.floor(Math.random() * rectory.rooms.length)];
  room.ghost = { name: "Old Jeffrey" }
 }
diff --git a/17 ~ Intermediate 4.ts b/17 ~ Intermediate 4.ts
 // You got roped into the cutest halloween competition, judging
 // doggy halloween pet costumes at the annual parade. 

 declare function decideWinner(breed: string, costume: string): { name: string, video: string }
 window.decideWinner = someoneElseDecides

 // Oh, actually you didn't - someone else got to do the fun bit...
 // Though you can watch it on zoom: http://www.tompkinssquaredogrun.com/halloween

 // Instead, you've been asked to help tally up a scoreboard of the most 
 // popular costumes according to the most popular breeds. You've built
 // out a quick implementation below, but it loses type information.

 // Now the contest is over, you feel it's your duty to refactor this
 // code to retain type information - you've heard that the 4.1 beta includes
 // something which helps with typing string manipulation.

 const breeds = ["Hound" , "Corgi" , "Pomeranian"] as const
 const costumes = ["Pumpkin" , "Hot Dog" , "Bumble Bee"] as const

 function tallyPopularWinners(_breeds: typeof breeds, _costumes: typeof costumes) {
  const winners: Record<string, any> = {}

  for (const breed of _breeds) {
    for (const costume of _costumes) {
      const id = `${breed}-${costume}`.toLowerCase()
      winners[id] = decideWinner(breed, costume)
    }
  }

  return winners
 }

 // You can run this example in order to see what the shape of the data looks like, but
 // the result will have keys which are lowercased for every mix of breed and costume, e.g:

 // {
 //     "hound-pumpkin": {...},
 //     "hound-hot dog": {...},
 //     "hound-bumble bee": {...},
 //     "corgi-pumpkin": {...}
 //     ...
 // }

 const winners = tallyPopularWinners(breeds, costumes)
 console.log(winners)

 // Passes
 winners["hound-pumpkin"].name

 // Should fail
 winners["pumpkin-pumpkin"].video

 // Spoilerific tips below:












 // 1: This builds off ideas from day 3, which builds of previous days too





 // 2: The implementation will require an `as` or two alas, but with some
 //    work you can partially find an answer








 // Mainly just adding a quick implementation, so that you can run the 
 // code above without a problem:

 function someoneElseDecides(_breed: string, _costume: string): { name: string, video: string }{
    // Yes, all these dogs have a name which is just a hexcode... hah
    const genRanHex = (size: number) => [...Array(size)].map(() => Math.floor(Math.random() * 16).toString(16)).join('');
    return {
        name: genRanHex(6),
        video: genRanHex(6)
    }
 }
diff --git a/18 ~ Answers 4.md b/18 ~ Answers 4.md
diff --git a/20 ~ Day 5.md b/20 ~ Day 5.md
diff --git a/21 ~ Beginner 5.ts b/21 ~ Beginner 5.ts
 // We have a set of houses on a street which
 // gives out candy and occasionally needs re-stocking.

 // This is an accurate representation of the houses
 // but there's a lot of duplicated code in here, and 
 // you want to create a type which could represent 
 // any house.

 // It looks like the only thing which changes between
 // houses is the return value of `trickOrTreat` and
 // the first parameter of `restock`. 

 // Can you use a generic type to make a `House` type 
 // which has a single argument for the return value 
 // of `trickOrTreat` and the param to `restock`?

 type FirstHouse = {
  doorNumber: 1;
  trickOrTreat(): "book" | "candy";
  restock(items: "book" | "candy"): void;
 };

 type SecondHouse = {
  doorNumber: 2;
  trickOrTreat(): "toothbrush" | "mints";
  restock(items: "toothbrush" | "mints"): void;
 };

 type ThirdHouse = {
  doorNumber: 3;
  trickOrTreat(): "candy" | "apple" | "donuts";
  restock(items: "candy" | "apple" | "donuts"): void;
 };

 type FourthHouse = {
  doorNumber: 4;
  trickOrTreat(): "candy" | "spooky spiders";
  restock(items: "candy" | "spooky spiders"): void;
 };

 type Street = [FirstHouse, SecondHouse, ThirdHouse, FourthHouse];
diff --git a/22 ~ Intermediate 5.ts b/22 ~ Intermediate 5.ts
 // You're part of a team scheduling a movie night, but someone accidentally
 // considered the movie "The Nightmare Before Christmas" to be a halloween 
 // movie, which it really isn't.

 const moviesToShow = {
  halloween: { forKids: false },
  nightmareOnElmStreet: { forKids: false },
  hocusPocus: { forKids: true },
  theWorstWitch: { forKids: true },
  sleepyHollow: { forKids: false }
 } as const

 // They got away with this travesty because you have some `any`s in the 
 // codebase for creating the scheduler. An OK call for a first pass, but
 // we're sharing code with others and want to be explicit.

 function makeScheduler(movies: typeof moviesToShow): any {
  const schedule = {} as any
  for (const movie in Object.keys(movies)) {
    const capitalName = movie.charAt(0).toUpperCase() + movie.slice(1);

    schedule[`getVHSFor${capitalName}`] = () => {}
    schedule[`makePopcornFor${capitalName}`] = () => {}
    schedule[`play${capitalName}`] = () => {}
  }

  return schedule
 }

 // Creates a scheduler
 const movieNight = makeScheduler(moviesToShow)

 // Then all these functions are automatically created 
 movieNight.getVHSForHalloween()
 movieNight.makePopcornForHalloween()
 movieNight.playHalloween()

 // Not a halloween movie! This should be a compiler error
 movieNight.getVHSForNightmareBeforeChristmas()
 movieNight.makePopcornForNightmareBeforeChristmas()
 movieNight.playNightmareBeforeChristmas()

 movieNight.getVHSForHocusFocus()
 movieNight.makePopcornForHocusPocus()
 movieNight.playHocusPocus()



 // Spoilers and part 2 of this challenge are below









 // Clue 1. This challenge builds off the last one, which builds off
 // the last one, etc...








 // Clue 2. These stringly typed function names can probably be handled 
 // with a new feature from TypeScript 4.1











 // **Part two**

 // You have the code to organize the same schedule, but with only kids movies.
 // It'd be great if you could apply the same types - but only when a movie
 // has been declared to be a kids movie.


 function makeKidScheduler(movies: typeof moviesToShow): any {
  const schedule = {} as any
  for (const movie in Object.keys(movies)) {
    // @ts-ignore
    if (moviesToShow[movie].forKids) {
      const capitalName = movie.charAt(0).toUpperCase() + movie.slice(1);

      schedule[`getVHSFor${capitalName}`] = () => {}
      schedule[`makePopcornFor${capitalName}`] = () => {}
      schedule[`play${capitalName}`] = () => {}
    }
  }

  return schedule
 }

 // Then when we have an object which uses these types
 const kidsMovieNight = makeKidScheduler(moviesToShow)

 // Should fail
 kidsMovieNight.getVHSForHalloween()
 kidsMovieNight.playHalloween()

 // Should pass
 kidsMovieNight.getVHSForHocusFocus()
 kidsMovieNight.makePopcornForHocusPocus()
 kidsMovieNight.playHocusPocus()




 // Spoiler clues below







 // 1. You can re-use your template literal types, but you need a new mapped type.









 // 2. Finding the right spot for your conditional is tricky, but there aren't too many positions
 //    where you can use them.









 // 3. You may need to apply additional contraints to your mapped type from the first one
diff --git a/23 ~ Answers 5.md b/23 ~ Answers 5.md
	// You're making an app which connects to a database
	// of local ghosts and their favourite haunts.

	// You are creating the client which connects to that database,
	// and you have an API response generated for you automatically.

	// When you start trying to display the hauntings, you realize
	// that you don't know how to type the parameter and just use `any`.

	// `any` has its place, but a colleague recommended that you can
	// use 'Indexed Types' to remove the 'any' without changing the
	// GhostAPIResponse type.

	type GhostAPIResponse = {
	name: string
	birthDate?: string
	deathDate?: string
	bio: string

	hauntings: Array<{ title: string, provenance: string, location: string }>
	}

	const displayGhost = (ghost: GhostAPIResponse) => {
	console.log(`Name: ${ghost.name}`)
	if (ghost.birthDate) console.log(`Birthday: ${ghost.birthDate}`)
	if (ghost.deathDate) console.log(`Died: ${ghost.deathDate}`)
	console.log(`\nBio: ${ghost.bio}`)

	console.log(`\nArtworks:`)
	ghost.hauntings.forEach(artwork => {
	displayHauntings(artwork)
	})
	}

	// Your goal: remove this any, without changing GhostAPIResponse
	const displayHauntings = (haunting: any) => {
	console.log(` - Title: ${haunting.title}`)
	console.log(` ${haunting.location}`)
	console.log(` ${haunting.provemance}`)
	}
	// Your kids have returned home with a whole bag
	// full of halloween loot, and you've taken the time to
	// make a description of all of them:

	type SnackBars = {
	name: "Short Chocolate Bars"
	amount: 4
	candy: true
	}

	type Gumballs = {
	name: "Gooey Gumballs"
	color: "green" \| "purples"
	candy: true
	}

	type Apples = {
	name: "Apples"
	candy: true
	}

	type Cookies = {
	name: "Cookies"
	candy: true
	peanuts: true
	}

	type SnickersBar = {
	name: "Snickers Bar"
	candy: true
	peanuts: true
	}

	type Toothpaste = {
	name: "Toothpaste"
	minty: true
	trick: true
	}

	type Pencil = {
	name: "Pencil"
	trick: true
	}

	// You create a single pile of all the results, and want to use
	// this to share out the winnings among your kids.

	type ResultsFromHalloween = SnackBars \| Gumballs \| Apples \| SnickersBar \| Cookies \| Toothpaste \| Pencil

	// You're first going to need to separate out the candy from the treats,
	// you can do that via conditional types.

	// type AllCandies = ...
	// type AllTricks = ...

	// Almost there, but little 'Bobby Tables' cannot have peanuts. Can
	// you make a list of candies just for him?

	// type AllCandiesWithoutPeanuts = ...
	// You've been keeping a diary of your trick or treat
	// results for your street, they generally fall into
	// three categories: treats, tricks and no-shows.

	// Can you make three types which can describe of
	// these results?

	const treats = [
	{ location: "House 1", result: "treat", treat: { candy: "Lion Bar" } },
	{ location: "House 3", result: "treat", treat: { candy: "Mars Bar" } },
	{ location: "House 4", result: "treat", treat: { baked: "Cookies", candy: "Reese's" } }
	]

	const tricks = [
	{ location: "House 2", result: "trick", trick: "Magic" },
	{ location: "House 7", result: "trick", trick: "Surprised" }
	]

	const noShows = [
	{ location: "House 6", result: "no-show" }
	]

	// Now that you have the types, can you make them
	// not duplicate 'location' and 'result' by using
	// a union for 'result' and a new intersection type?
	// Dang, COVID19 has really put a bind on the nature of trick or treating.
	// Your block has opt-ed to instead do a trunk or treat instead.

	// In a rush to prepare for the event, you hardcoded the
	// results into the 'TrunkOrTreatResults' type which is already
	// out of date - it's missing a few properties!
	// Can you rewrite 'TrunkOrTreatResults' as an object type that
	// stays in sync with the strings in 'trunkOrTreatSpots'?

	const trunkOrTreatSpots = [
	'The Park',
	'House #1',
	'House #2',
	'Corner Shop',
	'Place of Worship',
	] as const


	type TrunkOrTreatResults = {
	"The Park": {
	done: boolean,
	who: string,
	loot: Record<string, any>
	},
	"House #1" : {
	done: boolean,
	who: string,
	loot: Record<string, any>
	},
	"House #2": {
	done: boolean,
	who: string,
	loot: Record<string, any>
	}
	}

	function makeTODO(spots: typeof trunkOrTreatSpots): TrunkOrTreatResults {
	return spots.reduce((prev, current) => {
	return {
	...prev,
	[current]: {
	done: false,
	loot: {},
	who: ""
	}
	}
	}, {} as TrunkOrTreatResults)
	}

	// You can preview the results via "Run" above

	const todo = makeTODO(trunkOrTreatSpots)
	console.log(todo)

	// Works
	todo["The Park"].done = true

	// Should Work
	todo["Corner Shop"].loot = {}

	// Fails
	todo["House #3"].done = false


	// Spoiler-ish optional tips are a few lines below this











	// Warning: Spoilers


	// 1. This is a mapped types problem





	// 2. There is a constraint on the mapped type argument





	// 3. You can re-use a part of the technique from the beginner challenge 1 to get the exact keys from
	// the array: https://dev.to/typescript/type-treat-challenge-2-3n16
	// No-one knows what is going on, but you think your workplace
	// is haunted by a poltergeist. It kinda sucks.
	//
	// Your objects keep getting changed behind the scenes,
	// stop this from happening by making your objects readonly
	// to stop this spooky behavior.

	type Rectory = {
	rooms: Room[]
	noises: any[]
	}

	type Room = {
	name: string
	doors: number
	windows: number
	ghost?: any
	}


	// http://www.unexplainedstuff.com/Ghosts-and-Phantoms/Famous-Haunted-Houses-and-Places-Epworth-rectory.html
	const epworthRectory = {
	// https://epwortholdrectory.org.uk/epworth-old-rectory-old/visit/virtual-tour/
	rooms: [
	{ name: "Entrance Hall", doors: 5, windows: 2 },
	{ name: "The Kitchen", doors: 2, windows: 3 },
	{ name: "Parlour", doors: 2, windows: 3 },
	{ name: "The Nursery", doors: 2, windows: 3 },
	{ name: "The Attic", doors: 2, windows: 1 },
	{ name: "The Study", doors: 2, windows: 2 },
	{ name: "Master Bedroom", doors: 1, windows: 4 },
	{ name: "Bedroom 2", doors: 2, windows: 3 }
	]
	}


	// This code should cause compiler errors
	function haunt(rectory: Rectory) {
	const room = rectory.rooms[Math.floor(Math.random() * rectory.rooms.length)];
	room.ghost = { name: "Old Jeffrey" }
	}
	// You got roped into the cutest halloween competition, judging
	// doggy halloween pet costumes at the annual parade.

	declare function decideWinner(breed: string, costume: string): { name: string, video: string }
	window.decideWinner = someoneElseDecides

	// Oh, actually you didn't - someone else got to do the fun bit...
	// Though you can watch it on zoom: http://www.tompkinssquaredogrun.com/halloween

	// Instead, you've been asked to help tally up a scoreboard of the most
	// popular costumes according to the most popular breeds. You've built
	// out a quick implementation below, but it loses type information.

	// Now the contest is over, you feel it's your duty to refactor this
	// code to retain type information - you've heard that the 4.1 beta includes
	// something which helps with typing string manipulation.

	const breeds = ["Hound" , "Corgi" , "Pomeranian"] as const
	const costumes = ["Pumpkin" , "Hot Dog" , "Bumble Bee"] as const

	function tallyPopularWinners(_breeds: typeof breeds, _costumes: typeof costumes) {
	const winners: Record<string, any> = {}

	for (const breed of _breeds) {
	for (const costume of _costumes) {
	const id = `${breed}-${costume}`.toLowerCase()
	winners[id] = decideWinner(breed, costume)
	}
	}

	return winners
	}

	// You can run this example in order to see what the shape of the data looks like, but
	// the result will have keys which are lowercased for every mix of breed and costume, e.g:

	// {
	// "hound-pumpkin": {...},
	// "hound-hot dog": {...},
	// "hound-bumble bee": {...},
	// "corgi-pumpkin": {...}
	// ...
	// }

	const winners = tallyPopularWinners(breeds, costumes)
	console.log(winners)

	// Passes
	winners["hound-pumpkin"].name

	// Should fail
	winners["pumpkin-pumpkin"].video

	// Spoilerific tips below:












	// 1: This builds off ideas from day 3, which builds of previous days too





	// 2: The implementation will require an `as` or two alas, but with some
	// work you can partially find an answer








	// Mainly just adding a quick implementation, so that you can run the
	// code above without a problem:

	function someoneElseDecides(_breed: string, _costume: string): { name: string, video: string }{
	// Yes, all these dogs have a name which is just a hexcode... hah
	const genRanHex = (size: number) => [...Array(size)].map(() => Math.floor(Math.random() * 16).toString(16)).join('');
	return {
	name: genRanHex(6),
	video: genRanHex(6)
	}
	}
	// We have a set of houses on a street which
	// gives out candy and occasionally needs re-stocking.

	// This is an accurate representation of the houses
	// but there's a lot of duplicated code in here, and
	// you want to create a type which could represent
	// any house.

	// It looks like the only thing which changes between
	// houses is the return value of `trickOrTreat` and
	// the first parameter of `restock`.

	// Can you use a generic type to make a `House` type
	// which has a single argument for the return value
	// of `trickOrTreat` and the param to `restock`?

	type FirstHouse = {
	doorNumber: 1;
	trickOrTreat(): "book" \| "candy";
	restock(items: "book" \| "candy"): void;
	};

	type SecondHouse = {
	doorNumber: 2;
	trickOrTreat(): "toothbrush" \| "mints";
	restock(items: "toothbrush" \| "mints"): void;
	};

	type ThirdHouse = {
	doorNumber: 3;
	trickOrTreat(): "candy" \| "apple" \| "donuts";
	restock(items: "candy" \| "apple" \| "donuts"): void;
	};

	type FourthHouse = {
	doorNumber: 4;
	trickOrTreat(): "candy" \| "spooky spiders";
	restock(items: "candy" \| "spooky spiders"): void;
	};

	type Street = [FirstHouse, SecondHouse, ThirdHouse, FourthHouse];
	// You're part of a team scheduling a movie night, but someone accidentally
	// considered the movie "The Nightmare Before Christmas" to be a halloween
	// movie, which it really isn't.

	const moviesToShow = {
	halloween: { forKids: false },
	nightmareOnElmStreet: { forKids: false },
	hocusPocus: { forKids: true },
	theWorstWitch: { forKids: true },
	sleepyHollow: { forKids: false }
	} as const

	// They got away with this travesty because you have some `any`s in the
	// codebase for creating the scheduler. An OK call for a first pass, but
	// we're sharing code with others and want to be explicit.

	function makeScheduler(movies: typeof moviesToShow): any {
	const schedule = {} as any
	for (const movie in Object.keys(movies)) {
	const capitalName = movie.charAt(0).toUpperCase() + movie.slice(1);

	schedule[`getVHSFor${capitalName}`] = () => {}
	schedule[`makePopcornFor${capitalName}`] = () => {}
	schedule[`play${capitalName}`] = () => {}
	}

	return schedule
	}

	// Creates a scheduler
	const movieNight = makeScheduler(moviesToShow)

	// Then all these functions are automatically created
	movieNight.getVHSForHalloween()
	movieNight.makePopcornForHalloween()
	movieNight.playHalloween()

	// Not a halloween movie! This should be a compiler error
	movieNight.getVHSForNightmareBeforeChristmas()
	movieNight.makePopcornForNightmareBeforeChristmas()
	movieNight.playNightmareBeforeChristmas()

	movieNight.getVHSForHocusFocus()
	movieNight.makePopcornForHocusPocus()
	movieNight.playHocusPocus()



	// Spoilers and part 2 of this challenge are below









	// Clue 1. This challenge builds off the last one, which builds off
	// the last one, etc...








	// Clue 2. These stringly typed function names can probably be handled
	// with a new feature from TypeScript 4.1











	// Part two

	// You have the code to organize the same schedule, but with only kids movies.
	// It'd be great if you could apply the same types - but only when a movie
	// has been declared to be a kids movie.


	function makeKidScheduler(movies: typeof moviesToShow): any {
	const schedule = {} as any
	for (const movie in Object.keys(movies)) {
	// @ts-ignore
	if (moviesToShow[movie].forKids) {
	const capitalName = movie.charAt(0).toUpperCase() + movie.slice(1);

	schedule[`getVHSFor${capitalName}`] = () => {}
	schedule[`makePopcornFor${capitalName}`] = () => {}
	schedule[`play${capitalName}`] = () => {}
	}
	}

	return schedule
	}

	// Then when we have an object which uses these types
	const kidsMovieNight = makeKidScheduler(moviesToShow)

	// Should fail
	kidsMovieNight.getVHSForHalloween()
	kidsMovieNight.playHalloween()

	// Should pass
	kidsMovieNight.getVHSForHocusFocus()
	kidsMovieNight.makePopcornForHocusPocus()
	kidsMovieNight.playHocusPocus()




	// Spoiler clues below







	// 1. You can re-use your template literal types, but you need a new mapped type.









	// 2. Finding the right spot for your conditional is tricky, but there aren't too many positions
	// where you can use them.









	// 3. You may need to apply additional contraints to your mapped type from the first one