Pure kotlin

PURE KOTLIN
PURE KOTLIN
PURE KOTLIN
Kod/linki:
Kod/linki:
Kod/linki:

AGENDA
AGENDA
AGENDA
Propaganda

AGENDA
AGENDA
AGENDA
Propaganda
Propaganda

AGENDA
AGENDA
AGENDA
Propaganda
Propaganda
The road to purity

AGENDA
AGENDA
AGENDA
Propaganda
Propaganda
The road to purity
Frameworks

AGENDA
AGENDA
AGENDA
Propaganda
Propaganda
The road to purity
Frameworks
Rules

AGENDA
AGENDA
AGENDA
Propaganda
Propaganda
The road to purity
Frameworks
Rules
Propaganda

AGENDA
AGENDA
AGENDA
Propaganda
Propaganda
The road to purity
Frameworks
Rules
Propaganda
Questions, answers, examples,
demos, disasters

PART 1
PART 1
PART 1
FP
FP
FP
FUNCTIONAL PROPAGANDA

PART 1
PART 1
PART 1
FP
FP
FP
FUNCTIONAL PROPAGANDA
also known as
also known as
also known as Functional Programming
Functional Programming
Functional Programming

FP PROMISES
less errors
less code

FP PROMISES
less errors
less code
less tests

FP PROMISES
less errors
less code
less tests
LESS != Nil
LESS != Nil
LESS != Nil

Two hours after deployment

1999 I switched from C++ to Java
Life is too short for malloc

2016 - slowly leaving Java away
I am too old to mutate

What is functional programming?
Programming with functions:
deterministic
total
pure

deterministic
total
pure
Ok, I have no idea. Just copied this de nition
from John De Goes ;-)

DETERMINISTIC
depend on arguments only
always yield same results for the same
arguments
fun hello() = "Hello Jug"
fun fact(n:Int) = if (n<=1) 1 else n*fact(n-1)
fun radom() = Math.random()*0.7

TOTAL:
Yields result/ nishes for all possible arguments
fun negate(a:Int):Int = -a
fun radomize(v:String) = "Radom znowu $v"
fun parseInt(t:String):Int = /* whatever */

PURE:
Leaves no traces. The only (practical) way to
detect the function was called is by reading a
result.
result.
result.
fun add(a:Int, b:Int) = a+b
[CODE A]
val x = add(6,3) [OR] val x = 9
[CODE B]

fun add(a:Int, b:Int) = a*b //happy debugging
fun add2(a:Int, b:Int) = run {
Thread.sleep(a*1000)
Thread.sleep(b*1000)
return a+b
}
fun add3(a:Int, b:Int) = (a+b).also {
log("was adding something in Kielce")
}

Killer feature of functional programming

COMPOSABILITY
COMPOSABILITY
COMPOSABILITY

PART 2
PART 2
PART 2
KOTLIN PROPAGANDA
KOTLIN PROPAGANDA
KOTLIN PROPAGANDA

Kotlin killer feature?

No semicolon
No semicolon
No semicolon

Data class
Data class
Data class
kotlin
kotlin
kotlin
data class Person(
val name:String,
val age:Int,
val drinking:Boolean = true
)

public final class Person {
@NotNull
private final String name;
private final int age;
private final boolean drinking;
@NotNull
public final String getName() {
return this.name;
}
public final int getAge() {
return this.age;
}
public final boolean getDrinking() {
return this.drinking;
}
public Person(@NotNull String name, int age, boolean drinking) {
Intrinsics.checkNotNullParameter(name, "name");
this name = name;

@NotNull
@NotNull
return this.name;
}
return this.age;
}
}
this name = name;

@NotNull
@NotNull
return this.name;
}
return this.age;
}
}
this name = name;
equals and hashCode
equals and hashCode
equals and hashCode

