Index
A
- abstract classes / Abstract classes
- Actors / Actors
- advantages, immutability
- thread safety / Thread safety
- low coupling / Low coupling
- referential transparency / Referential transparency
- failure atomicity / Failure atomicity
- caching / Caching
- compiler optimization / Compiler optimization
- pure functions / Pure functions
- Algebraic Data Type (ADT) / Implementing a functional list
- Android Studio
- using / Using IntelliJ IDEA or Android Studio
- reference / Using IntelliJ IDEA or Android Studio
- annotations / Annotations
- anonymous class / Abstract classes
- anonymous functions / Lambda
- Any type / The Any type
- applicative / Applicatives
- Arrow
- function composition / Function composition
- partial application / Partial application
- Reverse / Reverse
- pipes / Pipes
- pipe function / Pipes
- type hierarchy / Arrow's type hierarchy
- Arrows code generation
- configuring / Configuring Arrows code generation
B
- binary operators / Binary operators
- binding / Binding
C
- C++ Standard Template Library (STL) / An introduction to collections
- caching
- advantages / Caching
- callbacks / Callbacks
- canonical methods / Canonical methods
- channel pipelines / Channel pipelines
- channels / Channels
- class delegation / Class delegation
- classes
- about / Classes
- properties / Properties
- methods / Methods
- code complexity
- versus resource consumption / Coroutines
- collection data types
- List / List and MutableList
- MutableList / List and MutableList
- Set / Set and MutableSet
- MutableSet / Set and MutableSet
- Map / Map and MutableMap
- MutableMap / Map and MutableMap
- Collections
- grouping / Grouping collections
- versus Streams / Collections versus Streams
- collections framework
- about / An introduction to collections
- interfaces / An introduction to collections
- implementations / An introduction to collections
- algorithms / An introduction to collections
- advantages / The advantages of a collections framework
- data operations / Data operations in a collection
- Collector class
- implementations / Collector and Stream.collect – collecting Streams
- companion objects / Companion objects
- comprehension / Option
- constant / Identity and constant
- Content Management System (CMS) / What is functional programming?
- control structures, Kotlin
- about / Control structures
- if expression / if expression
- when expression / when expression
- for loop / for loop
- while and do loops / while and do loops
- copy() method / The copy() method
- corecursion
- about / Recursion and corecursion
- with State / Corecursion with State
- coroutine context / Coroutine context
- coroutines
- about / Introduction to coroutines
- Hello World application / Hello, coroutine world!
- real-case scenario / Using coroutines in real life
- synchronous implementation / Synchronous implementation
- example / Coroutines
- coupling / Low coupling
- currying
- about / Currying
- versus partial application / Differences between the currying and partial application
- custom delegation / Custom delegation
D
- data classes / Data classes
- data operations, collection
- about / Data operations in a collection
- map function / The map function
- filter function / The filter function
- flatMap function / The flatMap function
- drop functions / The drop functions
- take functions / The take functions
- zip function / The zip function
- default parameters / Default parameters
- delegated map / Delegated map
- delegates
- about / Introduction to delegation
- in Kotlin / Delegates in Kotlin
- Delegates.notNull function / The Delegates.notNull function and lateinit
- Delegates.Observable
- property value change, observing with / Observing property value change with Delegates.Observable
- Delegates.vetoable / The power of veto – Delegates.vetoable
- delegation
- about / Introduction to delegation, Understanding delegation
- property delegation / Property delegation (standard delegates)
- custom delegation / Custom delegation
- class delegation / Class delegation
- dispatch receiver / Extension functions as members
- disposing / Subscribing and disposing
- distributable Gradle command
- creating / Creating a distributable Gradle command
- Domain Specific Languages (DSLs)
- creating / Creating a DSL
- drop functions / The drop functions
E
- Either
- used, for managing errors / Either
- Elm / Pipes
- Elvis operator / The Elvis (?:) operator
- empty Streams
- creating / Creating empty Streams – Stream.empty()
- Enterprise Integration Patterns (EIP) / Channel pipelines
- Enum / Enum
- extension functions
- about / Extension functions, Extension functions
- and inheritance / Extension functions and inheritance
- as members / Extension functions as members
- with conflicting names / Extension functions with conflicting names
- for objects / Extension functions for objects
F
- filter function / The filter function
- first-class functions / First-class and higher-order functions
- flatMap function / The flatMap function
- flip function / Reverse
- functional collections / Functional collections
- functional list
- implementing / Implementing a functional list
- functional programming
- about / What is functional programming?
- benefits / What is functional programming?
- first-class function / First-class and higher-order functions
- higher-order functions / First-class and higher-order functions
- pure functions / Pure functions
- recursive functions / Recursive functions
- lazy evaluation / Lazy evaluation
- combining, with OOP / Combining FP with OOP
- functional reactive frameworks
- for Kotlin / Functional reactive frameworks for Kotlin
- functional reactive programming / Functional reactive programming
- function arguments / Functions in Kotlin
- function body / Functions in Kotlin
- function composition / Function composition
- functions
- about / Functions in Kotlin
- functionalities / Functions in Kotlin
- example / Functions in Kotlin
- parts / Functions in Kotlin
- two values, returning from / Returning two values from a function
- extension functions / Extension functions, Extension functions
- default arguments / Default arguments
- nested functions / Nested functions
- types / Function types in functional programming
- as properties / Function as property
- high-order functions / High order functions
- pure functions / Pure functions and side effects
- single expression functions / Single-expression functions
- infix functions / Infix functions
- inline functions / Inline functions
- functors / Functors
- future / Java Futures
G
- general-purpose language (GPL) / Type-safe builders
- generalisation / Inheritance
- generic programming / Generics
- Gradle
- reference / Using Gradle
- installing, through SDKMAN / Install Gradle through SDKMAN
- Hello World code, creating / Creating our Hello World code
- Gradle files
- importing, with IntelliJ IDEA / Importing Gradle files with IntelliJ IDEA
- Gradle project file
- creating / Creating a Gradle project file
H
- HamKrest
- reference / Infix functions
- Haskell / Functors
- Hello World application
- with coroutines / Hello, coroutine world!
- high-order functions / High order functions
- Higher-Kinded Types (HKT) / Arrow's type hierarchy
- higher-order function / First-class and higher-order functions
- http4k
- reference / Using coroutines in real life
I
- identity / Identity and constant
- immutability
- about / What is immutability?
- implementing, in Kotlin / Implementing immutability in Kotlin
- reference / Implementing immutability in Kotlin
- var, versus val / The difference between var and val
- compile time constants / Compile time constants
- types / Types of immutability
- referential immutability / Immutable reference (referential immutability)
- advantages / The advantages of immutability
- disadvantages / The disadvantages of immutability
- immutable collections / Immutable collections
- immutable values / Immutable values
- immutable variable / What is immutability?
- implementations, Collectors
- Collectors.toList() / The Collectors.toList(), Collectors.toSet(), and Collectors.toCollection() methods
- Collectors.toSet() / The Collectors.toList(), Collectors.toSet(), and Collectors.toCollection() methods
- Collectors.toCollection() / The Collectors.toList(), Collectors.toSet(), and Collectors.toCollection() methods
- Collectors.toMap() / Collecting into Map – Collectors.toMap()
- Collectors.joining() / Joining Stream of strings – Collectors.joining()
- Collectors.groupingBy() / Grouping elements of Stream – Collectors.groupingBy()
- indexed access operator / Indexed access
- infix functions / Infix functions
- inheritance / Inheritance
- inline functions
- about / Inline functions
- restrictions / Inline restrictions
- IntelliJ IDEA
- using / Using IntelliJ IDEA or Android Studio
- reference / Using IntelliJ IDEA or Android Studio
- Gradle files, importing with / Importing Gradle files with IntelliJ IDEA
- interfaces / Interfaces
- Internet Chuck Norris Database API
- reference / Using coroutines in real life
- invoke operator / Invoke
- Iterable instance
- to Observable / Iterator<T>.toObservable
J
- Java Microbenchmark Harness (JMH) / Recursive functions
- JVM threads / Understanding JVM threads
K
- Kluent
- reference / Infix functions
- Kotlin
- immutability, implementing / Implementing immutability in Kotlin
- functional reactive frameworks / Functional reactive frameworks for Kotlin
- writing / Writing and running Kotlin
- running / Writing and running Kotlin
- installing, through SDKMAN / Installing Kotlin through SDKMAN
- syntax / Basic Kotlin syntax
- general features / General features
- packages / Packages
- string concatenation / String concatenation and interpolation
- string interpolation / String concatenation and interpolation
- comments / Comments
- control structures / Control structures
- Kotlin's REPL
- working with / Kotlin's REPL
- Kotlin Evolution and Enhancement Process (KEEP) / Arrow's type hierarchy
- Kotlin files
- compiling / Compiling and executing Kotlin files
- executing / Compiling and executing Kotlin files
- Kotlin Koans
- reference / Going further
- Kotlin online / Kotlin online
- Kotson
- reference / Using coroutines in real life
- Kovenant
- reference / Promises with Kovenant
L
- lambda
- lambda parameter / Lambda
- lateinit / The Delegates.notNull function and lateinit
- lazy evaluation / Lazy evaluation
- lazy function / The lazy function
- lenses
- generating / Generating lenses
- local delegates / Local delegates
- logical component / Logical complement
M
- map function / The map function
- memoization / Memoization
- methods
- about / Methods
- destructing / Destructuring methods
- methods, Stream factory
- Stream Builder / Stream Builder
- Stream.empty() / Creating empty Streams – Stream.empty()
- Stream.of() / Creating a Stream by passing elements – Stream.of()
- Stream.generate() / Generating Streams – Stream.generate()
- Micro
- reference / Compiling and executing Kotlin files
- monad / Monads
- monad transformers / Monad transformers
- mutable state
- managing / Managing mutable state
- switching context technique / Switching contexts
- mutexes / Mutexes
N
- named parameters
- about / Named parameters
- on high-order functions / Named parameters on high-order functions
- nested functions / Nested functions
- non-null types
- checking for / Checking for non-null types
- Nothing type / The Nothing type
- null
- checking for / Checking for null
- managing, Option used / Option
- nullable types / Nullable types
O
- !! operator / The (!!) operator
- object declaration / Object declarations
- object expression / Abstract classes
- objects
- about / Objects
- companion objects / Companion objects
- Observable
- about / Observables
- working / How Observable works
- versus Streams / Collections versus Streams
- Observable.create method / The Observable.create method
- Observable.from methods / The Observable.from methods
- Observable contract
- reference / The Observable.create method
- Observer interface
- Subscriber operator / Subscriber – the Observer interface
- Ocaml / Pipes
- OOP
- functional programming, combining with / Combining FP with OOP
- operations/functional interfaces, Stream API
- filter() / Working with Streams
- map() / Working with Streams
- mapToInt()/mapToLong()/mapToDouble() / Working with Streams
- flatMap() / Working with Streams
- flatMapToInt()/flatMapToLong()/flatMapToDouble() / Working with Streams
- distinct() / Working with Streams
- peek() / Working with Streams
- anyMatch() / Working with Streams
- allMatch() / Working with Streams
- noneMatch() / Working with Streams
- operator overloading / Operator overloading
- operators
- binary operators / Binary operators
- invoke operator / Invoke
- indexed access / Indexed access
- unary operators / Unary operators
- optics / Optics
- Option
- used, for managing null / Option
- override / Inheritance
P
- parameters
- about / Parameters
- vararg / vararg
- lambda / Lambda
- named parameters / Named parameters
- default parameters / Default parameters
- partial application
- about / Partial application
- versus currying / Differences between the currying and partial application
- partial function / Partial functions
- pipe function / Pipes
- primitive streams
- about / Primitive streams
- example / Primitive streams
- principles, Reactive Manifesto
- responsive / The Reactive Manifesto
- resilient / The Reactive Manifesto
- elastic / The Reactive Manifesto
- message-driven / The Reactive Manifesto
- promise
- about / Promises with Kovenant
- with Kovenant / Promises with Kovenant
- properties / Properties
- property delegation
- about / Property delegation (standard delegates)
- Delegates.notNull function / The Delegates.notNull function and lateinit
- lateinit / The Delegates.notNull function and lateinit
- lazy function / The lazy function
- Pull mechanism
- versus RxJava Push mechanism / Comparing the Pull mechanism with the RxJava Push mechanism
- pure functions
- about / Pure functions, Pure functions and side effects, Pure functions
- side effects / Side effects
R
- RandomUser API service
- reference / Using coroutines in real life
- Reactive Manifesto
- reference / The Reactive Manifesto
- principles / The Reactive Manifesto
- reactive programming / Functional reactive programming
- reactive programs / Functional reactive programming
- recursion / Recursion and corecursion
- recursive functions / Recursive functions
- referential immutability / Immutable reference (referential immutability)
- referential transparency / Referential transparency
- resource consumption
- versus code complexity / Coroutines
- return statement / Functions in Kotlin
- RxJava Push mechanism
- versus Pull mechanism / Comparing the Pull mechanism with the RxJava Push mechanism
- RxKotlin
- about / Getting started with RxKotlin
- downloading / Downloading and setting up RxKotlin
- setting up / Downloading and setting up RxKotlin
S
- safe calls / Safe calls
- Scala / Functors
- SDKMAN
- installing / Installing SDKMAN
- Kotlin, installing through / Installing Kotlin through SDKMAN
- Gradle, installing through / Install Gradle through SDKMAN
- single expression functions / Single-expression functions
- singleton / Objects
- specialisation / Inheritance
- State
- used, for managing application state / State
- corecursion / Corecursion with State
- Stream.collect() method / Collector and Stream.collect – collecting Streams
- Stream API
- operations/functional interfaces / Working with Streams
- Stream Builder interface / Stream Builder
- Stream factory
- methods / Stream factory methods
- Streams
- about / Introduction to Streams
- versus Collections / Collections versus Streams
- versus Observables / Collections versus Streams
- working with / Working with Streams
- primitive streams / Primitive streams
- creating, by passing elements / Creating a Stream by passing elements – Stream.of()
- generating / Generating Streams – Stream.generate()
- collecting / Collector and Stream.collect – collecting Streams
- joining, of strings / Joining Stream of strings – Collectors.joining()
- elements, grouping of / Grouping elements of Stream – Collectors.groupingBy()
- structural typing / Functors
- Subscriber operator
- for Observer interface / Subscriber – the Observer interface
- subscribing / Subscribing and disposing
T
- take functions / The take functions
- thread safe structures / Thread safe structures
- TornadoFX
- reference / Type-safe builders
- total function / Partial functions
- Try
- used, for managing errors / Try
- type-safe builders / Type-safe builders
- type alias / Type alias
- type system
- about / Kotlin's type system
- Any type / The Any type
- common types / Minimum common types
- Unit type / The Unit type
- Nothing type / The Nothing type
U
- unary operators / Unary operators
- Unit type / The Unit type
V
- var
- versus val / The difference between var and val
- vararg parameter / vararg
- veto
- reference / The power of veto – Delegates.vetoable
Z
- zip function / The zip function