`.
10 |
11 | If you want to use the provided tests these methods must be called as they are listed and must be inside the `functional.abstractions.applicative` package.
12 |
13 | ## Example
14 |
15 | ```kotlin
16 | data class Class(val a: String, val b: Int)
17 |
18 | ::Class.curried() map
19 | Try { "hello" } ap
20 | Try { 3 } // Success(Class("hello", 3))
21 |
22 | ::Class.curried() map
23 | Try { "hello" } ap
24 | Try { "hi".toInt() } // Failure(NumberFormatException)
25 | ```
26 |
27 | ## Solution
28 |
29 | Reveal
30 |
31 | ---
32 | ```kotlin
33 | fun Try.apply(
34 | tryAB: Try<(A) -> B>): Try =
35 | flatMap { a -> tryAB.map { it(a) } }
36 |
37 | infix fun ((A) -> B).map(aTry: Try): Try = aTry.map(this)
38 |
39 | infix fun Try<(A) -> B>.ap(aTry: Try): Try = aTry.apply(this)
40 | ```
41 |
42 |
Reveal
30 |
31 | ---
32 | ```kotlin
33 | fun performOperationCPS(
34 | check: () -> Boolean,
35 | onSuccess: (Int) -> Unit,
36 | onError: (FailureException) -> Unit) {
37 |
38 | if (check()) onSuccess(42)
39 | else onError(FailureException("Error"))
40 | }
41 | ```
42 |
43 |
Reveal
34 |
35 | ---
36 | ```kotlin
37 | fun getUrlOfLargestBoxArt(list: List): String = list.flatMap {
38 | it.boxArts
39 | }.biggestBoxArt().url
40 |
41 | private fun List.biggestBoxArt(): BoxArt = reduce { acc, boxArt ->
42 | if (acc.area > boxArt.area) acc
43 | else boxArt
44 | }
45 |
46 | private val BoxArt.area: Int
47 | get() = height * width
48 | ```
49 |
50 |
Reveal
39 |
40 | ---
41 | ```kotlin
42 | fun canReach(n: Int, add: Int, multiply: Int): Boolean = if (n <= 1) {
43 | n == 1
44 | } else {
45 | if (n % multiply == 0 && multiply > 1) {
46 | canReach(n / multiply, add, multiply) ||
47 | canReach(n - add, add, multiply)
48 | } else {
49 | canReach(n - add, add, multiply)
50 | }
51 | }
52 | ```
53 |
54 |
2 |
3 |
Reveal
48 |
49 | ---
50 | ```kotlin
51 | tailrec fun fibonacci(n: Int, a: Int = 1, b: Int = 1): Int =
52 | if (n > 0) fibonacci(n - 1, b, a + b) else a
53 | ```
54 |
55 |
Reveal
30 |
31 | ---
32 | ```kotlin
33 | val List.split: Split?
34 | get() = takeIf { count() > 0 }
35 | ?.let { Split(this.first(), subList(1, count())) }
36 |
37 | data class Split(val head: T, val tail: List)
38 |
39 | tailrec fun List.fold(accumulator: B, operation: (B, A) -> B): B {
40 | val (head, tail) = split ?: return accumulator
41 | return tail.fold(operation(accumulator, head), operation)
42 | }
43 |
44 | fun List.reduceKt(operation: (acc: A, A) -> A): A = split?.let {
45 | (head, tail) -> tail.fold(head, operation)
46 | } ?: throw UnsupportedOperationException("value")
47 | ```
48 |
49 |
Reveal
52 |
53 | ---
54 | ```kotlin
55 | fun getAllMoviesInformation(list: List): List> =
56 | list.flatMap {
57 | it.movies
58 | }.map {
59 | it.run {
60 | mapOf("id" to id, "title" to title, "boxArt" to boxArts.boxArt150())
61 | }
62 | }
63 |
64 | private fun List.boxArt150() = firstOrNull { it.width == 150 }
65 | ```
66 |
67 |
2 | 
3 |
4 |
5 | # Functional Kotlin Katas
6 |
7 | ## List of katas
8 |
9 | ### 1 - Recursion
10 |
11 | #### - [Adding & Multiplying](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/recursion/adding/multiplying)
12 |
13 | #### - [Reduce](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/recursion/reduce)
14 |
15 | #### - [Fibonacci](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/recursion/fibonacci)
16 |
17 | ### 2 - Functions
18 |
19 | #### - [Currying](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/functions/currying)
20 |
21 | #### - [Partial Application](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/functions/partial)
22 |
23 | #### - [CPS](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/functions/cps)
24 |
25 | ### 3 - Functional Transforms
26 |
27 | #### - [Map](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/functional/transforms/map)
28 |
29 | #### - [Filter & Map](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/functional/transforms/filtermap)
30 |
31 | #### - [FlatMap (Simple)](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/functional/transforms/flatMap/simple)
32 |
33 | #### - [FlatMap (Advanced)](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/functional/transforms/flatMap/advanced)
34 |
35 | #### - [Reduce](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/functional/transforms/reduce)
36 |
37 | #### - [MapReduce](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/functional/transforms/mapreduce)
38 |
39 | #### - [Zip](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/functional/transforms/zip)
40 |
41 | ### 4 - Functor
42 |
43 | #### - [Creating the Try Functor](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/functional/abstractions/functor)
44 |
45 | ### 5 - Monoid
46 |
47 | #### - [Adding Monoid to Try](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/functional/abstractions/monoid)
48 |
49 | ### 6 - Monad
50 |
51 | #### - [Adding Monad to Try](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/functional/abstractions/monad)
52 |
53 | ### 7 - Applicative
54 |
55 | #### - [Adding Applicative to Try](https://github.com/FunctionalKotlin/katas/tree/master/src/main/java/functional/abstractions/applicative)
56 |
57 | # How to test
58 |
59 | To test the different katas you can run the [unit tests provided](https://github.com/FunctionalKotlin/katas/blob/master/src/test/java/Tests.kt) inside the `test` folder.
60 |
61 | ---
62 |
63 | Copyright © [FunctionalHub.com](http://functionalhub.com) 2018. All rights reserved.
--------------------------------------------------------------------------------
/src/main/java/functional/abstractions/functor/README.md:
--------------------------------------------------------------------------------
1 | # Summary
2 |
3 | In functional programming we can use lots of different types of error handling and reporting, which allows us to choose the best strategy for out situation.
4 |
5 | - In one hand, we can use `Option` to model the absence of a value (like Kotlin's nullable)
6 | - Or, for example, `Either` (same as course's `Result`) if we want to model our result as a type either successful or failure.
7 | - On the other hand, we have `Try`, which represents an operation that can derive in a result (if it has been a success) or in an exception if something has failed.
8 |
9 | Taking this into account we can the infer that there are only two possible implementation for `Try`, a `Success` `Try` and a `Failure` `Try`.
10 |
11 | If we know that an operation could result in a failure, for example, because it is code from a library over which we have no control, or better yet, some method from the language itself. We can use Try as a substitute for the well-known try-catch, allowing us to rise to all its goodness.
12 |
13 | # Task
14 |
15 | Your task is to implement the `Try` type as a functor.
16 |
17 | For that, you need to create it as a sealed class and implement two children: `Success` and `Failure`.
18 |
19 | Also you need to be able to create `Try` instances out of the result of a lambda.
20 |
21 | Then you will need to create the following methods for it:
22 |
23 | - `filter`: It receives a predicate and returns a `Try` of the same type if the value contained matches the predicate.
24 |
25 | - `fold`: Receives a function for handling both cases of the `Try`.
26 |
27 | - `get`: Returns the value inside the `Try` or throws its error
28 |
29 | - `isFailure`: Returns true if the `Try` is a `Failure`.
30 |
31 | - `isSuccess`: Returns true if the `Try` is a `Success`.
32 |
33 | And, of course, you must implement the `map` function that will add a functor instance to this type.
34 |
35 | If you want to use the provided tests all this methods must be called as they are listed here and must be inside the `functional.abstractions.functor` package.
36 |
37 | ## Example
38 |
39 | ```kotlin
40 | Try { "Test".toInt() }
41 | .filter { it > 5 }
42 | .map { it + 2 }
43 | .fold({
44 | exception -> "Error value"
45 | }, {
46 | value -> "The value is $value"
47 | }) // Error value
48 |
49 | Try { "4".toInt() }
50 | .filter { it > 5 }
51 | .map { it + 2 } // PredicateException("Predicate does not hold for 4")
52 |
53 | Try { "6".toInt() }
54 | .filter { it > 5 }
55 | .map { it + 2 } // Try.Success(8)
56 | ```
57 |
58 | ## Solution
59 |
60 | Reveal
61 |
62 | ---
63 | ```kotlin
64 | data class PredicateException(override val message: String) : Exception(message)
65 |
66 | typealias Failure = Try.Failure
67 | typealias Success = Try.Success
68 |
69 | sealed class Try {
70 |
71 | companion object {
72 | operator fun invoke(f: () -> A): Try =
73 | try {
74 | Success(f())
75 | } catch (t: Throwable) {
76 | Failure(t)
77 | }
78 | }
79 |
80 | data class Success(val value: A): Try()
81 | data class Failure(val exception: Throwable): Try()
82 |
83 | }
84 |
85 | fun Try.filter(predicate: (A) -> Boolean): Try =
86 | fold({it -> Failure(it) }, {if (predicate(it)) Success(it)
87 | else Failure(PredicateException("Predicate does not hold for $it"))
88 | })
89 |
90 | fun Try.fold(
91 | transformFailure: (Throwable) -> B, transformSuccess: (A) -> B): B =
92 | when(this) {
93 | is Failure -> transformFailure(exception)
94 | is Success -> try {
95 | transformSuccess(value)
96 | } catch (t: Throwable) {
97 | transformFailure(t)
98 | }
99 | }
100 |
101 | fun Try.get(): A = fold({ throw it }, { it })
102 |
103 | fun Try.isFailure(): Boolean = this is Failure
104 |
105 | fun Try.isSuccess(): Boolean = this is Success
106 |
107 | fun Try.map(transform: (A) -> B): Try =
108 | fold({ Failure(it) }, { Success(transform(it)) })
109 | ```
110 |
111 |