public int hashCode() {
String var10000 = this.name;
int var1 = ((var10000 != null ? var10000.hashCode() : 0) * 31
return var1 + (drinking ? 1 : 0);
}
public boolean equals(@Nullable Object var1) {
if (this != var1) {
if (var1 instanceof Person) {
Person var2 = (Person) var1;
if (Intrinsics.areEqual(this.name, var2.name)
&& this.age == var2.age
&& this.drinking == var2.drinking) {
return true;
}
}
return false;
} else {
return true;
}
}

int var1 = ((var10000 != null ? var10000.hashCode() : 0) * 31
}
if (this != var1) {
if (Intrinsics.areEqual(this.name, var2.name)
&& this.age == var2.age
&& this.drinking == var2.drinking) {
return true;
}
}
return false;
} else {
return true;
}
}
@NotNull
public String toString() {

Back to kotlin
Back to kotlin
Back to kotlin

fun main() = run {
val p = Person("irek", 27, true)
//
}

fun main() = run {
val p1 = p.copy(name = "Irek")
println(p) //Person(name=irek, age=27, drinking=true)
println(p1) //Person(name=Irek, age=27, drinking=true)
}

fun main() = run {
val p1 = p.copy(name = "Irek")
val p2 = p1.copy(age = 28)
val p3 = p2.copy(drinking = false)
val p4 = p3.copy(age = 29, drinking = true)
val p5 = p4.copy(name = "Zdzich", age = p4.age+1, drinking = fals
println(p5)
}
//Person(name=Zdzich, age=30, drinking=false)

@NotNull
@NotNull
return this.name;
}
return this.age;
}
}
this.name = name;
this.age = age;
this.drinking = drinking;
}
public Person(@NotNull String name, int age) {
this(name, age, true);
}
int var1 = ((var10000 != null ? var10000.hashCode() : 0) * 31 + this.age) * 31;
}
if (this != var1) {
if (Intrinsics.areEqual(this.name, var2.name) && this.age == var2.age && this.drinking == var2.drinking) {
return true;
}
}

@NotNull
@NotNull
return this.name;
}
return this.age;
}
}
this.name = name;
this.age = age;
}
}
}
if (this != var1) {
return true;
}
}
return false;
} else {
return true;
}
}
@NotNull
return "Person(name=" + this.name + ", age=" + this.age + ", drinking=" + this.drinking + ")";
}
@NotNull
public final Person copy(@NotNull String name, int age, boolean drinking) {
return new Person(name, age, drinking);
}
@NotNull
public final Person copy(@NotNull String name) {
return new Person(name, this age, this drinking);

@NotNull
@NotNull
return this.name;
}
return this.age;
}
}
this.name = name;
this.age = age;
}
}
}
if (this != var1) {
return true;
}
}
return false;
} else {
return true;
}
}
@NotNull
}
@NotNull
}
@NotNull
return new Person(name, this age, this drinking);
almost
almost
almost

@NotNull
@NotNull
return this.name;
}
return this.age;
}
}
this.name = name;
this.age = age;
}
}
}
if (this != var1) {
return true;
}
}
return false;
} else {
return true;
}
}
@NotNull
}
@NotNull
}
@NotNull
return new Person(name, this.age, this.drinking);
}
@NotNull
public final Person copy(int age) {
return new Person(this.name, age, this.drinking);
}
@NotNull
public final Person copy(boolean drinking) {
return new Person(this.name, this.age, drinking);
}
@NotNull
public final Person copy(@NotNull String name, int age) {
return new Person(name, age, this.drinking);
}
@NotNull
public final Person copy(@NotNull String name, boolean drinking) {
return new Person(name, this.age, drinking);
}
@NotNull
public final Person copy(int age, boolean drinking) {
return new Person(this.name, age, drinking);
}
}

@NotNull
@NotNull
return this.name;
}
return this.age;
}
}
this.name = name;
this.age = age;
}
}
}
if (this != var1) {
return true;
}
}
return false;
} else {
return true;
}
}
@NotNull
}
@NotNull
}
@NotNull
return new Person(name, this.age, this.drinking);
}
@NotNull
public final Person copy(int age) {
return new Person(this.name, age, this.drinking);
}
@NotNull
public final Person copy(boolean drinking) {
return new Person(this.name, this.age, drinking);
}
@NotNull
public final Person copy(@NotNull String name, int age) {
return new Person(name, age, this.drinking);
}
@NotNull
public final Person copy(@NotNull String name, boolean drinking) {
return new Person(name, this.age, drinking);
}
@NotNull
public final Person copy(int age, boolean drinking) {
return new Person(this.name, age, drinking);
}
}
30 semicolons included

data class Person(val name:String, val age:Int, val drinking:Boolean = true)

data class Person(
val name:String,
val age:Int,
)

data class Person(
val names:List<String>,
val lastName:String,
val birthDate:LocalDate,
val email:Email,
val address:Address,
val family:List<Person>,
)

Unfortunately,
Unfortunately,
Unfortunately, copy
copy
copy is not yet included (as of
is not yet included (as of
is not yet included (as of
java 16)
java 16)
java 16) in
in
in java records
java records
java records

data class
data class
data class

data class
data class
data class
simple to use immutable record

IMMUTABILITY
IMMUTABILITY
IMMUTABILITY
First step on the road to safety (and stress free
weekends)
weekends)
weekends)

