According to PEP 589 you can use alternative syntax to create a TypedDict as follows: Movie = TypedDict(‘Movie’, {‘name’: str, ‘year’: int}) So, in your case, you could write: from typing import TypedDict RandomAlphabet = TypedDict(‘RandomAlphabet’, {‘A(2)’: str}) or for the second example: RandomAlphabet = TypedDict(‘RandomAlphabet’, {‘return’: str}) PEP 589 warns, though: This syntax doesn’t … Read more
Yes, this is standard practice in academic literature. To understand it, it helps to know that the notion of “type” was invented in the 1930s, in the context of lambda calculus (in fact, even earlier, in the context of set theory). Since then, a whole branch of computational logic has emerged that is known as … Read more
For an example of how to apply Brian’s answer: with a TypeVar: from typing import TypeVar AnyA = TypeVar(“AnyA”, bound=”A”) class A: def __init__(self): print(“A”) self.hello = “hello” @classmethod def bobo(cls: type[AnyA]) -> AnyA: return cls() class B(A): def __init__(self): print(“B”) super().__init__() self.world = “world” reveal_type(B.bobo()) # B with Self: from typing import Self class … Read more
There’s also ‘paredit. The cheat sheet shows you all the commands available. happen to like it better than the electric mode suggested in another answer. Though paredit does only apply to (), so it may not meed your needs. But, to be honest, there’s a bunch of packages surrounding parenthesis. The wiki has them all … Read more
To do that you need to extract props interface from children component (and preferably also parent) and use it this way: interface ParentProps { children: ReactElement<ChildrenProps> | Array<ReactElement<ChildrenProps>>; } so in your case it would look like this: interface IMenu { children: ReactElement<IMenuItem> | Array<ReactElement<IMenuItem>>; } const MenuItem: React.FunctionComponent<IMenuItem> = ({ props }) => { … Read more
There is no way to define such a type. There is a proposal on GitHub to support this, but it currently does not appear to be a priority. Vote on it and maybe the team might include it in a future release. Edit Starting in 4.1 you can define a type that would validate the … Read more
A simple approach: const elsTyper = document.querySelectorAll(“[data-typer]”); const rand = (min, max) => Math.floor(Math.random() * (max – min + 1) + min); const typer = (el) => { const text = el.dataset.typer; const tot = text.length; let ch = 0; (function typeIt() { if (ch > tot) return; el.textContent = text.substring(0, ch++); setTimeout(typeIt, rand(60, 300)); … Read more
PEP 0484 – Type Hints – The problem of forward declarations addresses the issue: The problem with type hints is that annotations (per PEP 3107 , and similar to default values) are evaluated at the time a function is defined, and thus any names used in an annotation must be already defined when the function … Read more
It wasn’t possible before but luckily it is now, since TypeScript version 2.1. It has been released on the 7th of December 2016 and it introduces indexed access types also called lookup types. The syntax looks exactly like element access but written in place of types. So in your case: interface I1 { x: any; … Read more
Both approaches are valid. If your function uses conditional types in the return it will need to use type assertions, as typescript will not try to reason about the conditional type since it contains a free type parameter: function dependsOnParameter<B extends boolean>(x: B): B extends true ? number : string { if (x) { return … Read more