Android Functional Validation With Arrow - Milan Kotlin Community Conf

You'll discover some basic notion of functional programming using Arrow with a concrete use case.

Transcript

1. ANDROID FUNCTIONAL VALIDATION WITH ARROW DANIELE CAMPOGIANI @DCAMPOGIANI
2. LEARNING KOTLIN LEARNING ARROW ANDROID DEVELOPER
3. WHY SHOULD I CARE ABOUT FUNCTIONAL PROGRAMMING? Kotlin Android Developer
8. FUNCTIONAL COMPANION TO KOTLIN'S STANDARD LIBRARY ARROW-KT.IO
9. DATA TYPE ▸Option ▸Either ▸Validated
10. OPTION sealed class Option<out A> data class Some<out A>(val value: A) : Option<A>() object None : Option<Nothing>()
11. OPTION - FOLD sealed class Option<out A> { fun <T> fold(ifNone: () -> T, ifSome: (A) -> T): T = when (this) { is Some -> ifSome(value) None -> ifNone() } }
12. OPTION - FOLD val option: Option<String> = Some("Daniele") val message = option.fold( { "Hello Stranger" }, { "Hello $it" }) //Hello Daniele
13. OPTION - MAP sealed class Option<out A> { fun <B> map(f: (A) -> B): Option<B> = when (this) { is Some -> Some(f(value)) None -> None } }
14. OPTION - MAP val map = Some(42).map { it * 2 } //Some(value=84)
15. OPTION - FLATMAP sealed class Option<out A> { fun <B> flatMap(f: (A) -> Option<B>): Option<B> = when (this) { is Some -> f(value) None -> None } }
16. OPTION - FLATMAP fun toInt(input: String): Option<Int> = try { Some(Integer.parseInt(input)) } catch (e: NumberFormatException) { None } val result = Some("42").flatMap { toInt(it) } //Some(value=42)
17. ANDROID ACTIVITY VIEWMODEL Delegates and subscribe React to (Live) Data
18. OPTION - MAIL fun String.optionMail(): Option<String> = when { validMail(this) -> Some(this) else -> None }
19. OPTION - NUMBER fun String.optionPhoneNumber(): Option<String> = when { validNumber(this) -> Some(this) else -> None }
20. DATA data class Data( val mail: String, val phone: String)
21. MERGE OPTION OPTION MAIL OPTION NUMBER OPTION DATA ?
22. APPLICATIVE ▸ A way to put a value in the context: Some(value) ▸ Map ▸ FlatMap ▸ For experienced FP programmers: we are taking a shortcut here, just wait few slides :)
23. OPTION - APPLICATIVE fun validateData(inputMail: String, inputNumber: String): Option<Data> { val mail = inputMail.optionMail() val number = inputNumber.optionPhoneNumber() return Option.applicative().map(mail, number) { Data(it.a, it.b) } }
24. OPTION - VIEWMODEL class OptionViewModel : ViewModel() { private val mutableValidation: MutableLiveData<Option<Data>> = MutableLiveData() val validation: LiveData<Option<Data>> get() = mutableValidation fun validate(mail: String, phoneNumber: String) { val validationResult = validateData(mail, phoneNumber) mutableValidation.value = validationResult } }
25. OPTION - ACTIVITY class OptionActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_input) val viewModel = ViewModelProviders.of(this)[OptionViewModel::class.java] signup_button.setOnClickListener { viewModel.validate(email.text.toString(), number.text.toString()) } viewModel.validation.observe(this, Observer { it?.fold(this::handleNone, this::handleSome) }) } }
26. OPTION - ACTIVITY - HANDLE RESULTS fun handleNone() { val message = getString(R.string.option_wrong) showMessage(message) } fun handleSome(data: Data) { val message = "Mail: ${data.mail} Phone: ${data.phone}" showMessage(message) }
30. EITHER sealed class Either<out A, out B> data class Left<out A>(val value: A) : Either<A, Nothing>() data class Right<out B>(val value: B) : Either<Nothing, B>()
31. EITHER - MAP sealed class Either<out A, out B> { fun <C> map(f: (B) -> C): Either<A, C> = when (this) { is Left -> Left(value) is Right -> Right(f(value)) } }
32. EITHER - MAP val input: Either<Throwable, Int> = Right(42) val result = input.map { it * 2 } //Right(value=84)
33. EITHER - FLATMAP sealed class Either<out A, out B> fun <A, B, C> Either<A, B>.flatMap(f: (B) -> Either<A, C>): Either<A, C> = when (this) { is Left -> Left(value) is Right -> f(value) }
34. EITHER - FLATMAP fun toInt(input: String): Either<NumberFormatException, Int> = try { Right(Integer.parseInt(input)) } catch (e: NumberFormatException) { Left(e) } val result = Right("42").flatMap { toInt(it) } //Right(value=42)
35. EITHER - MAIL fun String.eitherMail(): Either<String, String> = when { validMail(this) -> Right(this) else -> Left("Invalid email") }
36. EITHER - NUMBER fun String.eitherPhoneNumber(): Either<String, String> = when { validNumber(this) -> Right(this) else -> Left("Invalid phone number") }
37. EITHER - APPLICATIVE fun validateData(inputMail: String, inputNumber: String): Either<String, Data> { val mail = inputMail.eitherMail() val number = inputNumber.eitherPhoneNumber() return Either.applicative<String>().map(mail, number) { Data(it.a, it.b) } }
38. EITHER - VIEWMODEL class EitherViewModel : ViewModel() { private val mutableValidation: MutableLiveData<Either<String, Data>> = MutableLiveData() val validation: LiveData<Either<String, Data>> get() = mutableValidation fun validate(mail: String, phoneNumber: String) { mutableValidation.value = validateData(mail, phoneNumber) } }
39. EITHER - ACTIVITY class EitherActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_input) val viewModel = ViewModelProviders.of(this)[EitherViewModel::class.java] signup_button.setOnClickListener { viewModel.validate(email.text.toString(), number.text.toString()) } viewModel.validation.observe(this, Observer { it?.fold(this::handleLeft, this::handleRight) }) } }
40. EITHER - ACTIVITY - HANDLE RESULTS fun handleLeft(error: String) { showMessage(error) } fun handleRight(data: Data) { val message = "Mail: ${data.mail} Phone: ${data.phone}" showMessage(message) }
45. VALIDATED sealed class Validated<out A, out B> data class Invalid<out A>(val value: A) : Validated<A, Nothing>() data class Valid<out B>(val value: B) : Validated<Nothing, B>()
46. VALIDATED - MAP sealed class Validated<out A, out B> { fun <C> map(f: (B) -> C): Validated<A, C> = when (this) { is Invalid -> Invalid(value) is Valid -> Valid(f(value)) } }
47. VALIDATED - MAP val input: Validated<List<String>, Int> = Valid(42) val result = input.map { it * 2 } //Valid(value=84)
48. SEMIGROUP interface Semigroup<A> { fun combine(x: A, y: A): A } object StringSemigroup : Semigroup<String> { fun combine(x: String, y: String) = "$x $y" } class ListSemigroup<T> : Semigroup<List<T>> { fun combine(x: List<T>, y: List<T>) = x + y }
49. VALIDATED - APPLY fun Validated<A, B>.ap( SE: Semigroup<A>, f: Validated<A, (B) -> C>): Validated<A, C> = fold( { e -> f.fold({ Invalid(SE.combine(it, e)) },{ Invalid(e) })}, { a -> f.fold(::Invalid, { Valid(it(a)) }) })
50. APPLICATIVE ▸ A way to put a value in the context: ▸ Map ▸ FlatMap ▸ Apply ▸ FlatMap is more powerful than Apply: if a class has FlatMap, Apply can be written using FlatMap
51. VALIDATION ERROR sealed class ValidationError { object InvalidMail : ValidationError() object InvalidPhoneNumber : ValidationError() }
52. VALIDATED - MAIL fun String.validatedMail(): Validated<Nel<ValidationError>, String> = when { validMail(this) -> Valid(this) else -> Invalid(Nel(ValidationError.InvalidMail)) }
53. VALIDATED - NUMBER private fun String.validatedPhoneNumber(): Validated<Nel<ValidationError>, String> = when { validNumber(this) -> Valid(this) else -> Invalid(Nel(ValidationError.InvalidPhoneNumber)) }
54. VALIDATED - APPLICATIVE fun validateData(inputMail: String, inputNumber: String): Validated<Nel<ValidationError>, Data> { val mail = inputMail.validatedMail() val phoneNumber = inputNumber.validatedPhoneNumber() val SE = Nel.semigroup<ValidationError>() return Validated.applicative(SE).map(mail, phoneNumber) { Data(it.a, it.b) } }
55. VALIDATED - VIEWMODEL class ValidatedNelValidationErrorViewModel : ViewModel() { private val mutableValidation: MutableLiveData<Validated<Nel<ValidationError>, Data>> = MutableLiveData() val validation: LiveData<Validated<Nel<ValidationError>, Data>> get() = mutableValidation fun validate(mail: String, phoneNumber: String) { mutableValidation.value = validateData(mail, phoneNumber) } }
56. VALIDATED - ACTIVITY class ValidatedNelValidationErrorActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_input) val viewModel = ViewModelProviders.of(this)[ValidatedNelValidationErrorViewModel::class.java] signup_button.setOnClickListener { viewModel.validate(email.text.toString(), number.text.toString()) } viewModel.validation.observe(this, Observer { it?.fold(this::handleInvalid, this::handleValid) }) } }
57. VALIDATED - ACTIVITY - HANDLE RESULTS fun handleInvalid(errors: Nel<ValidationError>) = errors.map { getInvalidField(it) }.forEach { it.second.error = it.first } fun getInvalidField(validationError: ValidationError): Pair<String, TextInputLayout> = when (validationError) { ValidationError.InvalidMail -> Pair(getString(R.string.invalid_mail), emailWrapper) ValidationError.InvalidPhoneNumber -> Pair(getString(R.string.invalid_phone_number), numberWrapper) }
62. RECAP ▸ Each data type has his own logic ▸ We can write less code combining existing methods ▸ This is just the beginning :)
63. THANKS https://github.com/DanielaSfregola/data-validation https://github.com/arrow-kt/arrow