IMMUTABILITY
IMMUTABILITY
IMMUTABILITY
weekends)
weekends)
weekends)
immutable records, objects

IMMUTABILITY
IMMUTABILITY
IMMUTABILITY
weekends)
weekends)
weekends)
immutable records, objects
immutable data structures

vavr list
vavr list
vavr list
val list1 = list(1, 2, 3)
val list2 = list1.prepend(0)
println(list1)
println(list2)
//List(1, 2, 3)
//List(0, 1, 2, 3)

kotlin immutable (default list)
val list1 = listOf(1, 2, 3)
val list2 = listOf(0)+ list1 // not efficient
println(list1)
println(list2)
//[1, 2, 3]
//[0, 1, 2, 3]

val list1 = listOf(1, 2, 3)
val list2 = listOf(0)+ list1
(list1 as MutableList)[1] = -1
println(list1)
println(list2)
//[1, -1, 3]
//[0, 1, 2, 3]

java.util.ArrayList
java.util.ArrayList
java.util.ArrayList a total disaster
a total disaster
a total disaster
val list1 = ArrayList(listOf(1,2,3))
for (el in list1 ) {
list1.add(list1.size)
}
println(list1)

Not all lists are born equal
io.vavr.collection.List
io.vavr.collection.List
io.vavr.collection.List >
>
>
kotlin.ImmutableList
kotlin.ImmutableList
kotlin.ImmutableList >
>
> java.util.List
java.util.List
java.util.List

TYPE INFERENCE
TYPE INFERENCE
TYPE INFERENCE
A small step for a man, but an average one for
a dwarf
a dwarf
a dwarf

fun main() {
val x = "Hello Kielce JUG"
}

class A(val fieldAndConstructorArf:B, onlyArg:String) {
val fieldInitializedInClass = onlyArg+"_suffix"
fun a(arg:Int):String {// :String not needed
val variable = "$arg and $fieldInitializedInClass"
val other:String = variable //:String not needed
return other
}
}

class A(val fieldAndConstructorArf:B, onlyArg:String) {
val fieldInitializedInClass = onlyArg+"_suffix"
fun a(arg:Int):String {// :String not needed
val variable = "$arg and $fieldInitializedInClass"
val other:String = variable //:String not needed
return other
}
}
one rule (about val)
one rule (about val)
one rule (about val) ts everywhere
ts everywhere
ts everywhere

Type inference means type safety !!!

any doubts?
any doubts?
any doubts?

Which password policy is safer?

at least 12 characters

must include upper, lower case, digit and
special character

special character
must be changed weekly

special character
must be not like recent 20 passwords

special character
must be not like recent 20 passwords
or
or
or

val x:HashMap<Security.Id,List<Either<Group,User>>> = ...

typealias SecurityRegistry = HashMap<Security.Id,List<Either<G
val x:SecurityRegistry = ...

NEXT STEP
NEXT STEP
NEXT STEP
Expressions
Expressions
Expressions

Esspressions
Esspressions
Esspressions

Kill statements
Kill statements
Kill statements
fun addWithStatements(a:Int, b:Int):Int {
return a + b
}
fun addAsExpression(a:Int, b:Int) = a + b

Kill statements
Kill statements
Kill statements
fun addWithStatements(a:Int, b:Int):Int {
return a + b
}
fun addAsExpression(a:Int, b:Int) = a + b
return
return
return is younger brother of
is younger brother of
is younger brother of GOTO
GOTO
GOTO

Why statements are cool? A long example.
sealed class Order(val sum: Int)
class Created(s: Int) : Order(s)
class Paid(s: Int) : Order(s)
class Delivered(s: Int) : Order(s)

val orders = list(
Created(120),
Paid(20),
Delivered(30),
Paid(40)
)

val orders = list(
Created(120),
Paid(20),
Delivered(30),
Paid(40)
)
fun impureSum(orders: Seq<Order>): Int {
var sum = 0
for (order in orders) {
when (order) {
is Paid -> sum = sum + order.sum
is Delivered -> sum = sum + order.sum
}
}
return sum
}
fun main() {
println(impureSum(orders)) //90
}

fun pureSum(orders: Seq<Order>): Int =
orders.foldLeft(0, { accumulator, order ->
when (order) {
is Paid -> accumulator + order.sum
is Delivered -> accumulator + order.sum
is Created -> accumulator
}
})
fun main() =
println(pureSum(orders)) //90

orders.foldLeft(0) { accumulator, order ->
when (order) {
}
}
fun main() =

when (order) {
}
}
fun main() =
fold - don't loop
fold - don't loop
fold - don't loop

