indentation explanation for scala 3 book

_overviews/scala3-book/taste-indentation.md

@@ -0,0 +1,98 @@
+---
+title: Indentation
+type: section
+description: This section demonstrates Scala 3 Indentation.
+num: 8
+previous-page: taste-vars-data-types
+next-page: taste-control-structures
+---
+
+Indentation refers to the increase or decrease of space between the left and right margin of a paragraph.
+In some programming languages, tab key is used to make indentations. This is not the case in Scala. Tab key automatically creates four spaces which Scala doesn't support.
+In Scala each level of indentation is 2 spaces.  Thus, instead of
+indenting like this:
+
+    // wrong!
+    class Foo {
+        def fourspaces = {
+            val x = 4
+            ..
+        }
+    }
+
+You should indent like this:
+
+    // right!
+    class Foo {
+      def twospaces = {
+        val x = 2
+        ..
+      }
+    }
+
+The Scala language encourages a startling amount of nested scopes and
+logical blocks (function values and such). Do yourself a favor and don't
+penalize yourself syntactically for opening up a new block. Coming from
+Java, this style does take a bit of getting used to, but it is well
+worth the effort.
+
+## Line Wrapping
+
+There are times when a single expression reaches a length where it
+becomes unreadable to keep it confined to a single line (usually that
+length is anywhere above 80 characters). In such cases, the *preferred*
+approach is to simply split the expression up into multiple expressions
+by assigning intermediate results to values. However, this is not
+always a practical solution.
+
+When it is absolutely necessary to wrap an expression across more than
+one line, each successive line should be indented two spaces from the
+*first*. Also remember that Scala requires each "wrap line" to either
+have an unclosed parenthetical or to end with an infix method in which
+the right parameter is not given:
+
+    val result = 1 + 2 + 3 + 4 + 5 + 6 +
+      7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 +
+      15 + 16 + 17 + 18 + 19 + 20
+
+Without this trailing method, Scala will infer a semi-colon at the end
+of a line which was intended to wrap, throwing off the compilation
+sometimes without even so much as a warning.
+
+## Methods with Numerous Arguments
+
+it is best practice to avoid any method which takes more than two or
+three parameters! When calling a method which takes numerous arguments (in the range of
+five or more),though,  it is often necessary to wrap the method invocation onto
+multiple lines. In such cases, put each argument on a line by
+itself, indented two spaces from the current indent level:
+
+    foo(
+      someVeryLongFieldName,
+      andAnotherVeryLongFieldName,
+      "this is a string",
+      3.1415)
+
+This way, all parameters line up, and you don't need to re-align them if
+you change the name of the method later on.
+
+Great care should be taken to avoid these sorts of invocations well into
+the length of the line. More specifically, such an invocation should be
+avoided when each parameter would have to be indented more than 50
+spaces to achieve alignment. In such cases, the invocation itself should
+be moved to the next line and indented two spaces:
+
+    // right!
+    val myLongFieldNameWithNoRealPoint =
+      foo(
+        someVeryLongFieldName,
+        andAnotherVeryLongFieldName,
+        "this is a string",
+        3.1415)
+
+    // wrong!
+    val myLongFieldNameWithNoRealPoint = foo(someVeryLongFieldName,
+                                             andAnotherVeryLongFieldName,
+                                             "this is a string",
+                                             3.1415)
+