Update README.md

Author: AntonOresten

README.md

@@ -7,7 +7,7 @@
 
 Einops.jl is a Julia implementation of the [einops](https://einops.rocks) Python package, providing an elegant and intuitive notation for tensor operations. Einops offers a unified way to perform Julia's `reshape` and `permutedims`, with plans for also implementing `reduce` and `repeat`.
 
-The Python implementation uses strings to specify the operation, but in Julia, that would be tricky to compile, so for parity a string macro `@einops_str` is exported, e.g. `einops"a 1 b c -> (c b) a"`, which expands to the form `(:a, 1, :b, :c,) --> ((:c, :b), :a)` where `-->` is an operator that creates an `Einops.Pattern{(:a, 1, :b, :c), ((:c, :b), :a)}`, allowing for compile-time awareness of dimensionalities and permutations—this is not yet taken advantage of, since the tuple types are sufficient for at least ensuring type stability (see [Roadmap](#Roadmap)).
+The Python implementation uses strings to specify the operation, but that would be tricky to compile in Julia, so a string macro `@einops_str` is exported for parity, e.g. `einops"a 1 b c -> (c b) a"`, which expands to the form `(:a, 1, :b, :c,) --> ((:c, :b), :a)` where `-->` is an operator that creates an `Einops.Pattern{(:a, 1, :b, :c), ((:c, :b), :a)}`, allowing for compile-time awareness of dimensionalities and permutations—this is not yet taken advantage of, since the tuple types are sufficient for at least ensuring type stability (see [Roadmap](#Roadmap)).
 
 ## Operations
 
@@ -17,22 +17,16 @@ The `rearrange` combines reshaping and permutation operations into a single, exp
 
 ```julia
 # Example from Python API
-# no-op:
-images = randn(32, 30, 40, 3) # batch, height, width, channel
-rearranged_images = rearrange(images, (:b, :h, :w, :c) --> (:b, :h, :w, :c))
-@assert size(rearranged_images) == (32, 30, 40, 3)
+images = randn(32, 30, 40, 3); # batch, height, width, channel
 
 # reorder axes to "b c h w" format:
-rearranged_images = rearrange(images, (:b, :h, :w, :c) --> (:b, :c, :h, :w))
-@assert size(rearranged_images) == (32, 3, 30, 40)
+rearrange(images, (:b, :h, :w, :c) --> (:b, :c, :h, :w)) # (32, 3, 30, 40)
 
 # flatten each image into a vector
-flattened_images = rearrange(images, (:b, :h, :w, :c) --> (:b, (:c, :h, :w)))
-@assert size(flattened_images) == (32, 30*40*3)
+rearrange(images, (:b, :h, :w, :c) --> (:b, (:h, :w, :c))) # (32, 30*40*3)
 
 # split each image into 4 smaller (top-left, top-right, bottom-left, bottom-right), 128 = 32 * 2 * 2
-four_smaller_images = rearrange(images, (:b, (:h1, :h), (:w1, :w), :c) --> ((:b, :h1, :w1), :h, :w, :c), h1=2, w1=2)
-@assert size(four_smaller_images) (128, 15, 20, 3)
+rearrange(images, (:b, (:h1, :h), (:w1, :w), :c) --> ((:b, :h1, :w1), :h, :w, :c), h1=2, w1=2) # (128, 15, 20, 3)
 ```
 
 ### `reduce` (Planned)
@@ -42,7 +36,7 @@ The `reduce` function will allow for applying reduction operations (like `sum`,
 ```julia
 # Example (conceptual):
 x = randn(100, 32, 64)
-y = reduce(maximum, x, (:t, :b, :c) --> (:b, :c)) # Max-reduction on the first axis
+y = reduce(maximum, x, (:t, :b, :c) --> (:b, :c)) # max-reduction on the first axis
 ```
 
 ### `repeat` (Planned)