Examples 01-09

Author: tib

contents/[01]the-print-function/index.md

@@ -4,33 +4,35 @@ description: ""
 order: 1
 ---
 
-The print function displays text or values on the screen. In the simplest form it means we can display messages on the command line. Create a new file named `main.swift` and place the following Swift code inside the file:
+The print function displays text or values on the screen. 
 
-```swift
-// FILE: main.swift
+We can display messages on the command line using print, such as the famous "Hello, World!" text. To try it out, create a new file named main.swift and place the following Swift code inside:
 
+```swift
 print("Hello, World!")
-
-/**
-Run Swift files using the command line:
-
-$ swift main.swift
-> Hello, World!
-*/
 ```
 
-Run the program via the `swift main.swift` command, it will display the `Hello, World!` message. 
+The Swift toolchain is the complete set of tools — including the compiler, standard library, debugger, and package manager — that enables building, running, and testing Swift programs across platforms.
+
+The `swift` command is included in the Swift toolchain. By running your program with the `swift` command, the compiler executes the code and displays the classic "Hello, World!" message:
 
----
 
 ```sh
-# run the swift file
 swift main.swift
 # Hello, world!
+```
+
+The Swift compiler is part of the Swift toolchain, and the `swiftc` command is used to compile Swift source files into executable binaries. You can start the compilation process by running the following command:
 
-# build the program
+```sh
 swiftc -o app main.swift
-# run the program
+```
+
+The `swiftc` command generates an `app` binary, which you can then execute directly from the command line like this:
+
+```sh
 ./app
 # Hello, world!
-```
+```
+Now that we can build and run basic Swift programs, it’s time to dive deeper into the language and explore its core features.
+

contents/[02]constants-and-variables/index.md

@@ -4,27 +4,56 @@ description: ""
 order: 2
 ---
 
-foo
+A **constant** is a named container in memory that holds a value which cannot be changed after it is set. 
+
+Constants are used to store information that remains the same throughout the program's execution. Because their values are fixed, constants are also referred to as immutable variables.
+
+You can define a constant by using the `let` keyword. Then you choose the name you wish, finally assign the value of the constant after an equal `=` sign (assignment operator):
 
 ```swift
-// a constant
-let name: String = "John"
-print(name) // => John
-
-name = "Bob" // => ERROR
-// Cannot assign to value:
-//     'name' is a 'let' constant
-
-// a variable
-var age: Int = 42
-age = 69
-print(age) // => 69
+/// firstName is a constant, it can never change
+let firstName = "Kitti"
 ```
 
-bar
+If we try to assign another value to an existing constant, we get a compile-time error:
+
+```swift
+let firstName = "Kitti"
+
+/// Cannot assign to value: 'firstName' is a 'let' constant
+firstName = "Tibor"
+```
+
+A **variable** is a named container in memory that stores a value which can change during program execution.
+
+The value of a variable can change. It is used to store and update information as needed. We also refer to variables as mutable variables.
+
+You can define a variable using the `var` keyword:
+
+```swift
+/// We assign the value "Takács" to the lastName variable
+var lastName = "Takács"
+```
+
+Since `lastName` is a variable, it's possible to change its value:
+
+```swift
+var lastName = "Takács"
+
+/// we change the value of the lastName variable to "Bödecs"
+lastName = "Bödecs"
+```
+
+Here's the complete example including a constant and a variable:
+
+```swift
+let firstName = "Kitti"
+var lastName = "Takács"
+
+lastName = "Bödecs"
 
-```sh
-swift main.swift
+/// print out the full name
+print(firstName, lastName)
 ```
 
-baz
+In the previous example, we declared only string constants and variables. Now, let's explore other common data types available in the Swift programming language.

contents/[03]standard-types/index.md

@@ -5,24 +5,48 @@ order: 3
 ---
 
 
-foo
+A `String` type is a sequence of characters used to represent text in programming. It can include letters, numbers, symbols, spaces — and even emojis.
 
 ```swift
