From e7014e0025e616100ccc5dd76e92e924b592a226 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Sun, 1 Jan 2023 23:15:30 +0530
Subject: [PATCH 01/62] added loops.md in kotlin folder

---
 content/kotlin/concepts/loops/loops.md | 102 +++++++++++++++++++++++++
 1 file changed, 102 insertions(+)
 create mode 100644 content/kotlin/concepts/loops/loops.md

diff --git a/content/kotlin/concepts/loops/loops.md b/content/kotlin/concepts/loops/loops.md
new file mode 100644
index 00000000000..8f700f42a5d
--- /dev/null
+++ b/content/kotlin/concepts/loops/loops.md
@@ -0,0 +1,102 @@
+---
+Title: 'Loops'
+Description: 'In kotlin, a loop is a control structure that allows you to repeat a block of code a specified number of times or until a certain condition is met. Loops are useful for automating repetitive tasks and for processing large amounts of data efficiently.'
+Subjects:
+  - 'Computer Science'
+Tags:
+  - 'loops'
+  - 'while'
+  - 'for'
+  - 'do-while'
+CatalogContent:
+  - 'learn-kotlin'
+  - 'paths/computer-science'
+---
+
+## While loop
+
+The `while` loops used to execute a block of code repeatedly as long as a certain condition is true. The syntax for a `while` loop in Kotlin is:
+
+```kotlin
+    fun main(){
+        while(condition){
+            //code to be execute while the condition is true
+        }
+    }
+```
+
+Here's an example of a `while` loop in Kotlin that prints the numbers from 1 to 10:
+
+```kotlin
+    fun main(){
+    var i = 1
+    while (i <= 10) {
+    print(" " + i)
+    i++
+    }
+}
+```
+
+The output for the above code will be:
+
+```
+1 2 3 4 5 6 7 8 9 10
+```
+
+## For loop
+
+The `for` loop is used to iterate over a range of values or an iterable collection. The syntax for a `for` loop in Kotlin is:
+
+```kotlin
+fun main(){
+    for (item in collection) {
+   // code to be executed for each item
+    }
+}
+```
+
+Here's an example of a `for` loop in Kotlin that prints the numbers from 1 to 10:
+
+```kotlin
+fun main(){
+    for(i in 1..10){
+        print(i)
+    }
+}
+```
+
+The output for the above code will be:
+
+```
+1 2 3 4 5 6 7 8 9 10
+```
+
+## Do-While loop
+
+A `do-while` loop in Kotlin is similar to a `while` loop, but the block of code is always executed at least once before the condition is checked. The syntax for a `do-while` loop is:
+
+```kotlin
+fun main(){
+    do {
+    // code to be executed at least once
+    } while (condition)
+}
+```
+
+Here's an example of a `do-while` loop in Kotlin that prompts the user to enter a number and prints the decreasing order sequence till 0:
+
+```kotlin
+fun main(){
+    var i = 10
+    do {
+    print(" " + i)
+    i--
+    } while (i > 0)
+}
+```
+
+The output for the above code will be:
+
+```
+10 9 8 7 6 5 4 3 2 1
+```

From 31dca9aeb2fae1d4df295e4d14a3afe0dab9d46d Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Sun, 1 Jan 2023 23:27:42 +0530
Subject: [PATCH 02/62] added more info and a introduction paragraph for loops

---
 content/kotlin/concepts/loops/loops.md | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/loops/loops.md b/content/kotlin/concepts/loops/loops.md
index 8f700f42a5d..18962f5956c 100644
--- a/content/kotlin/concepts/loops/loops.md
+++ b/content/kotlin/concepts/loops/loops.md
@@ -4,7 +4,7 @@ Description: 'In kotlin, a loop is a control structure that allows you to repeat
 Subjects:
   - 'Computer Science'
 Tags:
-  - 'loops'
+  - 'loop'
   - 'while'
   - 'for'
   - 'do-while'
@@ -13,6 +13,12 @@ CatalogContent:
   - 'paths/computer-science'
 ---
 
+In Kotlin, a loop is a control flow statement that allows you to repeat a block of code a certain number of times or until a certain condition is met. Kotlin provides several types of loops, including:
+
+- `for` loop: This loop iterates over a range of values or elements in a collection.
+- `while` loop: This loop repeatedly executes a block of code as long as a certain condition is true.
+- `do-while` loop: This loop is similar to a while loop, but it guarantees that the block of code will be executed at least once before the condition is checked.
+
 ## While loop
 
 The `while` loops used to execute a block of code repeatedly as long as a certain condition is true. The syntax for a `while` loop in Kotlin is:

From fcdd14d89fda1f5ccf77ebb77be6fe9bdc571992 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Mon, 2 Jan 2023 15:30:38 +0530
Subject: [PATCH 03/62] Added data-types.md in the kotlin folder

