Kotlin Functions and Project Setup

Lesson 2: Functions

• Functions in Kotlin are blocks of code performing specific tasks.
• They structure larger programs into smaller, modular units.
• Functions are declared using the fun keyword.
• Functions can accept arguments with named or default values.
• main() is the entry point for program execution in Kotlin.
• Arguments to main() are optional.

Setting up Kotlin Project

• Create a file in your project.
• Create a main() function within the file.
• Pass arguments to main() (optional).
• Use passed arguments in function calls (optional).
• Run the Kotlin program.

Creating a New Kotlin File

• Right-click the src folder in your project's pane (in IntelliJ).
• Select New > Kotlin File/Class.
• Press Enter.

Creating a main() function

• main() is the entry point for a Kotlin program.
• It is declared in the Kotlin file.
• The args parameter in main() is an Array<String>, it may contain arguments passed at execution time.

Running a Kotlin Program

• Locate the Run icon near the main() function.
• Click the Run icon to initiate program execution.

Passing Arguments to main()

• Use Run > Edit Configurations to open configurations.
• Input arguments in Program arguments field.

Using Arguments in main()

• Access input arguments using args[] in main().
• For example to access the first argument, use args[0]

Kotlin (Almost) Everything has a Value

• In Kotlin, (almost) everything is an expression, even if statements.
• Expressions always return a specific value.
• Unit is used to represent the absence of data.

Kotlin Expression Values

• Kotlin values can often be of type Unit.
• Unit is the default return type of functions with no meaningful output.

Functions in Kotlin

• Functions (a block of code that does specific task) breakdown the program to manageable modules.
• Declared using fun keyword
• You can specify parameters with named and default arguments.

Parts of a Function

• A function is made up from parts.

Unit returning Functions

• Functions with no useful return values have a return type of Unit.
• The keyword Unit is optional, it's the default type for function with no return value.

Function Arguments

• Functions can have default, required and named arguments.

Default Parameters

• Default parameters (values) are given to function arguments to specify a fallback.
• Use the = symbol to assign default values after type declaration.

Required Parameters

• Without default values, parameter values are required.

Default Versus Required Parameters

• Functions can use a mix of default and required parameters.

Named Arguments

• For enhanced readability, use named arguments for required parameters.
• Position default arguments after required arguments.

Compact Functions

• Compact functions are more readable than lengthy ones.
• They combine a single expression with function body.

Single-Expression Functions

• Single expression functions have one line that does the work.

Lambdas and Higher-Order Functions

• Lambdas create functions without names.
• Higher-order functions use lambdas as inputs or outputs, creating flexible tools.

Kotlin Functions as First-Class

• Kotlin functions can be stored, passed and returned in data structures.

Higher-Order Functions

• Higher order functions accept or return functions.
• This makes them flexible in code.

Passing Function Reference

• The :: operator gives the function's reference, not its call.

Last Parameter Call Syntax

• Kotlin lets you place function parameters last to keep the code simple.

Using Higher-Order Functions

• Many Kotlin built-in functions use the last parameter call syntax.

List Filters

• Get portions of a list based on filters.

Iterating through Lists

• Function literals with one parameter can omit ->.

List Filters

• filter condition determines inclusion of an element.

Eager and Lazy Filters

• Eager evaluation creates a new list, regardless of usage.
• Lazy evaluation creates a list only if needed.

Eager Filters

• Filters create entirely new lists.

Lazy Filters

• Lazy evaluation means a list is created only when used.

Sequences ----> Lists

• Sequences create lists using toList().

Other List Transformations

• Use map() to transform each list item.
• Use flatten() for a single list of nested collections.

Summary

• Lesson 2 covered the creation of Kotlin files, main() function, passing arguments and using values.

• Key concepts include Unit, functions as first-class objects, compact/single-line functions and higher-order functions, and list filtering mechanisms.