rulebook | Lets you define methods with regex for dynamic methods

You are missing a class that matches the list of Species that your JSON contains:

You can directly convert the DataFrame into HTML. And Use safe filter inside Jinja like {pd_data|safe}

The keyword is "from".

The player does not exit a container, player exits from a container.

Here's the same code, this time with "exiting from" and it works.

You made it more complicated that it needed to be :)

I also suggest you to remove the absolute positioning, negative margins, table-cell display and z-index, which are not necessary.

Code optimazation usually belongs to the code review site. Just a few inputs...

Not sure if I got all your intentions but this approach seems to be overly complicated.

1. Just have one object that represents your board, I'd chose a List[List] and then instead of mapping a character to each field (what limits you in your field size) let the user input two integers to identify the chosen field.
2. No need to keep track of the played items in another list, just check if the field in your board is still playable.
3. I'd reduce the use of global variables in functions to a minimum, this allows you to e.g. move them to separate files.
4. You do a lot of unesseccary type conversions, why does move have to be of type List?

Or your valid_move could be simplified to

I spent a long time trying to write out the mechanical explanation for why particular expressions like expr1 || expr2 && expr3 act as type guards in certain situations and not in others. It ended up becoming several pages and still didn't account for all the cases in your examples. If you care you can look at the code implemented for expression operators in microsoft/TypeScript#7140.

A more high-level explanation for why this limitation and ones like it exist: when you, a human being, sees a value of a union type, you can decide to analyze it by imagining what would happen if the value were narrowed to each member of that type, for the entire scope where that value exists. If your code behaves well for each such case analysis, then it behaves well for the full union. This decision is presumably made based on how much you care about the behavior of the code in question, or some other cognitive process that we cannot hope to reproduce by a compiler.

The compiler could possibly do this analysis all the time, for every possible union-typed expression it encountered. We could call this "automatic distributive control flow analysis" and it would have the benefit of nearly always producing the type guard behavior you want. The drawback is that the compiler would require more memory and time than you'd be willing to spend, and possibly more than humanity is able to spend due to the combinatorial explosion that happens as each additional union-typed expression has a multiplicative effect on required resources. Exponential-time algorithms don't make for good compilers.

At times I've wanted to be able to hint to the compiler that a particular union-typed value in a particular scope should be analyzed this way, and I even filed a request for such "opt-in distributive control flow analysis", (see microsoft/TypeScript#25051), but even this would require a lot of development effort to implement and would deviate from the TS design goals of enabling JS design patterns without requiring the developer to think too hard about control flow analysis.

So in the end, what TypeScript language designers do is to implement heuristics that perform such analysis in limited scopes that enable conventional and idiomatic JavaScript coding patterns. If code like (a ?? null) && fs(a) is not considered idiomatic and conventional enough for the language designers (this is partially subjective and partially depending on examining a corpus of real-world code), and if implementing it would result in a major compiler performance penalty, then I wouldn't expect the language to support it.

Some examples:

• microsoft/TypeScript#12184: support "saving" the result of a type guard into a constant (like your something example) for later use. This is an open suggestion marked as "revisit" with the ominous proclamation by a language architect that it would be difficult to do it in a performant manner. This might be idiomatic, but it might be hard to implement effectively.

• microsoft/TypeScript#37258: support successive type guards where narrowings are performed on multiple correlated variables at once. It's closed as too complex because to avoid an exponential-time algorithm you'd need to hardcode it to some small number of checks which wouldn't be very beneficial in general. The suggestion by the language maintainers: use more idiomatic checks.

So that's the closest I can get to an authoritative or official answer on this. Hope it helps; good luck!