-let b: Bool = false
+let firstName: String = "Kitti"
+var lastName = "Bödecs"
 
-let i: Int = 6
+print(firstName, lastName)
+```
 
-let f: Float = 4.20
+A `Bool` (Boolean) data type represents two possible values: `true` or `false`. It's used to handle logical decisions in programming.
 
-let d: Double = 6.9
+```swift
+let isDeveloper: Bool = true
+print(isDeveloper)
 
-let s: String = "Lorem ipsum"
+var isItMonday = false
+print(isItMonday)
 ```
 
-bar
+An `Int` type (short for integer) stores whole numbers, either positive or negative. It is also possible to perform mathematical operations by using Int types:
+
+```swift
+let x: Int = 12
+let y = 3
 
-```sh
-swift main.swift
+print(x, y)
 ```
 
-baz
+A `Double` data type is used to store numbers with decimal points, allowing for more precision than an `Int`. It is commonly used for calculations requiring fractional values.
+
+```swift
+let pi: Double = 3.14
+print(pi)
+
+let mph = 0.621371
+print(mph)
+```
+
+Swift is smart enough to automatically figure out the type of a variable or constant without explicitly writing it. This is called _type inference_. 
+
+Type inference works with `Bool`, `Int`, `Double` and `String` types.
+
+Next, let's explore string operations in Swift.
+
+

contents/[04]string-operations/index.md

@@ -4,23 +4,75 @@ description: ""
 order: 4
 ---
 
+The plus sign (addition operator) works on `String` types to join multiple strings together. This is often called as string concatenation:
 
-foo
+```swift
+let firstName = "Kitti"
+let lastName = "Bödecs"
+
+let fulName = firstName + " " + lastName 
+print(fulName)
+```
+
+Use the `\()` syntax to insert values into a String. Interpolation works with any data type, such as `Int` or `Double`.
+
+```swift
+var x = 12
+var y = 6
+let pi = 3.14
+let name = "Kitti"
+
+print("Hello, my name is \(name).")  
+print("The coordinates are x: \(x) and y: \(y)")
+print("Pi is always \(pi).")
+```
+
+Use triple quotes `"""` to define a string that spans multiple lines:
 
 ```swift
-let name = "John"
-let age = 42
-let end = "years old."
+let lyrics = """
+    You belong
+    with me.
+    """
 
-// String interpolation
-print("\(name) is \(age) \(end).")
-// => John is 42 years old.
+print(lyrics)
 ```
 
-bar
+When using multiline string literals, the closing triple quote `"""` must align with the start of the content. Whitespace is preserved exactly as written when using multiline strings.
+
+You can check if a string is empty by using the `isEmpty` property. The `count` property returns the number of characters. It is also possible to turn a string into a lowercase or uppercase string:
+
 
-```sh
-swift main.swift
+```swift
+let helloWorld = "Hello, World!"
+
+print(helloWorld.isEmpty)
+print(helloWorld.count)
+print(helloWorld.uppercased())
+print(helloWorld.lowercased())
 ```
 
-baz
+To include double quotes (or other special characters) inside a string, use the backslash `\` to escape them:
+
+```swift
+let quote = "He said: \"Hello!\"."
+
+print(quote)
+```
+
+If you prefer to avoid escape characters, you can use raw string literals. Raw strings are defined using the `#` symbol before and after the quotes, allowing you to include special characters like double quotes without needing to escape them:
+
+```swift
+let quote = #"He said: "Hello!"."#
+print(quote)
+```
+
+You can also use string interpolation with raw strings. To do this, add a `#` after the backslash, like `\#(value)`, inside the raw string literal:
+
+```swift
+let name = "Kitti"
+print(#"Hello, my name is \#(name)."#) 
+```
+
+You may use multiple `#` delimiter characters; if you do, you must use the corresponding number of characters when interpolating.
+