Actual examples

Author: emptybutton

README.md

@@ -4,71 +4,83 @@ Structures your annotations and puts more information into them.
 ### Installation
 `pip install pyannotating`
 
-### Features
-You can create a template of your annotations
+### Examples
+Create annotation templates
 ```python
-from pyannotating import *
 from typing import Callable, Any, Optional, Iterable
 
+from pyannotating import *
+
+
 handler_of = AnnotationTemplate(Callable, [[input_annotation], Any])
-```
-and then create an annotation by this template
-```python
 handler_of[int | float]
 ```
-
-what is equivalent
 ```python
 Callable[[int | float], Any]
 ```
 
-Also you can nest templates inside each other
+in a nested way
 ```python
-optional_handler_of = AnnotationTemplate(
+optional_reformer_of = AnnotationTemplate(
     Callable,
     [[input_annotation], AnnotationTemplate(Optional, [input_annotation])]
 )
 
-optional_handler_of[int]
+optional_reformer_of[int]
 ```
-
-what results in
 ```python
 Callable[[int], Optional[int]]
 ```
 
-and use input_annotation in conjunction with something else
+with non-strict input annotation
 ```python
 summator_of = AnnotationTemplate(Callable, [[input_annotation | int, input_annotation], int])
 summator_of[float]
 ```
-
-to get
 ```python
 Callable[[float | int, float], int]
 ```
 
-In addition, you can integrate comments with your annotations
+Integrate comments into annotations
 ```python
 even = FormalAnnotation("Formal annotation of even numbers.")
 
 number: even[int | float] = 42
 ```
 
-or annotate downcasts
+or subgroups of existing types
 ```python
-def transform(collection: Special[range, Iterable]) -> Any:
-    ...
+natural_numbers = Subgroup(int, lambda number: number > 0)
+
+isinstance(14, natural_numbers)
+isinstance(-1.2, natural_numbers)
+
+64 in natural_numbers
+```
+```python
+True
+False
+True
 ```
 
-or just use some pre-made templates
+or downcasts
 ```python
-many_or_one[Callable]
-method_of[int]
+def transform(numbers: Special[range, Iterable[int]], additional: Special[None] = None) -> Any:
+    ...
+
+# Equals to
+
+def transform(numbers: Iterable[int], additional: Any = None) -> Any:
+    ...
 ```
 
-for getting
+
+or just some pre-made templates and annotations
+```python
+many_or_one[int | float]
+number
+```
 ```python
-Callable | Iterable[Callable]
-Callable[[int, ...], Any]
+int | float | Iterable[int | float]
+int | float | complex
 ```