class Cancelled(s:Int) : Order(s)
class Archived(s:Int) :Order(s)
val orders = list(
Created(120),
Paid(20),
Delivered(30),
Paid(40),
Cancelled(20),
Archived(10)
)

fun impureSum(orders: Seq<Order>): Int {
var sum = 0
for (order in orders) {
when (order) {
is Paid -> sum = sum + order.sum
is Delivered -> sum = sum + order.sum
}
}
return sum //90 - wrong
}

fun impureSum(orders: Seq<Order>): Int =
when (order) {
// Error: 'when' expression must be exhaustive,
// add necessary 'is Cancelled', 'is Archived' br
// or 'else' branch instead
}
} //wont compile

fun impureSum(orders: Seq<Order>): Int =
when (order) {
// Error: 'when' expression must be exhaustive,
// add necessary 'is Cancelled', 'is Archived' br
// or 'else' branch instead
}
} //wont compile
Compilation error is your friend

if
if
if ,,
, when
when
when,,
, try
try
try etc. are expressions in kotlin
etc. are expressions in kotlin
etc. are expressions in kotlin
fun (a:Int,b:Int) =
a + if (b<5) a else -a

Even more type safety

sealed class Order(internal val sum: Int) {
open fun income(): Int = sum
fun cancelled() = Cancelled(this)
}
class Created(s: Int) : Order(s) {
override fun income(): Int = 0
fun pay() = Paid(this)
}
class Paid internal constructor(order: Created) : Order(order.sum) {
fun deliver() = Delivered(this)
}
class Delivered internal constructor(order: Paid) : Order(order.sum)
fun archive() = Archived(this)
}
class Cancelled internal constructor(order: Order) : Order(order.sum)
override fun income() = 0
}
class Archived internal constructor(order: Delivered) : Order(order.s
l d li t(

fun perfectDelivery() = run {
val created = Created(25)
val paid = created.pay()
paid.deliver()
}

TOTALITARISM
TOTALITARISM
TOTALITARISM
Sounds like a wrong step. Let's see.

Say no to
Say no to
Say no to expected exceptions
expected exceptions
expected exceptions
fun parse(s:String) : Int = s.toInt()

fun String.asInt(): Either<ParseError, Int> =
if (this != null && this.matches(Regex("-?[0-9]+"))) {
this.toInt().right()
} else {
ParseError.WrongCharacters(this).left()
}

val z = "124".asInt()

Checked exceptions | 4xx =>
Checked exceptions | 4xx =>
Checked exceptions | 4xx => Either
Either
Either
Runtime exceptions | 5xx => Runtime
Exceptions
Exceptions
Exceptions

SIDE EFFECTS
SIDE EFFECTS
SIDE EFFECTS

SIDE EFFECTS
SIDE EFFECTS
SIDE EFFECTS
Functional programming is all about side
e ects
e ects
e ects

fun deliver() = Delivered(this).also {
println("delivered")
}
fun deliverFast() = Delivered(this).also {
println("delivered fast")
}
}

A surprise...
A surprise...
A surprise...
fun doubleDelivery() = run {
paid.deliver()
if (paid.income() > 20) {
paid.deliverFast()
}
}
fun main() = doubleDelivery()
//delivered
//delivered fast

SIDE EFFECTS
SIDE EFFECTS
SIDE EFFECTS
How not to have surprises (that often)

a fail
a fail
a fail
fun sayIt() = println("I said no side effects")

Too lazy to do side e ect
fun sayItLater() = { println("I said no side effects")}

Back to problem
Back to problem
Back to problem
fun crashDelivery() = run {
paid.deliver()
if (paid.income() > 20) {
paid.deliverFast()
}
}

Naleśnik == pancake
class Naleśnik<out A>(private val nadzienie: () -> A) {
fun przepakuj(f: (A) -> B) =
Naleśnik { f(this.nadzienie()) }
fun zawiń(f: (A) -> Naleśnik): Naleśnik =
Naleśnik { f(this.nadzienie()).nadzienie() }
fun zjedz(): A = nadzienie() //use with caution
}

sealed class Order(internal val sum: Int) {
open fun income(): Int = sum
fun cancelled() = Naleśnik { Cancelled(this) }
}
class Created(s: Int) : Order(s) {
override fun income(): Int = 0
fun pay() = Naleśnik { Paid(this) }
}
fun deliver(): Naleśnik<Delivered> = Naleśnik {
Delivered(this).also {
println("delivered")
}
}
fun deliverFast(): Naleśnik<Delivered> = Naleśnik {
Delivered(this).also {
println("delivered fast")
}
}
}