---
 .../kotlin/concepts/data-types/data-types.md  | 378 ++++++++++++++++++
 1 file changed, 378 insertions(+)
 create mode 100644 content/kotlin/concepts/data-types/data-types.md

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
new file mode 100644
index 00000000000..4b75c551196
--- /dev/null
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -0,0 +1,378 @@
+---
+Title: 'Data Types'
+Description: 'Data types are a classification of types of values that can be stored and manipulated in a program.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Primitive Data-Type'
+  - 'Data Types'
+  - 'Non Primitive Data-Type'
+CatalogContent:
+  - 'learn-Kotlin'
+  - 'paths/computer-science'
+---
+
+`Data types` are a classification of types of data that determine the possible values and operations that can be performed on that data.
+
+Kotlin has both `primitive` and `non-primitive` data types.
+
+## Primitive Data-type
+
+There are the following different types of primitive data types in Kotlin:
+
+- Boolean
+- Byte
+- Char
+- Double
+- Float
+- Int
+- Long
+- Short
+
+### Boolean
+
+In Kotlin, the `Boolean` is a primitive data type and can hold only one of the two possible values: `true` or `false`.
+
+Here is an example of how to declare a `Boolean` variable in Kotlin:
+
+```kotlin
+val isTrue: Boolean = true
+val isFalse: Boolean = false
+// here we can see that if a variable is wrong we can written false and true if its right
+```
+
+The `Boolean` data type can be used to determine the outcome of `if ... then` statements:
+
+```kotlin
+fun main(){
+    val condition: Boolean = true
+
+    if (condition) {
+        // write a code that you want to execute if the variable is given as true
+    } else {
+        // write a code for the false variable
+    }
+}
+```
+
+### Byte
+
+A `Byte` is a data type that is similar to an integer data type, but it is only 8 bits in size, whereas an integer can be a different size depending on the system. A byte can hold values from -128 to 127.
+
+A `Byte` is a way to represent a small whole number. It is commonly used to store small pieces of data, such as characters in a text file or colors in an image.
+
+Here is an example of how to declare a `Byte` variable in Kotlin:
+
+```kotlin
+fun main(){
+    val a: Byte = 50
+    val b: Byte = 25
+    val c: Byte = a + b as Byte
+    print(c)
+
+}
+```
+
+The output will be:
+
+```
+75
+```
+
+The range of the `Byte` data type is -128 to 127. Calculations that exceed this range will produce unexpected results:
+
+```kotlin
+fun main(){
+    val a: Byte = 120
+    val b: Byte = 120
+    val c: Byte = a + b as Byte
+    print(c)
+}
+```
+
+Here the output will be:
+
+```
+-88
+```
+
+In the above example, the value of c will be -88, because the result of 120 + 120 is 240, which exceeds the valid range for a Byte type.
+
+### Char
+
+In Kotlin, the `Char` data type represents a primitive data type that can hold any character from the Unicode character set, which includes letters, digits, symbols, and special characters.
+
+Here is an example of how to declare a `Char` variable in Kotlin:
+
+```kotlin
+fun main(){
+    val ch: Char = 'A'
+    print(ch)
+}
+```
+
+The output will be:
+
+```
+A
+```
+
+### Double
+
+In Kotlin, the `Double` data type represents a 64-bit floating-point number. It is a primitive data type that can hold values with a fractional component, such as 3.14 or 0.5.
+
+Here is an example of how to declare a `Double` variable in Kotlin:
+
+```kotlin
+fun main(){
+    val a: Double = 3.14
+    val b: Double = 2.71
+    val c: Double = a * b as Double
+    print(c)
+}
+```
+
+The output of the above code will be:
+
+```
+8.5094
+```
+
+In this example, the c variable will be assigned the value 8.5014, which is the result of 3.14 \* 2.71.
+
+The `Double` data type can be used to perform more advanced operations, such as calculating the square root of a number or raising a number to a power in Kotlin. For example:
+
+```kotlin
+
+import kotlin.math.sqrt
+import kotlin.math.pow
+fun main(){
+
+
+val a: Double = 16.0
+val b: Double = sqrt(a)
+val c: Double = a.pow(2)
+
+println("The square root of $a is $b.")
+println("$a raised to the power of 2 is $c.")
+
+}
+```
+
+The output will be:
+
+```
+The square root of 16.0 is 4.0.
+16.0 raised to the power of 2 is 256.0.
+```
+
+### Float
+
+In Kotlin, the `Float` data type represents a 32-bit floating-point number. It is a primitive data type that can hold values with a fractional component, such as 3.14 or 0.5.
+
+Here is an example of how to declare a Float variable in Kotlin:
+
+```kotlin
+fun main(){
+    val a: Float = 3.14f
+    val b: Float = 2.71f
+    val c: Float = a * b as Float
+    print(c)
+
+}
+```
+
+The output will be :
+
+```
+8.5094
+```
+
+In this example, the c variable will be assigned the value 8.5014, which is the result of 3.14 \* 2.71.
+
+### Int
+
+In Kotlin, the `Int` data type represents a 32-bit signed integer. It is a primitive data type that can hold values ranging from -2147483648 to 2147483647.
+
+Here is an example of how to declare an `Int` variable in Kotlin:
+
+```kotlin
+fun main(){
+    val a: Int = 50
+    val b: Int = 25
+    val c: Int = a + b
+    print(c)
+}
+```
+
+The output of the above code will be:
+
+```
+75
+```
+
+### Long
+
+In Kotlin, the `Long` data type represents a 64-bit signed integer. It is a primitive data type that can hold values ranging from -9223372036854775808 to 9223372036854775807.
+
+Here is an example of how to declare a `Long` variable in Kotlin:
+
+```kotlin
+fun main(){
+    val a: Long = 500000000
+    val b: Long = 250000000
+    val c: Long = a + b
+    print(c)
+}
+```
+
+The output for the above code will be :
+
+```
+750000000
+```
+
+In this example, the c variable will be assigned the value 750000000, which is the result of 500000000 + 250000000.
+
+### Short
+
+In Kotlin, the `Short` data type represents a 16-bit signed integer. It is a primitive data type that can hold values ranging from -32768 to 32767.
+
+Here is an example of how to declare a `Short` variable in Kotlin:
+
+```kotlin
+fun main(){
+    val a: Short = 50
+    val b: Short = 25
+    val c: Short = (a + b).toShort()
+    print(c)
+}
+```
+
+The output for the above code will be:
+
+```
+75
+```
+
+In this example, the c variable will be assigned the value 75, which is the result of 50 + 25. The `toShort()` function is used to explicitly convert the result to a `Short` type.
+
+## Non-Primitive Data Types
+
+The following are non-primitive data types in Kotlin :
+
+- Arrays
+- String
+- Any
+- Nothing
+- Unit
+
+### Arrays
+
+In Kotlin, an `Array` is a data structure that stores a fixed-size collection of elements of the same data type. Arrays are non-primitive data types, which means they are derived from primitive data types or other non-primitive data types.
+
+To declare an `Array` in Kotlin, you can use the `arrayOf()` function and specify the elements of the array within the parentheses. For example:
+
+```kotlin
+fun main(){
+    val numbers: Array<Int> = arrayOf(1, 2, 3, 4, 5)
+}
+```
+
+In this example, the `numbers` variable is an array of integers that contains the values 1, 2, 3, 4, and 5. The type of the array is specified using the `Array<Int>` syntax, which indicates that the array contains elements of the `Int` type.
+
+If you want to know how to print the array then you can check [Arrays].
+
+### String
+
+In Kotlin, a `String` is a data type that represents a sequence of characters. You can use a string to store and manipulate text in your program.
+
+Here is an example of how to declare and initialize a string in Kotlin:
+
+```kotlin
+fun main(){
+    val message: String = "Hello, World!"
+    print(message)
+}
+```
+
+The output for the above code will be :
+
+```
+Hello, World!
+```
+
+Strings are also [immutable](https://kotlinlang.org/docs/native-immutability.html) in Kotlin.
+
+You can use the '+' operator to concatenate strings, or the trim() function to remove leading and trailing whitespace from a string. For example:
+
+```kotlin
+fun main(){
+    val greeting: String = "Hello, "
+    val name: String = "John"
+    val fullMessage: String = greeting + name
+    println(fullMessage.trim())
+}
+```
+
+The output for the above code will be :
+
+```
+Hello, John
+```
+
+### Any
+
+In Kotlin, the `Any` type is a supertype of all types in the language. It represents a general type that can hold any value.
+
+Here is an example of how to declare a variable of type `Any` in Kotlin:
+
+```kotlin
+fun main(){
+    val value: Any = 100
+    val value2: Any = "Hello, World!"
+    println(value)
+    println(value2)
+}
+```
+
+The output for the above code will be :
+
+```
+100
+Hello, World!
+```
+
+### Nothing
+
+In Kotlin, the `Nothing` type is a special type that represents the absence of a value. It is a subtype of all types in the language and cannot be instantiated.
+
+The `Nothing` type is used to indicate that a function never returns a value. For example, a function that throws an exception or terminates the program will have a return type of `Nothing`.
+
+Here is an example of a function that has a return type of `Nothing`:
+
+```kotlin
+fun error(): Nothing {
+    throw IllegalStateException("An error occurred.")
+}
+```
+
+In the above, the `error()` function throws an exception and does not return a value. Therefore, its return type is `Nothing`.
+
+### Unit
+
+In Kotlin, the `Unit` type represents the absence of a value, similar to the `void` type in other programming languages. It is a special type that is used to indicate that a function does not return a value.
+
+The `Unit` type can be used to specify that a function has a return type of `Unit` when it is not possible to infer the return type from the function's body. For example:
+
+```kotlin
+fun main(){
+
+}
+fun doSomething(): Unit {
+    // perform some action that you want to do
+}
+```
+
+In the above example, the doSomething() function performs an action and does not return a value. Therefore, its return type is `Unit`.

From 5bf7922ca9d38a8790d48960ec3e8edc1de6b758 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Mon, 2 Jan 2023 21:45:12 +0530
Subject: [PATCH 04/62] Update content/kotlin/concepts/loops/loops.md

Co-authored-by: SSwiniarski <86081858+SSwiniarski@users.noreply.github.com>
---
 content/kotlin/concepts/loops/loops.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/loops/loops.md b/content/kotlin/concepts/loops/loops.md
index 18962f5956c..6f2e28c62a4 100644
--- a/content/kotlin/concepts/loops/loops.md
+++ b/content/kotlin/concepts/loops/loops.md
@@ -1,6 +1,6 @@
 ---
 Title: 'Loops'
-Description: 'In kotlin, a loop is a control structure that allows you to repeat a block of code a specified number of times or until a certain condition is met. Loops are useful for automating repetitive tasks and for processing large amounts of data efficiently.'
+Description: 'A loop is a control structure that allows you to repeat a block of code a specified number of times or until a certain condition is met.'
 Subjects:
   - 'Computer Science'
 Tags:

From 162c7a9726d85eaf96bc529efd297e6dc39a9fb3 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Mon, 2 Jan 2023 21:45:24 +0530
Subject: [PATCH 05/62] Update content/kotlin/concepts/loops/loops.md

Co-authored-by: SSwiniarski <86081858+SSwiniarski@users.noreply.github.com>
---
 content/kotlin/concepts/loops/loops.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/loops/loops.md b/content/kotlin/concepts/loops/loops.md
index 6f2e28c62a4..b7c7f03f56e 100644
--- a/content/kotlin/concepts/loops/loops.md
+++ b/content/kotlin/concepts/loops/loops.md
@@ -4,7 +4,7 @@ Description: 'A loop is a control structure that allows you to repeat a block of
 Subjects:
   - 'Computer Science'
 Tags:
-  - 'loop'
+  - 'Loops'
   - 'while'
   - 'for'
   - 'do-while'

From 43b62dfa5d7244c63c9ef0e64ad20f7a1a6c440b Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Mon, 2 Jan 2023 21:45:30 +0530
Subject: [PATCH 06/62] Update content/kotlin/concepts/loops/loops.md

Co-authored-by: SSwiniarski <86081858+SSwiniarski@users.noreply.github.com>
---
 content/kotlin/concepts/loops/loops.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/loops/loops.md b/content/kotlin/concepts/loops/loops.md
index b7c7f03f56e..09c677f1e2a 100644
--- a/content/kotlin/concepts/loops/loops.md
+++ b/content/kotlin/concepts/loops/loops.md
@@ -5,7 +5,7 @@ Subjects:
   - 'Computer Science'
 Tags:
   - 'Loops'
-  - 'while'
+  - 'While'
   - 'for'
   - 'do-while'
 CatalogContent:

From 40eacf3f284e26ce40f9f3b09b50c94b0f73caad Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Mon, 2 Jan 2023 21:45:36 +0530
Subject: [PATCH 07/62] Update content/kotlin/concepts/loops/loops.md

Co-authored-by: SSwiniarski <86081858+SSwiniarski@users.noreply.github.com>
---
 content/kotlin/concepts/loops/loops.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/loops/loops.md b/content/kotlin/concepts/loops/loops.md
index 09c677f1e2a..07edc4a3ac6 100644
--- a/content/kotlin/concepts/loops/loops.md
+++ b/content/kotlin/concepts/loops/loops.md
@@ -6,7 +6,7 @@ Subjects:
 Tags:
   - 'Loops'
   - 'While'
-  - 'for'
+  - 'For'
   - 'do-while'
 CatalogContent:
   - 'learn-kotlin'

From 48166f2c34a8ba08c6f6fc10ae157446ce739c33 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Mon, 2 Jan 2023 21:45:42 +0530
Subject: [PATCH 08/62] Update content/kotlin/concepts/loops/loops.md

Co-authored-by: SSwiniarski <86081858+SSwiniarski@users.noreply.github.com>
---
 content/kotlin/concepts/loops/loops.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/content/kotlin/concepts/loops/loops.md b/content/kotlin/concepts/loops/loops.md
index 07edc4a3ac6..21756c5f410 100644
--- a/content/kotlin/concepts/loops/loops.md
+++ b/content/kotlin/concepts/loops/loops.md
@@ -7,7 +7,6 @@ Tags:
   - 'Loops'
   - 'While'
   - 'For'
-  - 'do-while'
 CatalogContent:
   - 'learn-kotlin'
   - 'paths/computer-science'

From 22c708d4035f5cae18924398b6b89a43f7eaddc6 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Mon, 2 Jan 2023 21:45:51 +0530
Subject: [PATCH 09/62] Update content/kotlin/concepts/loops/loops.md

Co-authored-by: SSwiniarski <86081858+SSwiniarski@users.noreply.github.com>
---
 content/kotlin/concepts/loops/loops.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/loops/loops.md b/content/kotlin/concepts/loops/loops.md
index 21756c5f410..8f32c82cef2 100644
--- a/content/kotlin/concepts/loops/loops.md
+++ b/content/kotlin/concepts/loops/loops.md
@@ -20,7 +20,7 @@ In Kotlin, a loop is a control flow statement that allows you to repeat a block
 
 ## While loop
 
-The `while` loops used to execute a block of code repeatedly as long as a certain condition is true. The syntax for a `while` loop in Kotlin is:
+The `while` loop is used to execute a block of code repeatedly as long as a certain condition is true. The syntax for a `while` loop in Kotlin is:
 
 ```kotlin
     fun main(){

From 5f03889c84480e91e5c7efe8469ac15c5578d034 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Mon, 2 Jan 2023 21:47:42 +0530
Subject: [PATCH 10/62] Update loops.md

---
 content/kotlin/concepts/loops/loops.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/content/kotlin/concepts/loops/loops.md b/content/kotlin/concepts/loops/loops.md
index 8f32c82cef2..877802b7360 100644
--- a/content/kotlin/concepts/loops/loops.md
+++ b/content/kotlin/concepts/loops/loops.md
@@ -22,7 +22,7 @@ In Kotlin, a loop is a control flow statement that allows you to repeat a block
 
 The `while` loop is used to execute a block of code repeatedly as long as a certain condition is true. The syntax for a `while` loop in Kotlin is:
 
-```kotlin
+```pseudo
     fun main(){
         while(condition){
             //code to be execute while the condition is true
@@ -52,7 +52,7 @@ The output for the above code will be:
 
 The `for` loop is used to iterate over a range of values or an iterable collection. The syntax for a `for` loop in Kotlin is:
 
-```kotlin
+```pseudo
 fun main(){
     for (item in collection) {
    // code to be executed for each item
@@ -80,7 +80,7 @@ The output for the above code will be:
 
 A `do-while` loop in Kotlin is similar to a `while` loop, but the block of code is always executed at least once before the condition is checked. The syntax for a `do-while` loop is:
 
-```kotlin
+```pseudo
 fun main(){
     do {
     // code to be executed at least once

From 885ea2a50c505f07eae7225da923d8d67b74cbea Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Mon, 2 Jan 2023 21:50:07 +0530
Subject: [PATCH 11/62] Update loops.md

---
 content/kotlin/concepts/loops/loops.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/loops/loops.md b/content/kotlin/concepts/loops/loops.md
index 877802b7360..b46402ac22d 100644
--- a/content/kotlin/concepts/loops/loops.md
+++ b/content/kotlin/concepts/loops/loops.md
@@ -14,8 +14,8 @@ CatalogContent:
 
 In Kotlin, a loop is a control flow statement that allows you to repeat a block of code a certain number of times or until a certain condition is met. Kotlin provides several types of loops, including:
 
-- `for` loop: This loop iterates over a range of values or elements in a collection.
 - `while` loop: This loop repeatedly executes a block of code as long as a certain condition is true.
+- `for` loop: This loop iterates over a range of values or elements in a collection.
 - `do-while` loop: This loop is similar to a while loop, but it guarantees that the block of code will be executed at least once before the condition is checked.
 
 ## While loop

From 0736dd9b5cb05479c628dea784a601767a54a0a7 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Mon, 2 Jan 2023 22:14:25 +0530
Subject: [PATCH 12/62] Update loops.md

---
 content/kotlin/concepts/loops/loops.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/loops/loops.md b/content/kotlin/concepts/loops/loops.md
index b46402ac22d..3fcaf8b4bc4 100644
--- a/content/kotlin/concepts/loops/loops.md
+++ b/content/kotlin/concepts/loops/loops.md
@@ -88,7 +88,7 @@ fun main(){
 }
 ```
 
-Here's an example of a `do-while` loop in Kotlin that prompts the user to enter a number and prints the decreasing order sequence till 0:
+Here's an example of a `do-while` loop in Kotlin here the code declares a variable i with the initial value of 10. It then enters a loop, which will continue to run as long as i is greater than 0. Inside the loop, the code prints the value of i, and then decrements i by 1. This means that on each iteration of the loop, the value of i will be printed, and then reduced by 1. The loop will continue to run until i is no longer greater than 0, at which point the loop will exit and the program will end:
 
 ```kotlin
 fun main(){

From b42143fda3a5a0037422fed1c380038ca4f88b06 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Mon, 2 Jan 2023 22:31:50 +0530
Subject: [PATCH 13/62] changed the sequence of for while and do while loops

---
 content/kotlin/concepts/loops/loops.md | 46 +++++++++++++-------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/content/kotlin/concepts/loops/loops.md b/content/kotlin/concepts/loops/loops.md
index 3fcaf8b4bc4..23c8aa464c4 100644
--- a/content/kotlin/concepts/loops/loops.md
+++ b/content/kotlin/concepts/loops/loops.md
@@ -14,30 +14,28 @@ CatalogContent:
 
 In Kotlin, a loop is a control flow statement that allows you to repeat a block of code a certain number of times or until a certain condition is met. Kotlin provides several types of loops, including:
 
-- `while` loop: This loop repeatedly executes a block of code as long as a certain condition is true.
 - `for` loop: This loop iterates over a range of values or elements in a collection.
+- `while` loop: This loop repeatedly executes a block of code as long as a certain condition is true.
 - `do-while` loop: This loop is similar to a while loop, but it guarantees that the block of code will be executed at least once before the condition is checked.
 
-## While loop
+## For loop
 
-The `while` loop is used to execute a block of code repeatedly as long as a certain condition is true. The syntax for a `while` loop in Kotlin is:
+The `for` loop is used to iterate over a range of values or an iterable collection. The syntax for a `for` loop in Kotlin is:
 
 ```pseudo
-    fun main(){
-        while(condition){
-            //code to be execute while the condition is true
-        }
+fun main(){
+    for (item in collection) {
+   // code to be executed for each item
     }
+}
 ```
 
-Here's an example of a `while` loop in Kotlin that prints the numbers from 1 to 10:
+Here's an example of a `for` loop in Kotlin that prints the numbers from 1 to 10:
 
 ```kotlin
-    fun main(){
-    var i = 1
-    while (i <= 10) {
-    print(" " + i)
-    i++
+fun main(){
+    for(i in 1..10){
+        print(i)
     }
 }
 ```
@@ -48,24 +46,26 @@ The output for the above code will be:
 1 2 3 4 5 6 7 8 9 10
 ```
 
-## For loop
+## While loop
 
-The `for` loop is used to iterate over a range of values or an iterable collection. The syntax for a `for` loop in Kotlin is:
+The `while` loop is used to execute a block of code repeatedly as long as a certain condition is true. The syntax for a `while` loop in Kotlin is:
 
 ```pseudo
-fun main(){
-    for (item in collection) {
-   // code to be executed for each item
+    fun main(){
+        while(condition){
+            //code to be execute while the condition is true
+        }
     }
-}
 ```
 
-Here's an example of a `for` loop in Kotlin that prints the numbers from 1 to 10:
+Here's an example of a `while` loop in Kotlin that prints the numbers from 1 to 10:
 
 ```kotlin
-fun main(){
-    for(i in 1..10){
-        print(i)
+    fun main(){
+    var i = 1
+    while (i <= 10) {
+    print(" " + i)
+    i++
     }
 }
 ```

From f6fd28e0c8036dce677bab01502dddac39eded78 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Mon, 2 Jan 2023 22:37:17 +0530
Subject: [PATCH 14/62] del

---
 content/kotlin/concepts/loops/loops.md | 107 -------------------------
 1 file changed, 107 deletions(-)
 delete mode 100644 content/kotlin/concepts/loops/loops.md

diff --git a/content/kotlin/concepts/loops/loops.md b/content/kotlin/concepts/loops/loops.md
deleted file mode 100644
index 23c8aa464c4..00000000000
--- a/content/kotlin/concepts/loops/loops.md
+++ /dev/null
@@ -1,107 +0,0 @@
----
-Title: 'Loops'
-Description: 'A loop is a control structure that allows you to repeat a block of code a specified number of times or until a certain condition is met.'
-Subjects:
-  - 'Computer Science'
-Tags:
-  - 'Loops'
-  - 'While'
-  - 'For'
-CatalogContent:
-  - 'learn-kotlin'
-  - 'paths/computer-science'
----
-
-In Kotlin, a loop is a control flow statement that allows you to repeat a block of code a certain number of times or until a certain condition is met. Kotlin provides several types of loops, including:
-
-- `for` loop: This loop iterates over a range of values or elements in a collection.
-- `while` loop: This loop repeatedly executes a block of code as long as a certain condition is true.
-- `do-while` loop: This loop is similar to a while loop, but it guarantees that the block of code will be executed at least once before the condition is checked.
-
-## For loop
-
-The `for` loop is used to iterate over a range of values or an iterable collection. The syntax for a `for` loop in Kotlin is:
-
-```pseudo
-fun main(){
-    for (item in collection) {
-   // code to be executed for each item
-    }
-}
-```
-
-Here's an example of a `for` loop in Kotlin that prints the numbers from 1 to 10:
-
-```kotlin
-fun main(){
-    for(i in 1..10){
-        print(i)
-    }
-}
-```
-
-The output for the above code will be:
-
-```
-1 2 3 4 5 6 7 8 9 10
-```
-
-## While loop
-
-The `while` loop is used to execute a block of code repeatedly as long as a certain condition is true. The syntax for a `while` loop in Kotlin is:
-
-```pseudo
-    fun main(){
-        while(condition){
-            //code to be execute while the condition is true
-        }
-    }
-```
-
-Here's an example of a `while` loop in Kotlin that prints the numbers from 1 to 10:
-
-```kotlin
-    fun main(){
-    var i = 1
-    while (i <= 10) {
-    print(" " + i)
-    i++
-    }
-}
-```
-
-The output for the above code will be:
-
-```
-1 2 3 4 5 6 7 8 9 10
-```
-
-## Do-While loop
-
-A `do-while` loop in Kotlin is similar to a `while` loop, but the block of code is always executed at least once before the condition is checked. The syntax for a `do-while` loop is:
-
-```pseudo
-fun main(){
-    do {
-    // code to be executed at least once
-    } while (condition)
-}
-```
-
-Here's an example of a `do-while` loop in Kotlin here the code declares a variable i with the initial value of 10. It then enters a loop, which will continue to run as long as i is greater than 0. Inside the loop, the code prints the value of i, and then decrements i by 1. This means that on each iteration of the loop, the value of i will be printed, and then reduced by 1. The loop will continue to run until i is no longer greater than 0, at which point the loop will exit and the program will end:
-
-```kotlin
-fun main(){
-    var i = 10
-    do {
-    print(" " + i)
-    i--
-    } while (i > 0)
-}
-```
-
-The output for the above code will be:
-
-```
-10 9 8 7 6 5 4 3 2 1
-```

From c219bc5fbd2e7ac4020dd62232a47b607807104b Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:03:36 +0530
Subject: [PATCH 15/62] changed tags

---
 content/kotlin/concepts/data-types/data-types.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index 4b75c551196..5dc51c20afd 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -5,9 +5,10 @@ Subjects:
   - 'Code Foundations'
   - 'Computer Science'
 Tags:
-  - 'Primitive Data-Type'
+  - 'Integers'
   - 'Data Types'
-  - 'Non Primitive Data-Type'
+  - 'Boolean'
+  - 'Characters'
 CatalogContent:
   - 'learn-Kotlin'
   - 'paths/computer-science'

From a0cec1ede585280cb3a66d8bbb1dbeed7d6b064e Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:04:01 +0530
Subject: [PATCH 16/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index 5dc51c20afd..9459975871a 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -14,7 +14,7 @@ CatalogContent:
   - 'paths/computer-science'
 ---
 
-`Data types` are a classification of types of data that determine the possible values and operations that can be performed on that data.
+**Data types** are a classification of types of data that determine possible values and operations that can be performed on that data.
 
 Kotlin has both `primitive` and `non-primitive` data types.
 

From 28c3525fffb4e6d3e54d98524dc41652e1100019 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:04:07 +0530
Subject: [PATCH 17/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index 9459975871a..57e7882abe8 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -18,7 +18,7 @@ CatalogContent:
 
 Kotlin has both `primitive` and `non-primitive` data types.
 
-## Primitive Data-type
+## Primitive Data Types
 
 There are the following different types of primitive data types in Kotlin:
 

From 156cbaa3887490f8b536fa3ba383ecc113357029 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:04:15 +0530
Subject: [PATCH 18/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index 57e7882abe8..31031002c6f 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -33,9 +33,7 @@ There are the following different types of primitive data types in Kotlin:
 
 ### Boolean
 
-In Kotlin, the `Boolean` is a primitive data type and can hold only one of the two possible values: `true` or `false`.
-
-Here is an example of how to declare a `Boolean` variable in Kotlin:
+In Kotlin, `Boolean` can hold only one of the two possible values: `true` or `false`. Below is an example of how to declare a `Boolean` variable in Kotlin:
 
 ```kotlin
 val isTrue: Boolean = true

From 9fbd5e609b8ee7aacd016a9b8b415ec483ffede3 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:04:22 +0530
Subject: [PATCH 19/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index 31031002c6f..b0298bcebed 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -38,7 +38,6 @@ In Kotlin, `Boolean` can hold only one of the two possible values: `true` or `fa
 ```kotlin
 val isTrue: Boolean = true
 val isFalse: Boolean = false
-// here we can see that if a variable is wrong we can written false and true if its right
 ```
 
 The `Boolean` data type can be used to determine the outcome of `if ... then` statements:

From 6a49a1c65258cb8252f065d83436075f776a6b0f Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:04:31 +0530
Subject: [PATCH 20/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index b0298bcebed..b756f116be7 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -40,7 +40,7 @@ val isTrue: Boolean = true
 val isFalse: Boolean = false
 ```
 
-The `Boolean` data type can be used to determine the outcome of `if ... then` statements:
+The `Boolean` data type can be used to determine the outcome of `if...else` statements:
 
 ```kotlin
 fun main(){

From ab6ebff6858186641c4224c2ff9025280f53a5c9 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:05:32 +0530
Subject: [PATCH 21/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index b756f116be7..cc2afc2f324 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -260,10 +260,15 @@ In this example, the c variable will be assigned the value 75, which is the resu
 
 The following are non-primitive data types in Kotlin :
 
-- Arrays
-- String
 - Any
+- Arrays
+- Class
+- Enum
+- List
+- Map
 - Nothing
+- Set
+- String
 - Unit
 
 ### Arrays

From 2f1cc3c6d8a5a2be2c1f342d8f5696df852df55b Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:06:05 +0530
Subject: [PATCH 22/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index cc2afc2f324..34ede4d4647 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -278,7 +278,7 @@ In Kotlin, an `Array` is a data structure that stores a fixed-size collection of
 To declare an `Array` in Kotlin, you can use the `arrayOf()` function and specify the elements of the array within the parentheses. For example:
 
 ```kotlin
-fun main(){
+fun main() {
     val numbers: Array<Int> = arrayOf(1, 2, 3, 4, 5)
 }
 ```

From 49b568f6de551b883783c467afb6f7255ef00b3d Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:06:14 +0530
Subject: [PATCH 23/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index 34ede4d4647..0b9a2e4e7aa 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -294,7 +294,7 @@ In Kotlin, a `String` is a data type that represents a sequence of characters. Y
 Here is an example of how to declare and initialize a string in Kotlin:
 
 ```kotlin
-fun main(){
+fun main() {
     val message: String = "Hello, World!"
     print(message)
 }

From 7e30fbaf6f807c558b5bd744f83850213c3b4135 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:06:26 +0530
Subject: [PATCH 24/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index 0b9a2e4e7aa..c977e53f308 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -300,7 +300,7 @@ fun main() {
 }
 ```
 
-The output for the above code will be :
+The output for the above code will be:
 
 ```
 Hello, World!

From 970a372ffa0d5ac8336c60305fdcf44e657ec6a6 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:06:36 +0530
Subject: [PATCH 25/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index c977e53f308..94256bc946e 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -319,7 +319,7 @@ fun main(){
 }
 ```
 
-The output for the above code will be :
+The output for the above code will be:
 
 ```
 Hello, John

From 4974ee01d2ffbc7a848a7fa30ddccf2d06785e4a Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:06:46 +0530
Subject: [PATCH 26/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index 94256bc946e..ab67f0dc074 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -370,7 +370,7 @@ In Kotlin, the `Unit` type represents the absence of a value, similar to the `vo
 The `Unit` type can be used to specify that a function has a return type of `Unit` when it is not possible to infer the return type from the function's body. For example:
 
 ```kotlin
-fun main(){
+fun main() {
 
 }
 fun doSomething(): Unit {

From 37e863f444b25013f4823e3885ae39fff2dd70ab Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:06:58 +0530
Subject: [PATCH 27/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index ab67f0dc074..ead6eff0f0b 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -373,6 +373,7 @@ The `Unit` type can be used to specify that a function has a return type of `Uni
 fun main() {
 
 }
+
 fun doSomething(): Unit {
     // perform some action that you want to do
 }

From 8f211b0c6dc52b9ce8696a51b5c61e0ad08fdd0d Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:07:08 +0530
Subject: [PATCH 28/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index ead6eff0f0b..b1bbcaad513 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -375,7 +375,7 @@ fun main() {
 }
 
 fun doSomething(): Unit {
-    // perform some action that you want to do
+    // Perform some action here
 }
 ```
 

From cd47aaa0d7b230e95df554d07c104b7ce15ed516 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:07:23 +0530
Subject: [PATCH 29/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index b1bbcaad513..dd06b164db9 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -379,4 +379,4 @@ fun doSomething(): Unit {
 }
 ```
 
-In the above example, the doSomething() function performs an action and does not return a value. Therefore, its return type is `Unit`.
+In the above example, the `doSomething()` function performs an action and does not return a value. Therefore, its return type is `Unit`.

From f24382f571c46c965aa35aa262ef82178b820a02 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:08:08 +0530
Subject: [PATCH 30/62] Update content/kotlin/concepts/data-types/data-types.md

Co-authored-by: Christine Yang <72277593+yangc95@users.noreply.github.com>
---
 content/kotlin/concepts/data-types/data-types.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index dd06b164db9..0884abe1cff 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -374,6 +374,7 @@ fun main() {
 
 }
 
+
 fun doSomething(): Unit {
     // Perform some action here
 }

From ff95ae26d62338c09df4a7f123976fd3e1fe17ef Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:10:45 +0530
Subject: [PATCH 31/62] changed the sentence in line 278

---
 content/kotlin/concepts/data-types/data-types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index 0884abe1cff..4f9a61c9e9d 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -275,7 +275,7 @@ The following are non-primitive data types in Kotlin :
 
 In Kotlin, an `Array` is a data structure that stores a fixed-size collection of elements of the same data type. Arrays are non-primitive data types, which means they are derived from primitive data types or other non-primitive data types.
 
-To declare an `Array` in Kotlin, you can use the `arrayOf()` function and specify the elements of the array within the parentheses. For example:
+To declare an Array in Kotlin, the arrayOf() function can be utilized, with the elements of the array specified within the parentheses. For instance:
 
 ```kotlin
 fun main() {

From 9d8e67a710afa851fbfc9f158ca66097de711dae Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 13:11:33 +0530
Subject: [PATCH 32/62] Update data-types.md

---
 content/kotlin/concepts/data-types/data-types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
index 4f9a61c9e9d..4e88bdae5c6 100644
--- a/content/kotlin/concepts/data-types/data-types.md
+++ b/content/kotlin/concepts/data-types/data-types.md
@@ -275,7 +275,7 @@ The following are non-primitive data types in Kotlin :
 
 In Kotlin, an `Array` is a data structure that stores a fixed-size collection of elements of the same data type. Arrays are non-primitive data types, which means they are derived from primitive data types or other non-primitive data types.
 
-To declare an Array in Kotlin, the arrayOf() function can be utilized, with the elements of the array specified within the parentheses. For instance:
+To declare an Array in Kotlin, the `arrayOf()` function can be utilized, with the elements of the array specified within the parentheses. For instance:
 
 ```kotlin
 fun main() {

From 73e5ae96c155dff10a6d9f20960def5a5a6effd6 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 4 Jan 2023 23:14:19 +0530
Subject: [PATCH 33/62] added variables.md in kotlin folder

---
 .../kotlin/concepts/data-types/data-types.md  | 383 ------------------
 .../kotlin/concepts/variables/variables.md    |  70 ++++
 2 files changed, 70 insertions(+), 383 deletions(-)
 delete mode 100644 content/kotlin/concepts/data-types/data-types.md
 create mode 100644 content/kotlin/concepts/variables/variables.md

diff --git a/content/kotlin/concepts/data-types/data-types.md b/content/kotlin/concepts/data-types/data-types.md
deleted file mode 100644
index 4e88bdae5c6..00000000000
--- a/content/kotlin/concepts/data-types/data-types.md
+++ /dev/null
@@ -1,383 +0,0 @@
----
-Title: 'Data Types'
-Description: 'Data types are a classification of types of values that can be stored and manipulated in a program.'
-Subjects:
-  - 'Code Foundations'
-  - 'Computer Science'
-Tags:
-  - 'Integers'
-  - 'Data Types'
-  - 'Boolean'
-  - 'Characters'
-CatalogContent:
-  - 'learn-Kotlin'
-  - 'paths/computer-science'
----
-
-**Data types** are a classification of types of data that determine possible values and operations that can be performed on that data.
-
-Kotlin has both `primitive` and `non-primitive` data types.
-
-## Primitive Data Types
-
-There are the following different types of primitive data types in Kotlin:
-
-- Boolean
-- Byte
-- Char
-- Double
-- Float
-- Int
-- Long
-- Short
-
-### Boolean
-
-In Kotlin, `Boolean` can hold only one of the two possible values: `true` or `false`. Below is an example of how to declare a `Boolean` variable in Kotlin:
-
-```kotlin
-val isTrue: Boolean = true
-val isFalse: Boolean = false
-```
-
-The `Boolean` data type can be used to determine the outcome of `if...else` statements:
-
-```kotlin
-fun main(){
-    val condition: Boolean = true
-
-    if (condition) {
-        // write a code that you want to execute if the variable is given as true
-    } else {
-        // write a code for the false variable
-    }
-}
-```
-
-### Byte
-
-A `Byte` is a data type that is similar to an integer data type, but it is only 8 bits in size, whereas an integer can be a different size depending on the system. A byte can hold values from -128 to 127.
-
-A `Byte` is a way to represent a small whole number. It is commonly used to store small pieces of data, such as characters in a text file or colors in an image.
-
-Here is an example of how to declare a `Byte` variable in Kotlin:
-
-```kotlin
-fun main(){
-    val a: Byte = 50
-    val b: Byte = 25
-    val c: Byte = a + b as Byte
-    print(c)
-
-}
-```
-
-The output will be:
-
-```
-75
-```
-
-The range of the `Byte` data type is -128 to 127. Calculations that exceed this range will produce unexpected results:
-
-```kotlin
-fun main(){
-    val a: Byte = 120
-    val b: Byte = 120
-    val c: Byte = a + b as Byte
-    print(c)
-}
-```
-
-Here the output will be:
-
-```
--88
-```
-
-In the above example, the value of c will be -88, because the result of 120 + 120 is 240, which exceeds the valid range for a Byte type.
-
-### Char
-
-In Kotlin, the `Char` data type represents a primitive data type that can hold any character from the Unicode character set, which includes letters, digits, symbols, and special characters.
-
-Here is an example of how to declare a `Char` variable in Kotlin:
-
-```kotlin
-fun main(){
-    val ch: Char = 'A'
-    print(ch)
-}
-```
-
-The output will be:
-
-```
-A
-```
-
-### Double
-
-In Kotlin, the `Double` data type represents a 64-bit floating-point number. It is a primitive data type that can hold values with a fractional component, such as 3.14 or 0.5.
-
-Here is an example of how to declare a `Double` variable in Kotlin:
-
-```kotlin
-fun main(){
-    val a: Double = 3.14
-    val b: Double = 2.71
-    val c: Double = a * b as Double
-    print(c)
-}
-```
-
-The output of the above code will be:
-
-```
-8.5094
-```
-
-In this example, the c variable will be assigned the value 8.5014, which is the result of 3.14 \* 2.71.
-
-The `Double` data type can be used to perform more advanced operations, such as calculating the square root of a number or raising a number to a power in Kotlin. For example:
-
-```kotlin
-
-import kotlin.math.sqrt
-import kotlin.math.pow
-fun main(){
-
-
-val a: Double = 16.0
-val b: Double = sqrt(a)
-val c: Double = a.pow(2)
-
-println("The square root of $a is $b.")
-println("$a raised to the power of 2 is $c.")
-
-}
-```
-
-The output will be:
-
-```
-The square root of 16.0 is 4.0.
-16.0 raised to the power of 2 is 256.0.
-```
-
-### Float
-
-In Kotlin, the `Float` data type represents a 32-bit floating-point number. It is a primitive data type that can hold values with a fractional component, such as 3.14 or 0.5.
-
-Here is an example of how to declare a Float variable in Kotlin:
-
-```kotlin
-fun main(){
-    val a: Float = 3.14f
-    val b: Float = 2.71f
-    val c: Float = a * b as Float
-    print(c)
-
-}
-```
-
-The output will be :
-
-```
-8.5094
-```
-
-In this example, the c variable will be assigned the value 8.5014, which is the result of 3.14 \* 2.71.
-
-### Int
-
-In Kotlin, the `Int` data type represents a 32-bit signed integer. It is a primitive data type that can hold values ranging from -2147483648 to 2147483647.
-
-Here is an example of how to declare an `Int` variable in Kotlin:
-
-```kotlin
-fun main(){
-    val a: Int = 50
-    val b: Int = 25
-    val c: Int = a + b
-    print(c)
-}
-```
-
-The output of the above code will be:
-
-```
-75
-```
-
-### Long
-
-In Kotlin, the `Long` data type represents a 64-bit signed integer. It is a primitive data type that can hold values ranging from -9223372036854775808 to 9223372036854775807.
-
-Here is an example of how to declare a `Long` variable in Kotlin:
-
-```kotlin
-fun main(){
-    val a: Long = 500000000
-    val b: Long = 250000000
-    val c: Long = a + b
-    print(c)
-}
-```
-
-The output for the above code will be :
-
-```
-750000000
-```
-
-In this example, the c variable will be assigned the value 750000000, which is the result of 500000000 + 250000000.
-
-### Short
-
-In Kotlin, the `Short` data type represents a 16-bit signed integer. It is a primitive data type that can hold values ranging from -32768 to 32767.
-
-Here is an example of how to declare a `Short` variable in Kotlin:
-
-```kotlin
-fun main(){
-    val a: Short = 50
-    val b: Short = 25
-    val c: Short = (a + b).toShort()
-    print(c)
-}
-```
-
-The output for the above code will be:
-
-```
-75
-```
-
-In this example, the c variable will be assigned the value 75, which is the result of 50 + 25. The `toShort()` function is used to explicitly convert the result to a `Short` type.
-
-## Non-Primitive Data Types
-
-The following are non-primitive data types in Kotlin :
-
-- Any
-- Arrays
-- Class
-- Enum
-- List
-- Map
-- Nothing
-- Set
-- String
-- Unit
-
-### Arrays
-
-In Kotlin, an `Array` is a data structure that stores a fixed-size collection of elements of the same data type. Arrays are non-primitive data types, which means they are derived from primitive data types or other non-primitive data types.
-
-To declare an Array in Kotlin, the `arrayOf()` function can be utilized, with the elements of the array specified within the parentheses. For instance:
-
-```kotlin
-fun main() {
-    val numbers: Array<Int> = arrayOf(1, 2, 3, 4, 5)
-}
-```
-
-In this example, the `numbers` variable is an array of integers that contains the values 1, 2, 3, 4, and 5. The type of the array is specified using the `Array<Int>` syntax, which indicates that the array contains elements of the `Int` type.
-
-If you want to know how to print the array then you can check [Arrays].
-
-### String
-
-In Kotlin, a `String` is a data type that represents a sequence of characters. You can use a string to store and manipulate text in your program.
-
-Here is an example of how to declare and initialize a string in Kotlin:
-
-```kotlin
-fun main() {
-    val message: String = "Hello, World!"
-    print(message)
-}
-```
-
-The output for the above code will be:
-
-```
-Hello, World!
-```
-
-Strings are also [immutable](https://kotlinlang.org/docs/native-immutability.html) in Kotlin.
-
-You can use the '+' operator to concatenate strings, or the trim() function to remove leading and trailing whitespace from a string. For example:
-
-```kotlin
-fun main(){
-    val greeting: String = "Hello, "
-    val name: String = "John"
-    val fullMessage: String = greeting + name
-    println(fullMessage.trim())
-}
-```
-
-The output for the above code will be:
-
-```
-Hello, John
-```
-
-### Any
-
-In Kotlin, the `Any` type is a supertype of all types in the language. It represents a general type that can hold any value.
-
-Here is an example of how to declare a variable of type `Any` in Kotlin:
-
-```kotlin
-fun main(){
-    val value: Any = 100
-    val value2: Any = "Hello, World!"
-    println(value)
-    println(value2)
-}
-```
-
-The output for the above code will be :
-
-```
-100
-Hello, World!
-```
-
-### Nothing
-
-In Kotlin, the `Nothing` type is a special type that represents the absence of a value. It is a subtype of all types in the language and cannot be instantiated.
-
-The `Nothing` type is used to indicate that a function never returns a value. For example, a function that throws an exception or terminates the program will have a return type of `Nothing`.
-
-Here is an example of a function that has a return type of `Nothing`:
-
-```kotlin
-fun error(): Nothing {
-    throw IllegalStateException("An error occurred.")
-}
-```
-
-In the above, the `error()` function throws an exception and does not return a value. Therefore, its return type is `Nothing`.
-
-### Unit
-
-In Kotlin, the `Unit` type represents the absence of a value, similar to the `void` type in other programming languages. It is a special type that is used to indicate that a function does not return a value.
-
-The `Unit` type can be used to specify that a function has a return type of `Unit` when it is not possible to infer the return type from the function's body. For example:
-
-```kotlin
-fun main() {
-
-}
-
-
-fun doSomething(): Unit {
-    // Perform some action here
-}
-```
-
-In the above example, the `doSomething()` function performs an action and does not return a value. Therefore, its return type is `Unit`.
diff --git a/content/kotlin/concepts/variables/variables.md b/content/kotlin/concepts/variables/variables.md
new file mode 100644
index 00000000000..31a8ea73a6b
--- /dev/null
+++ b/content/kotlin/concepts/variables/variables.md
@@ -0,0 +1,70 @@
+---
+Title: 'Variables'
+Description: 'Variables are used whenever there’s a need to store a piece of data and ensures code re-usability.'
+Subjects:
+  - 'Computer Science'
+Tags:
+  - 'Variables'
+  - 'Data Types'
+CatalogContent:
+  - 'learn-java'
+  - 'paths/computer-science'
+---
+
+**Variable** is a storage location for a value that can be either mutable or read-only. The value stored in a variable can be of different types, such as numbers, characters, or strings.
+
+## Declaring a Variable
+
+A `variable` in Kotlin is declared using the `var` keyword for a mutable variable or the `val` keyword for a read-only variable. Here's an example of how to declare variables in Kotlin:
+
+```pseudo
+fun main() {
+    // Declare a mutable variable
+    var x: Int = 5
+    // Declare a read-only variable
+    val y: String = "Hello, World!"
+}
+```
+
+The type of a `variable` is optional in Kotlin, as the type can be inferred from the value assigned to the variable. For example, the following declarations are equivalent to the ones above:
+
+```kotlin
+fun main() {
+    // Declare a mutable variable with inferred type
+    var x = 5
+    // Declare a read-only variable with inferred type
+    val y = "Hello, World!"
+}
+```
+
+It's important to note that, unlike other programming languages, Kotlin doesn't have a `null` type. Instead, it has nullable and non-nullable types. A nullable type can hold a null value, while a non-nullable type cannot. To declare a nullable type, you can use the `?` operator after the type. For example:
+
+```kotlin
+fun main() {
+    // Declare a nullable variable
+    var z: String? = null
+}
+```
+
+One thing that not many people know about `variables` in Kotlin is that they can have `delegated` properties. A `delegated` property is a special type of property that is computed automatically by a delegate object, rather than being stored directly in the class.
+
+Here's an example of how to declare a delegated property in Kotlin:
+
+```kotlin
+import kotlin.reflect.KProperty
+class Example {
+    var prop: String by Delegate()
+}
+class Delegate {
+    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
+        return "$thisRef, thank you for delegating '${property.name}' to me!"
+    }
+    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
+        println("$value has been assigned to '${property.name}' in $thisRef.")
+    }
+}
+```
+
+In this example, the `prop` property of the `Example` class is delegated to an instance of the `Delegate` class. The `getValue` and `setValue` functions of the `Delegate` class define how the property is accessed and modified.
+
+`Delegated` properties are a powerful and flexible feature of Kotlin that can be used to implement various design patterns, such as the observer pattern or the proxy pattern. They can also be used to simplify code by abstracting away common property-related tasks, such as lazy initialization or thread-safe access.

From 6af23b8a7cc132baeedbece712d6c5e50a363939 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Fri, 6 Jan 2023 22:51:16 +0530
Subject: [PATCH 34/62] Update content/kotlin/concepts/variables/variables.md

Co-authored-by: SSwiniarski <86081858+SSwiniarski@users.noreply.github.com>
---
 content/kotlin/concepts/variables/variables.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/variables/variables.md b/content/kotlin/concepts/variables/variables.md
index 31a8ea73a6b..e6204b2072b 100644
--- a/content/kotlin/concepts/variables/variables.md
+++ b/content/kotlin/concepts/variables/variables.md
@@ -7,7 +7,7 @@ Tags:
   - 'Variables'
   - 'Data Types'
 CatalogContent:
-  - 'learn-java'
+  - 'learn-kotlin'
   - 'paths/computer-science'
 ---
 

From 6381b7b71a201e23e86255e2c3034407e7bcff3b Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Fri, 6 Jan 2023 22:51:22 +0530
Subject: [PATCH 35/62] Update content/kotlin/concepts/variables/variables.md

Co-authored-by: SSwiniarski <86081858+SSwiniarski@users.noreply.github.com>
---
 content/kotlin/concepts/variables/variables.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/variables/variables.md b/content/kotlin/concepts/variables/variables.md
index e6204b2072b..cd24a56002e 100644
--- a/content/kotlin/concepts/variables/variables.md
+++ b/content/kotlin/concepts/variables/variables.md
@@ -11,7 +11,7 @@ CatalogContent:
   - 'paths/computer-science'
 ---
 
-**Variable** is a storage location for a value that can be either mutable or read-only. The value stored in a variable can be of different types, such as numbers, characters, or strings.
+A **variable** is a storage location for a value that can be either mutable or read-only. The value stored in a variable can be of different types, such as numbers, characters, or strings.
 
 ## Declaring a Variable
 

From 664148fd8d564f626173a170295d4ddd9acea3cd Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Fri, 6 Jan 2023 22:51:28 +0530
Subject: [PATCH 36/62] Update content/kotlin/concepts/variables/variables.md

Co-authored-by: SSwiniarski <86081858+SSwiniarski@users.noreply.github.com>
---
 content/kotlin/concepts/variables/variables.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/variables/variables.md b/content/kotlin/concepts/variables/variables.md
index cd24a56002e..220b6f62576 100644
--- a/content/kotlin/concepts/variables/variables.md
+++ b/content/kotlin/concepts/variables/variables.md
@@ -15,7 +15,7 @@ A **variable** is a storage location for a value that can be either mutable or r
 
 ## Declaring a Variable
 
-A `variable` in Kotlin is declared using the `var` keyword for a mutable variable or the `val` keyword for a read-only variable. Here's an example of how to declare variables in Kotlin:
+A variable in Kotlin is declared using the `var` keyword for a mutable variable or the `val` keyword for a read-only variable. Here's an example of how to declare variables in Kotlin:
 
 ```pseudo
 fun main() {

From 36081dc589152a80da4e7f9452a94c5af73f31bd Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Fri, 6 Jan 2023 22:51:35 +0530
Subject: [PATCH 37/62] Update content/kotlin/concepts/variables/variables.md

Co-authored-by: SSwiniarski <86081858+SSwiniarski@users.noreply.github.com>
---
 content/kotlin/concepts/variables/variables.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/variables/variables.md b/content/kotlin/concepts/variables/variables.md
index 220b6f62576..11e82b89760 100644
--- a/content/kotlin/concepts/variables/variables.md
+++ b/content/kotlin/concepts/variables/variables.md
@@ -26,7 +26,7 @@ fun main() {
 }
 ```
 
-The type of a `variable` is optional in Kotlin, as the type can be inferred from the value assigned to the variable. For example, the following declarations are equivalent to the ones above:
+Declaring the type of a variable is optional in Kotlin, as the type can be inferred from the value assigned to the variable. For example, the following declarations are equivalent to the ones above:
 
 ```kotlin
 fun main() {

From b5a42f439ef31228738c8795eb771d66300f6864 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Fri, 6 Jan 2023 22:52:19 +0530
Subject: [PATCH 38/62] Update variables.md

---
 content/kotlin/concepts/variables/variables.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/variables/variables.md b/content/kotlin/concepts/variables/variables.md
index 11e82b89760..7ada09d3b38 100644
--- a/content/kotlin/concepts/variables/variables.md
+++ b/content/kotlin/concepts/variables/variables.md
@@ -17,7 +17,7 @@ A **variable** is a storage location for a value that can be either mutable or r
 
 A variable in Kotlin is declared using the `var` keyword for a mutable variable or the `val` keyword for a read-only variable. Here's an example of how to declare variables in Kotlin:
 
-```pseudo
+```kotlin
 fun main() {
     // Declare a mutable variable
     var x: Int = 5

From 8152444aa828eecc6994f799c577b2b8370ea5ba Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Sat, 7 Jan 2023 23:39:31 +0530
Subject: [PATCH 39/62] del

---
 .../kotlin/concepts/variables/variables.md    | 70 -------------------
 1 file changed, 70 deletions(-)
 delete mode 100644 content/kotlin/concepts/variables/variables.md

diff --git a/content/kotlin/concepts/variables/variables.md b/content/kotlin/concepts/variables/variables.md
deleted file mode 100644
index 7ada09d3b38..00000000000
--- a/content/kotlin/concepts/variables/variables.md
+++ /dev/null
@@ -1,70 +0,0 @@
----
-Title: 'Variables'
-Description: 'Variables are used whenever there’s a need to store a piece of data and ensures code re-usability.'
-Subjects:
-  - 'Computer Science'
-Tags:
-  - 'Variables'
-  - 'Data Types'
-CatalogContent:
-  - 'learn-kotlin'
-  - 'paths/computer-science'
----
-
-A **variable** is a storage location for a value that can be either mutable or read-only. The value stored in a variable can be of different types, such as numbers, characters, or strings.
-
-## Declaring a Variable
-
-A variable in Kotlin is declared using the `var` keyword for a mutable variable or the `val` keyword for a read-only variable. Here's an example of how to declare variables in Kotlin:
-
-```kotlin
-fun main() {
-    // Declare a mutable variable
-    var x: Int = 5
-    // Declare a read-only variable
-    val y: String = "Hello, World!"
-}
-```
-
-Declaring the type of a variable is optional in Kotlin, as the type can be inferred from the value assigned to the variable. For example, the following declarations are equivalent to the ones above:
-
-```kotlin
-fun main() {
-    // Declare a mutable variable with inferred type
-    var x = 5
-    // Declare a read-only variable with inferred type
-    val y = "Hello, World!"
-}
-```
-
-It's important to note that, unlike other programming languages, Kotlin doesn't have a `null` type. Instead, it has nullable and non-nullable types. A nullable type can hold a null value, while a non-nullable type cannot. To declare a nullable type, you can use the `?` operator after the type. For example:
-
-```kotlin
-fun main() {
-    // Declare a nullable variable
-    var z: String? = null
-}
-```
-
-One thing that not many people know about `variables` in Kotlin is that they can have `delegated` properties. A `delegated` property is a special type of property that is computed automatically by a delegate object, rather than being stored directly in the class.
-
-Here's an example of how to declare a delegated property in Kotlin:
-
-```kotlin
-import kotlin.reflect.KProperty
-class Example {
-    var prop: String by Delegate()
-}
-class Delegate {
-    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
-        return "$thisRef, thank you for delegating '${property.name}' to me!"
-    }
-    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
-        println("$value has been assigned to '${property.name}' in $thisRef.")
-    }
-}
-```
-
-In this example, the `prop` property of the `Example` class is delegated to an instance of the `Delegate` class. The `getValue` and `setValue` functions of the `Delegate` class define how the property is accessed and modified.
-
-`Delegated` properties are a powerful and flexible feature of Kotlin that can be used to implement various design patterns, such as the observer pattern or the proxy pattern. They can also be used to simplify code by abstracting away common property-related tasks, such as lazy initialization or thread-safe access.

From 435aeb69b7afe888bbfbab9dc9796a22bff999ab Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Sun, 8 Jan 2023 16:19:18 +0530
Subject: [PATCH 40/62] added strings.md

---
 content/kotlin/concepts/strings/strings.md | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 content/kotlin/concepts/strings/strings.md

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
new file mode 100644
index 00000000000..e69de29bb2d

From d73cfa97d59ff975b631d1ab01e8ca9d774bafdb Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Sun, 8 Jan 2023 16:20:21 +0530
Subject: [PATCH 41/62] strings.md

---
 content/kotlin/concepts/strings/strings.md | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index e69de29bb2d..e4e0e6f02df 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -0,0 +1,13 @@
+---
+Title: 'Strings'
+Description: 'A string in Kotlin is an object that holds a sequence of characters contained within a pair of double quotes (").'
+Subjects:
+  - 'Computer Science'
+Tags:
+  - 'Strings'
+  - 'Data Types'
+  - 'Characters'
+CatalogContent:
+  - 'learn-kotlin'
+  - 'paths/computer-science'
+---

From 52762427c70b51d876cf1533db77310463d86359 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Sun, 8 Jan 2023 16:26:05 +0530
Subject: [PATCH 42/62] 2

---
 content/kotlin/concepts/strings/strings.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index e4e0e6f02df..e5edefb3367 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -11,3 +11,5 @@ CatalogContent:
   - 'learn-kotlin'
   - 'paths/computer-science'
 ---
+
+**Strings** in Kotlin are objects that can hold a sequence of characters contained within a pair of double quotes (`"`). It is not a primitive data type.

From 9ccfd0fd33270b71f76d5b062345008e65e42de8 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Sun, 8 Jan 2023 16:41:22 +0530
Subject: [PATCH 43/62]  added strings.md in the kotlin folder

---
 content/kotlin/concepts/strings/strings.md | 32 +++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index e5edefb3367..7fb3e815baf 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -12,4 +12,34 @@ CatalogContent:
   - 'paths/computer-science'
 ---
 
-**Strings** in Kotlin are objects that can hold a sequence of characters contained within a pair of double quotes (`"`). It is not a primitive data type.
+In Kotlin, a `string` is an immutable object that represents a sequence of characters.
+
+## Syntax
+
+```pseudo
+val stringName: String = "string value"
+```
+
+## Example
+
+You can also use `string` templates to include dynamic values in your strings. To do this, you enclose the dynamic value in curly braces and precede it with a dollar sign, like this:
+
+```kotlin
+val dynamicValue = 4
+val stringName: String = "The value of dynamicValue is $dynamicValue"
+```
+
+Here is an example of how you might use strings in Kotlin:
+
+```kotlin
+fun main(args: Array<String>) {
+    val greeting: String = "Hello, World!"
+    println(greeting)
+}
+```
+
+The output for the above code will be:
+
+```
+Hello, World!
+```

From 9156296d2643d352a0a32a095b2a62f861b2f1de Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Sun, 8 Jan 2023 22:02:10 +0530
Subject: [PATCH 44/62] did the changes that were asked :D

---
 content/kotlin/concepts/strings/strings.md | 31 +++++++++++++++++-----
 1 file changed, 24 insertions(+), 7 deletions(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 7fb3e815baf..34df43c11ed 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -22,13 +22,6 @@ val stringName: String = "string value"
 
 ## Example
 
-You can also use `string` templates to include dynamic values in your strings. To do this, you enclose the dynamic value in curly braces and precede it with a dollar sign, like this:
-
-```kotlin
-val dynamicValue = 4
-val stringName: String = "The value of dynamicValue is $dynamicValue"
-```
-
 Here is an example of how you might use strings in Kotlin:
 
 ```kotlin
@@ -43,3 +36,27 @@ The output for the above code will be:
 ```
 Hello, World!
 ```
+
+## String Templates
+
+We can also use `string` templates to include dynamic values in your strings. To do this, you enclose the dynamic value in curly braces and precede it with a dollar sign, like this:
+
+```kotlin
+val dynamicValue = 4
+val stringName: String = "The value of dynamicValue is $dynamicValue"
+```
+
+Below we will see an example with use of curly braces `{}`:
+
+```java
+val a = 4
+val b = 5
+val stringName: String = "The sum of a and b is ${a + b}"
+System.out.println(stringName)
+```
+
+The output for the above code will be:
+
+```
+The sum of a and b is 9
+```

From 19bf5195f886f9aab613d76004711e3e74c68141 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 00:49:45 +0530
Subject: [PATCH 45/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 34df43c11ed..43d0417f76b 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -1,6 +1,6 @@
 ---
 Title: 'Strings'
-Description: 'A string in Kotlin is an object that holds a sequence of characters contained within a pair of double quotes (").'
+Description: 'Strings are immutable objects that are sequences of characters contained within a pair of double quotes.'
 Subjects:
   - 'Computer Science'
 Tags:

From d5e06dccb71ffacec1dee1517d3b41a773f4cd0b Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 00:49:53 +0530
Subject: [PATCH 46/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 43d0417f76b..68de55cd4c5 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -12,7 +12,7 @@ CatalogContent:
   - 'paths/computer-science'
 ---
 
-In Kotlin, a `string` is an immutable object that represents a sequence of characters.
+**Strings** are immutable objects that represents a sequence of characters contained within double quotes (`""`).
 
 ## Syntax
 

From 6fcd1c8423a8d0cc0349eec2f30ecc2ce72b0aaf Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 00:50:02 +0530
Subject: [PATCH 47/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 68de55cd4c5..97870a09480 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -20,6 +20,7 @@ CatalogContent:
 val stringName: String = "string value"
 ```
 
+In Kotlin, string values are always defined as instances of the `String` class.
 ## Example
 
 Here is an example of how you might use strings in Kotlin:

From 1fe84731f0165ad5b8852470668a824bd4c676d8 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 00:50:13 +0530
Subject: [PATCH 48/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 97870a09480..3c7d3b5a6ae 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -27,8 +27,8 @@ Here is an example of how you might use strings in Kotlin:
 
 ```kotlin
 fun main(args: Array<String>) {
-    val greeting: String = "Hello, World!"
-    println(greeting)
+  val greeting: String = "Hello, World!"
+  println(greeting)
 }
 ```
 

From 8cc3af337d38aa523e58eade3000b22c8de3cee9 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 00:50:20 +0530
Subject: [PATCH 49/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 3c7d3b5a6ae..be4801fc3da 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -34,7 +34,7 @@ fun main(args: Array<String>) {
 
 The output for the above code will be:
 
-```
+```shell
 Hello, World!
 ```
 

From 6f25a052fcad1de0294c46ec1706dd7b6a41fca9 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 00:50:31 +0530
Subject: [PATCH 50/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index be4801fc3da..76cf2610640 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -44,7 +44,13 @@ We can also use `string` templates to include dynamic values in your strings. To
 
 ```kotlin
 val dynamicValue = 4
-val stringName: String = "The value of dynamicValue is $dynamicValue"
+val stringOne: String = "The value of dynamicValue is $dynamicValue"
+System.out.println(stringOne)
+
+val a = 4
+val b = 5
+val stringTwo: String = "The sum of a and b is ${a + b}"
+System.out.println(stringTwo)
 ```
 
 Below we will see an example with use of curly braces `{}`:

From 1e88f8cef220d32a3ecb10f4d392bd5e3ad049a2 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 00:50:41 +0530
Subject: [PATCH 51/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 76cf2610640..010e1b3d1e6 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -40,7 +40,7 @@ Hello, World!
 
 ## String Templates
 
-We can also use `string` templates to include dynamic values in your strings. To do this, you enclose the dynamic value in curly braces and precede it with a dollar sign, like this:
+Templates can also be used to dynamically produce string values. Dynamic values don't have to start as strings, and can either be directly referenced with a dollar sign (`$`) or evaluated as a string with additional curly braces (`{}`). The following showcases both techniques:
 
 ```kotlin
 val dynamicValue = 4

From afd77413db1dfb2eee7d32e3844f3bb817026a11 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 00:50:57 +0530
Subject: [PATCH 52/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 010e1b3d1e6..31469cd83c7 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -53,15 +53,6 @@ val stringTwo: String = "The sum of a and b is ${a + b}"
 System.out.println(stringTwo)
 ```
 
-Below we will see an example with use of curly braces `{}`:
-
-```java
-val a = 4
-val b = 5
-val stringName: String = "The sum of a and b is ${a + b}"
-System.out.println(stringName)
-```
-
 The output for the above code will be:
 
 ```

From dc76d6d21b5ae93b88ccfc4c5503a7986f88a45f Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 00:51:05 +0530
Subject: [PATCH 53/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 31469cd83c7..a854261ff90 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -53,7 +53,7 @@ val stringTwo: String = "The sum of a and b is ${a + b}"
 System.out.println(stringTwo)
 ```
 
-The output for the above code will be:
+This will print the following output:
 
 ```
 The sum of a and b is 9

From 2da667f310025d77b8453668868abdc4ac52c7ad Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 00:51:13 +0530
Subject: [PATCH 54/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index a854261ff90..46ff97ba067 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -55,6 +55,6 @@ System.out.println(stringTwo)
 
 This will print the following output:
 
-```
+```shell
 The sum of a and b is 9
 ```

From 6f8b56377c7e9b4e4f248a149e7ed0efdfe478cd Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 00:51:19 +0530
Subject: [PATCH 55/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 46ff97ba067..1cd3818a9ef 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -56,5 +56,6 @@ System.out.println(stringTwo)
 This will print the following output:
 
 ```shell
+The value of dynamicValue is 4
 The sum of a and b is 9
 ```

From 21246ef89e0083486e04322dc66f19fb68e1b431 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 18:36:32 +0530
Subject: [PATCH 56/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 1cd3818a9ef..28d4a8ea075 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -12,7 +12,7 @@ CatalogContent:
   - 'paths/computer-science'
 ---
 
-**Strings** are immutable objects that represents a sequence of characters contained within double quotes (`""`).
+**Strings** are immutable objects that represent a sequence of characters contained within double quotes (`""`).
 
 ## Syntax
 

From a040b77806ab5d6ac0ba6a7df532035a2d19b033 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 18:36:40 +0530
Subject: [PATCH 57/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 28d4a8ea075..9d3f5d29cc1 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -21,6 +21,11 @@ val stringName: String = "string value"
 ```
 
 In Kotlin, string values are always defined as instances of the `String` class.
+
+### String Templates
+
+Templates can also be used to dynamically produce string values. Dynamic values don't have to start as strings, and can either be directly referenced with a dollar sign (`$`) or evaluated as a string with additional curly braces (`{}`).
+
 ## Example
 
 Here is an example of how you might use strings in Kotlin:

From 50242e9de90dec3069e2305c08006d3529b51624 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 18:36:54 +0530
Subject: [PATCH 58/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 9d3f5d29cc1..544a691ef6e 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -28,7 +28,7 @@ Templates can also be used to dynamically produce string values. Dynamic values
 
 ## Example
 
-Here is an example of how you might use strings in Kotlin:
+The following example showcases the various ways strings are used in Kotlin:
 
 ```kotlin
 fun main(args: Array<String>) {

From 4c4dfb64b1599e120ec910cb986a50520f965761 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 18:37:05 +0530
Subject: [PATCH 59/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 544a691ef6e..b07aae96c9a 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -32,8 +32,19 @@ The following example showcases the various ways strings are used in Kotlin:
 
 ```kotlin
 fun main(args: Array<String>) {
+  // String literals
   val greeting: String = "Hello, World!"
   println(greeting)
+  
+  // String templates
+  val dynamicValue = 4
+  val stringOne: String = "The value of dynamicValue is $dynamicValue"
+  System.out.println(stringOne)
+  
+  val a = dynamicValue
+  val b = 5
+  val stringTwo: String = "The sum of a and b is ${a + b}"
+  System.out.println(stringTwo)
 }
 ```
 

From 7703ddf2c1418183f8b413fc27d64582291395b3 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 18:37:13 +0530
Subject: [PATCH 60/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index b07aae96c9a..ec522eb4ce3 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -52,6 +52,8 @@ The output for the above code will be:
 
 ```shell
 Hello, World!
+The value of dynamicValue is 4
+The sum of a and b is 9
 ```
 
 ## String Templates

From 763fe08e4b2f4fb1e19a58f25267c9b7142d62a6 Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 18:37:23 +0530
Subject: [PATCH 61/62] Update content/kotlin/concepts/strings/strings.md

Co-authored-by: Brandon Dusch <brandondusch@gmail.com>
---
 content/kotlin/concepts/strings/strings.md | 21 ---------------------
 1 file changed, 21 deletions(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index ec522eb4ce3..6a5fed1a524 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -56,24 +56,3 @@ The value of dynamicValue is 4
 The sum of a and b is 9
 ```
 
-## String Templates
-
-Templates can also be used to dynamically produce string values. Dynamic values don't have to start as strings, and can either be directly referenced with a dollar sign (`$`) or evaluated as a string with additional curly braces (`{}`). The following showcases both techniques:
-
-```kotlin
-val dynamicValue = 4
-val stringOne: String = "The value of dynamicValue is $dynamicValue"
-System.out.println(stringOne)
-
-val a = 4
-val b = 5
-val stringTwo: String = "The sum of a and b is ${a + b}"
-System.out.println(stringTwo)
-```
-
-This will print the following output:
-
-```shell
-The value of dynamicValue is 4
-The sum of a and b is 9
-```

From bd27e06a2cb48a98c5e78855e7fd742c50d1c89e Mon Sep 17 00:00:00 2001
From: Daksha Deep <dakshadeep1234@gmail.com>
Date: Wed, 11 Jan 2023 18:39:43 +0530
Subject: [PATCH 62/62] added changes

---
 content/kotlin/concepts/strings/strings.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/content/kotlin/concepts/strings/strings.md b/content/kotlin/concepts/strings/strings.md
index 6a5fed1a524..b1a3a290364 100644
--- a/content/kotlin/concepts/strings/strings.md
+++ b/content/kotlin/concepts/strings/strings.md
@@ -35,12 +35,12 @@ fun main(args: Array<String>) {
   // String literals
   val greeting: String = "Hello, World!"
   println(greeting)
-  
+
   // String templates
   val dynamicValue = 4
   val stringOne: String = "The value of dynamicValue is $dynamicValue"
   System.out.println(stringOne)
-  
+
   val a = dynamicValue
   val b = 5
   val stringTwo: String = "The sum of a and b is ${a + b}"
@@ -55,4 +55,3 @@ Hello, World!
 The value of dynamicValue is 4
 The sum of a and b is 9
 ```
-