Let's say we are writing DB model for `Post`, and because database stores everything as string we need to write `parse` function that would take raw DB object and cast it to proper `Post` interface.

To reproduce set `noImplicitReturns: true`

```
interface Post {
  id:   number
  text: string
}

function parse<K extends keyof Post>(k: K, v: any): Post[K] {
  switch(k) {
    case 'id':   return parseInt(v)
    case 'text': return v.toString()
  }
}

```

There are two errors in that code. First - it won't compile, it seems like TypeScript didn't realises that our code is correct and ask for `default` statement to be added to the `switch`. 

The second error - it won't detect that you are checking against wrong value. The wrong code below would compile without errors

```
function parse<K extends keyof Post>(k: K, v: any): Post[K] {
  switch(k) {
    case 'id':   return parseInt(v)
    case 'text': return v.toString()
    case 'some': return v.toString() // <= error, no `some` key
    default: return ''               // <= this line is not needed
  }
}

```

There's even third error, TypeScript would allow to return wrong value for the key, this wrong code would compile

```
function parse<K extends keyof Post>(k: K, v: any): Post[K] {
  switch(k) {
    case 'id':   return parseInt(v)
    case 'text': return 2 // <= error, it should be string, not number
    default: return ''
  }
}

```

Are those TypeScript limitations or I'm dong something wrong?