fun crashDelivery():Naleśnik<Delivered> = run {
val delivered = paid.zawiń { it.deliver() }
paid.zawiń { if (it.income()> 20) it.deliverFast() else
}
fun main() {
crashDelivery().zjedz()
//delivered fast
}

Naleśnik - harder to do e ect accidentally

Naleśnik > Burrito
Naleśnik > Burrito
Naleśnik > Burrito

Naleśnik
Naleśnik
Naleśnik == IO (Monad)
== IO (Monad)
== IO (Monad)

IO <A>
IO <A>
IO <A> ~=
~=
~= Mono<A>
Mono<A>
Mono<A>

in
in
in arrow-fx
arrow-fx
arrow-fx
IO<A>
IO<A>
IO<A> ==
==
== suspend () -> A
suspend () -> A
suspend () -> A

FRAMEWORKS - ENTERPRISY
CODE
CODE
CODE

Transaction is a Monad
class Transaction<A>(private val action: (Connection) -> A) {
fun map ( f: (A)->B) = Transaction { conn -> f(action(conn))}
fun flatMap( f: (A)->Transaction) =
Transaction { conn -> f(action(conn)).action(conn) }
fun runTransaction(conn:Connection): Either<Exception, A> = run {
val initialAC = conn.autoCommit
conn.autoCommit = false
try {
val res = action(conn)
conn.commit()
Either.right(res)
} catch (e: Exception) {
conn.rollback()
Either.left(e)
} finally {
conn.autoCommit = initialAC
}
}
}

GENERIC EFFECT
IO<R,E,A>
IO<R,E,A>
IO<R,E,A>
R - environment (dependencies)
E - error (not only exception)
A - result (business)

NEE
mutilated
mutilated
mutilated ZIO <R,E,A>
ZIO <R,E,A>
ZIO <R,E,A> + spring like aspects
+ spring like aspects
+ spring like aspects
description
description
description

Instead of writing:
Instead of writing:
Instead of writing:
class Hasiok {
@Resource
val jdbcConnection: Connection
@Transactional
@Secure
@Cacheable
@Retryable
fun f(p:P) {
//code
}
}

Write:
Write:
Write:
class Hasiok {
fun enterprisyFunction(x:Int) = Nee.pure(
secure + retryable + cache.of(x) + tx
) {jdbcConnection:Connection ->
//code using jdbcConnection
}
//declaration above means security is checked before retri
//and retrial is made before cache which happens before tr
}

HOW DO I PROTECT MY PURITY?

What about discipline?

If
If
If I wanted to be careful with
I wanted to be careful with
I wanted to be careful with every line I write I
every line I write I
every line I write I
would have chosen PHP

KURE-POTLIN
KURE-POTLIN
KURE-POTLIN
https://github.com/nee ect/kure-potlin

Plugin for
Plugin for
Plugin for detekt
detekt
detekt

Plugin for
Plugin for
Plugin for detekt
detekt
detekt
Rule Detects Properties
with defaults
Requires
i
LoopUsage use of for, while active: true
ReturnStatement use of return statement active: true
VariableUsage use of var active: true
ReturnUnit use of function returning Unit, Nothing,
Void
active: true
checkFunctionType:
true
:ballot_box_with_check:
ClassDe nition use of object-oriented class active: false
AbstractClassDe nition use of object-oriented abstract class active: false
ThrowExpression use of throw active: true
MutableCollections use of mutable collections active: true :ballot_box_with_check:
BranchStatement use of if or when as statement :white_check_mark:
MissingElse use of if statement without else
type resolution

PROJECT LINKS
PROJECT LINKS
PROJECT LINKS

example of pure todo list with arrow-fx and
ktor
ktor
ktor
springy e ects for kotlin
example ktor project with Nee ("todo list like")
https://github.com/jarekratajski/just_another_to
https://github.com/nee ect/nee
https://github.com/nee ect/kotlin-stones
https://demo.nee ect.dev

SUMMARY
SUMMARY
SUMMARY
FP is not a silver bullet, but it can help ->
composability.
composability.
composability.
The road is long and has multiple
The road is long and has multiple
The road is long and has multiple milestones
milestones
milestones
Each milestone is a
Each milestone is a
Each milestone is a potential profit
potential profit
potential profit
Kotlin is not Scala - but can be quite pure
Runtime magic vs Compiler magic

Pure kotlin

More Related Content

What's hot (20)

Similar to Pure kotlin (20)

More from Jarek Ratajski (15)

Recently uploaded (20)

Pure kotlin