Add three new challenges (laike9m#12)

Author: RF-Tar-Railt

challenges/advanced-overload-generic/question.py

@@ -0,0 +1,26 @@
+"""
+TODO:
+
+foo is a function that returns an interger when called with Foo[int], returns a string when called with Foo[str], otherwise returns a Foo[T].
+"""
+from typing import TypeVar, Generic
+
+T = TypeVar('T')
+
+class Foo(Generic[T]):
+    a: T
+
+def foo(value: Foo):
+    ...
+
+
+def should_pass():
+    foo(Foo[int]()).bit_length()
+    foo(Foo[str]()).upper()
+    foo(Foo[list]()).a.append(1)
+
+
+def should_fail():
+    foo(Foo[int]()).upper()
+    foo(Foo[str]()).bit_length()
+    foo(Foo[list]()).bit_length()

challenges/advanced-overload-generic/solution.py

@@ -0,0 +1,38 @@
+"""
+TODO:
+
+foo is a function that returns an interger when called with Foo[int], returns a string when called with Foo[str], otherwise returns a Foo[T].
+"""
+from typing import Any, TypeVar, Generic, overload
+
+T = TypeVar('T')
+
+class Foo(Generic[T]):
+    a: T
+
+@overload
+def foo(value: Foo[int]) -> int:
+    ...
+
+@overload
+def foo(value: Foo[str]) -> str:
+    ...
+
+@overload
+def foo(value: Foo[T]) -> Foo[T]:
+    ...
+
+def foo(value: Foo) -> Any:
+    ...
+
+
+def should_pass():
+    foo(Foo[int]()).bit_length()
+    foo(Foo[str]()).upper()
+    foo(Foo[list]()).a.append(1)
+
+
+def should_fail():
+    foo(Foo[int]()).upper()
+    foo(Foo[str]()).bit_length()
+    foo(Foo[list]()).bit_length()

challenges/advanced-overload-literal/question.py

@@ -0,0 +1,23 @@
+"""
+TODO:
+
+foo is a function that returns an interger when second argument is 1, returns a string when second argument is 2, returns a list when second argument is 3, otherwise it returns inputs self.
+"""
+
+
+def foo(value, flag):
+    ...
+
+
+def should_pass():
+    foo("42", 1).bit_length()
+    foo(42, 2).upper()
+    foo(True, 3).append(1)
+    foo({}, "4").keys()
+
+
+def should_fail():
+    foo("42", 1).upper()
+    foo(42, 2).append(1)
+    foo(True, 3).bit_length()
+    foo({}, "4").upper()

challenges/advanced-overload-literal/solution.py

@@ -0,0 +1,42 @@
+"""
+TODO:
+
+foo is a function that returns an interger when second argument is 1, returns a string when second argument is 2, returns a list when second argument is 3, otherwise it returns inputs self.
+"""
+from typing import Any, Literal, overload, TypeVar
+
+T = TypeVar('T')
+
+@overload
+def foo(value: Any, flag: Literal[1]) -> int:
+    ...
+
+@overload
+def foo(value: Any, flag: Literal[2]) -> str:
+    ...
+
+@overload
+def foo(value: Any, flag: Literal[3]) -> list:
+    ...
+
+@overload
+def foo(value: T, flag: Any) -> T:
+    ...
+
+
+def foo(value, flag) -> Any:
+    ...
+
+
+def should_pass():
+    foo("42", 1).bit_length()
+    foo(42, 2).upper()
+    foo(True, 3).append(1)
+    foo({}, "4").keys()
+
+
+def should_fail():
+    foo("42", 1).upper()
+    foo(42, 2).append(1)
+    foo(True, 3).bit_length()
+    foo({}, "4").upper()

challenges/extreme-constructor-parameter/question.py

@@ -0,0 +1,36 @@
+"""
+TODO:
+
+Define a decorator `constructor_parameter` that accepts the type of Foo.
+and return a wrapper function with the same signature as the constructor of Foo, 
+and function decorated by `constructor_parameter` can be called with an instance of Foo.
+"""
+
+class Foo:
+    a: int
+    b: str
+
+    def __init__(self, a: int, b: str) -> None:
+        ...
+
+def constructor_parameter():
+    ...
+
+
+def should_pass():
+    @constructor_parameter(Foo)
+    def func(foo: Foo) -> list[Foo]:
+        ...
+
+    res = func(1, "2")
+    res[0].a.bit_length()
+    res[0].b.upper()
+
+
+def should_fail():
+    @constructor_parameter(Foo)
+    def func(foo: Foo) -> list:
+        ...
+
+    func("1", "2")
+    func([1, 2, 3])

challenges/extreme-constructor-parameter/solution.py

@@ -0,0 +1,43 @@
+"""
+TODO:
+
+Define a decorator `constructor_parameter` that accepts the type of Foo.
+and return a wrapper function with the same signature as the constructor of Foo, 
+and function decorated by `constructor_parameter` can be called with an instance of Foo.
+"""
+from typing import TypeVar, Callable
+from typing_extensions import ParamSpec, Concatenate
+
+class Foo:
+    a: int
+    b: str
+
+    def __init__(self, a: int, b: str) -> None:
+        ...
+
+T = TypeVar('T')
+P = ParamSpec('P')
+R = TypeVar('R')
+
+
+def constructor_parameter(cls: Callable[P, T]) -> Callable[[Callable[[T], R]], Callable[P, R]]:
+    ...
+
+
+def should_pass():
+    @constructor_parameter(Foo)
+    def func(foo: Foo) -> list[Foo]:
+        ...
+
+    res = func(1, "2")
+    res[0].a.bit_length()
+    res[0].b.upper()
+
+
+def should_fail():
+    @constructor_parameter(Foo)
+    def func(foo: Foo) -> list:
+        ...
+
+    func("1", "2")
+    func([1, 2, 3])