convert to 4 spaces

Author: Alan-95-hub

README.md

@@ -70,26 +70,26 @@ To read a text file in UTF-8:
 
 ```java
 String text = new TextOf(
-  new File("/code/a.txt")
+    new File("/code/a.txt")
 ).asString();
 ```
 
 To write a text into a file:
 
 ```java
 new LengthOf(
-  new TeeInput(
-    "Hello, world!",
-    new File("/code/a.txt")
-  )
+    new TeeInput(
+        "Hello, world!",
+        new File("/code/a.txt")
+    )
 ).value();
 ```
 
 To read a binary file from classpath:
 
 ```java
 byte[] data = new BytesOf(
-  new ResourceOf("foo/img.jpg")
+    new ResourceOf("foo/img.jpg")
 ).asBytes();
 ```
 
@@ -99,8 +99,8 @@ To format a text:
 
 ```java
 String text = new FormattedText(
-  "How are you, %s?",
-  name
+    "How are you, %s?",
+    name
 ).asString();
 ```
 
@@ -109,11 +109,11 @@ To manipulate with a text:
 ```java
 // To lower case
 new Lowered(
-	new TextOf("Hello")
+    new TextOf("Hello")
 );
 // To upper case
 new Upper(
-	new TextOf("Hello")
+    new TextOf("Hello")
 );
 ```
 
@@ -125,53 +125,53 @@ To filter a collection:
 
 ```java
 Collection<String> filtered = new ListOf<>(
-  new Filtered<>(
-    s -> s.length() > 4,
-    new IterableOf<>("hello", "world", "dude")
-  )
+    new Filtered<>(
+        s -> s.length() > 4,
+        new IterableOf<>("hello", "world", "dude")
+    )
 );
 ```
 
 To flatten one iterable:
 ```java
 new Joined<>(
-  new Mapped<IterableOf>(
-    iter -> new IterableOf<>(
-      new ListOf<>(iter).toArray(new Integer[]{})
-    ),
-    new IterableOf<>(1, 2, 3, 4, 5, 6)
-  )
+    new Mapped<IterableOf>(
+        iter -> new IterableOf<>(
+            new ListOf<>(iter).toArray(new Integer[]{})
+        ),
+        new IterableOf<>(1, 2, 3, 4, 5, 6)
+    )
 );    // Iterable<Integer>
 ```
 
 To flatten and join several iterables:
 ```java
 new Joined<>(
-  new Mapped<IterableOf>(
-    iter -> new IterableOf<>(
-      new Joined<>(iter)
-    ),
-    new Joined<>(
-      new IterableOf<>(new IterableOf<>(1, 2, 3)),
-      new IterableOf<>(new IterableOf<>(4, 5, 6))
+    new Mapped<IterableOf>(
+        iter -> new IterableOf<>(
+            new Joined<>(iter)
+        ),
+        new Joined<>(
+            new IterableOf<>(new IterableOf<>(1, 2, 3)),
+            new IterableOf<>(new IterableOf<>(4, 5, 6))
+        )
     )
-  )
 );    // Iterable<Integer>
 ```
 
 To iterate a collection:
 
 ```java
 new And(
-  new Mapped<>(
-    new FuncOf<>(
-      input -> {
-        System.out.printf("Item: %s\n", input);
-      },
-      new True()
-    ),
-    new IterableOf<>("how", "are", "you", "?")
-  )
+    new Mapped<>(
+        new FuncOf<>(
+            input -> {
+                System.out.printf("Item: %s\n", input);
+            },
+            new True()
+        ),
+        new IterableOf<>("how", "are", "you", "?")
+    )
 ).value();
 ```
 
@@ -189,25 +189,25 @@ To sort a list of words in the file:
 
 ```java
 List<Text> sorted = new ListOf<>(
-  new Sorted<>(
-    new Mapped<>(
-      text -> new ComparableText(text),
-      new Split(
-        new TextOf(
-          new File("/tmp/names.txt")
-        ),
-        new TextOf("\\s+")
-      )
+    new Sorted<>(
+        new Mapped<>(
+            text -> new ComparableText(text),
+            new Split(
+                new TextOf(
+                    new File("/tmp/names.txt")
+                ),
+                new TextOf("\\s+")
+            )
+        )
     )
-  )
 );
 ```
 
 To count elements in an iterable:
 
 ```java
 int total = new LengthOf(
-  new IterableOf<>("how", "are", "you")
+    new IterableOf<>("how", "are", "you")
 ).value().intValue();
 ```
 
@@ -260,39 +260,39 @@ This is a traditional `foreach` loop:
 
 ```java
 for (String name : names) {
-  System.out.printf("Hello, %s!\n", name);
+    System.out.printf("Hello, %s!\n", name);
 }
 ```
 
 This is its object-oriented alternative (no streams!):
 
 ```java
 new And(
-  n -> {
-    System.out.printf("Hello, %s!\n", n);
-    return new True().value();
-  },
-  names
+    n -> {
+        System.out.printf("Hello, %s!\n", n);
+        return new True().value();
+    },
+    names
 ).value();
 ```
 
 This is an endless `while/do` loop:
 
 ```java
 while (!ready) {
-  System.out.println("Still waiting...");
+    System.out.println("Still waiting...");
 }
 ```
 
 Here is its object-oriented alternative:
 
 ```java
 new And(
-  ready -> {
-    System.out.println("Still waiting...");
-    return !ready;
-  },
-  new Endless<>(booleanParameter)
+    ready -> {
+        System.out.println("Still waiting...");
+        return !ready;
+    },
+    new Endless<>(booleanParameter)
 ).value();
 ```