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
  • about / Lambda
  • reference / 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