Kotlin և ֆունկցիոնալ ծրագրավորում
Kotlin-ը ներկայացնում է իրեն որպես բազմապարադիգմ լեզու, և FP-ն այն պարադիգմներից է, որոնք նա իրենն է համարում։ Այդ պնդումից որքանն է գործնականում պահպանվում։ Հնարավո՞ր է իդիոմատիկ ֆունկցիոնալ Kotlin առանց արտաքին գրադարանների։ Եկեք ստուգենք։
Ֆունկցիոնալ ծրագրավորումը ինձ երեք բան է հիշեցնում՝ անփոփոխելիություն (immutability), մոնադներ և կողմնակի էֆեկտներ։ Անփոփոխելիությունը արժանի է իր լավ համբավին. այն իսկապես հեշտացնում է կոդի մասին դատելը և դարձնում զուգահեռությունն ավելի անվտանգ։ Մոնադնե՞րը։ Հզոր են, բայց վախեցնող։ Իսկ կողմնակի էֆեկտնե՞րը։ Ցանկացած օգտակար ծրագիր ունի դրանք։ Այն կարդում է ֆայլեր, կանչում API-ներ և գրում տվյալների բազաներում։ Իսկական հարցը այն չէ, թե ինչպես ազատվել դրանցից, այլ թե ինչպես դրանք պահել վերահսկողության տակ։
Kotlin-ը ներկայացնում է իրեն որպես բազմապարադիգմ լեզու, և FP-ն այն պարադիգմներից է, որոնք նա իրենն է համարում։ Այդ պնդումից որքանն է գործնականում պահպանվում։ Հնարավո՞ր է իդիոմատիկ ֆունկցիոնալ Kotlin առանց արտաքին գրադարանների։
Ո՞ւմ համար է այս բլոգի գրառումը
Եթե անփոփոխելիությունն ու բարձր կարգի ֆունկցիաները ձեզ արդեն ծանոթ են, կարդացեք։ Ես չեմ անդրադառնալու map-ին և filter-ին։ Եթե հետաքրքրված եք, թե որքանով է Kotlin-ը իսկապես ֆունկցիոնալ, կամ պարզապես հոգնել եք «դա կախված է» պատասխանից, այս գրառումը ձեզ համար է։ Եթե արդեն լավ տիրապետում եք էֆեկտների համակարգերին, այստեղ գրվածի մեծ մասը ձեզ ծանոթ կլինի, թեև casual և pure FP-ի տարանջատումը դեռ կարող է օգտակար լինել։
Ի՞նչն է լեզուն «ֆունկցիոնալ» դարձնում
Նախքան Kotlin-ը գնահատելը պետք է համաձայնվենք չափանիշի շուրջ։ Ֆունկցիոնալ ծրագրավորումը այո-թե-ոչ նշման վանդակ չէ։ Այն ավելի մոտ է սպեկտրի, որի մի ծայրում «երբեմն օգտագործում եմ map» է, իսկ մյուսում՝ «ամեն ինչ IO մոնադ է»։
Այստեղ օգնում է մի հարմար տարբերակում՝ կա casual FP, և կա pure FP։ Casual FP նշանակում է ֆունկցիաները դիտարկել որպես առաջին կարգի քաղաքացիներ (դրանք փոխանցել որպես արգումենտներ և վերադարձնել այլ ֆունկցիաներից), ընդունել անփոփոխելիությունը, օգտագործել բարձր կարգի ֆունկցիաներ, տիրույթը մոդելավորել հանրահաշվական տվյալների տիպերով (algebraic data types) և ընդհանրապես նախընտրել արտահայտությունները հրամանների փոխարեն։ Pure FP-ն մեկ քայլ առաջ է գնում. կողմնակի էֆեկտները հետևվում են տիպերի համակարգով, պարտադրվում է referential transparency-ն, և ամբողջ ծրագիրը, ըստ էության, մաքուր ֆունկցիաների կոմպոզիցիա է։
Ո՞րն է հետաքրքիր եզրակացությունը։ Գործնական օգուտների մեծ մասը գալիս է casual FP տարածք մտնելուց։ Իմպերատիվ կոդից casual FP անցնելը ավելի մեծ թռիչք է, քան casual-ից pure անցնելը։ Դուք ստանում եք ավելի մաքուր կոդ, ավելի քիչ սխալներ և ավելի լավ թեստավորելիություն։ Pure FP-ին անցնելը բերում է մաթեմատիկական երաշխիքներ, բայց բիզնես հավելվածների մեծ մասի համար ROI-ն կասկածելի է։
Casual FP. որտեղ Kotlin-ը արդարացնում է սպասելիքները
Կսկսենք նրանից, թե ինչ է Kotlin-ը բերում casual ֆունկցիոնալ ծրագրավորմանը։ Սա ներառում է հիմունքները, որոնք անհրաժեշտ են թիմերի մեծ մասին՝ անփոփոխելիություն, մաքուր ֆունկցիաներ, բարձր կարգի ֆունկցիաներ և հանրահաշվական տվյալների տիպեր։
Անփոփոխելիություն
Kotlin-ը առանձնացնում է փոփոխվող հավաքածուները անփոփոխներից և խթանում է անփոփոխելիությունը լեզվի նախագծման եղանակով։
val users = listOf(
User("Alice", 28),
User("Bob", 35)
)
listOf()-ը արտադրում է անփոփոխ ցուցակ։ Ստեղծվելուց հետո նրա տարրերը չեն կարող ավելացվել, հեռացվել կամ փոփոխվել։
val updatedUsers = users + User("Charlie", 42)
Տարր ավելացնելը տալիս է նոր ցուցակ և բնօրինակը թողնում անփոփոխ։
data class User(val name: String, val age: Int)
val հատկություններով data class-ը լռելյայն անփոփոխ է։ copy() մեթոդի հետ միասին սա անփոփոխ տիրույթի մոդելավորումը դարձնում է բնական։
Kotlin-ը անփոփոխելիություն ձեզ վրա չի պարտադրում (var-ը և mutableListOf()-ը դեռ հասանելի են), բայց տալիս է գործիքները և ուղղորդում է ճիշտ ուղղությամբ։ Հիշեք, որ val-ը անփոփոխ է դարձնում միայն հղումը, այլ ոչ թե հիմքում ընկած տվյալների կառուցվածքը։ Ստանդարտ գրադարանը լռելյայն օգտագործում է անփոփոխ հավաքածուներ։
Մաքուր ֆունկցիաներ
Մաքուր ֆունկցիաներ կարելի է գրել ցանկացած լեզվով, ներառյալ Kotlin-ը։
fun processOrder(order: Order): Order {
return order.copy(
total = calculateDiscount(order.total, order.discountPercent)
)
}
Data class-երի copy() մեթոդի շնորհիվ «վերադարձնել փոփոխված պատճեն՝ փոփոխելու փոխարեն» օրինաչափությունը գալիս է բնականորեն։ Ի տարբերություն Haskell-ի, Kotlin-ը մաքրությունը չի պարտադրում կոմպիլյացիայի ժամանակ։ Այլ կերպ ասած, կոմպիլյատորում ոչինչ չի խանգարում ֆունկցիայի մեջ կողմնակի էֆեկտներ մտցնել։
Առաջին կարգի և բարձր կարգի ֆունկցիաներ
Kotlin-ում ֆունկցիաները առաջին կարգի քաղաքացիներ են։ Դրանք կարելի է փոխանցել որպես պարամետրեր, վերադարձնել այլ ֆունկցիաներից և պահել փոփոխականներում։
val square: (Int) -> Int = { it * it }
fun applyTwice(f: (Int) -> Int, x: Int): Int {
return f(f(x))
}
val result = applyTwice(square, 3) // 81
Այստեղ բարձր կարգի ֆունկցիան որպես պարամետր ընդունում է մեկ այլ ֆունկցիա։ Այս օրինաչափությունը հնարավոր է դարձնում հզոր աբստրակցիաներ, ինչպիսիք են map-ը, filter-ը և հատուկ կառավարման հոսքերը։ Այն ֆունկցիոնալ ծրագրավորման հիմնաքարերից է, և Kotlin-ը նրբագեղ կերպով աջակցում է այն lambda շարահյուսության և ֆունկցիոնալ տիպերի միջոցով։
Ստանդարտ գրադարանի FP գործողությունները
Kotlin-ի ստանդարտ գրադարանը առաջարկում է հավաքածուների վրա ֆունկցիոնալ գործողությունների ընդարձակ աջակցություն՝
data class Product(val name: String, val price: Double, val inStock: Boolean)
val products = listOf(
Product("Laptop", 999.0, true),
Product("Mouse", 25.0, false),
Product("Keyboard", 75.0, true)
)
val affordableInStock = products
.filter { it.inStock } // (1)
.filter { it.price < 100 } // (2)
.map { it.name.uppercase() } // (3)
.sorted() // (4)
// Result: ["KEYBOARD"]
- Թողնել միայն պահեստում առկա տարրերը
- Զտել ըստ գնի
- Արտապատկերել (map) մեծատառ անուններին
- Դասավորել այբբենական կարգով
Հավաքածուների API-ն ներառում է map, filter, flatMap, fold, reduce, groupBy, partition և շատ ուրիշներ։ Առօրյա ֆունկցիոնալ փոխակերպումների համար դուք սահմանափակված չեք զգա։
Հանրահաշվական տվյալների տիպեր (ADT)
Kotlin-ը շատ լավ աջակցում է ADT-ները sealed դասերի/ինտերֆեյսների և data դասերի միջոցով։
sealed interface PaymentResult {
data class Success(val transactionId: String) : PaymentResult
data class Declined(val reason: String) : PaymentResult
data object NetworkError : PaymentResult
}
Սա գումարային տիպ է (sealed interface), որտեղ արդյունքը ստանում է մի քանի տարբերակներից մեկի տեսք։ Տվյալներ չկրող տարբերակների համար օգտագործեք data object։
fun handlePayment(result: PaymentResult): String = when (result) {
is PaymentResult.Success -> "Payment successful: ${result.transactionId}"
is PaymentResult.Declined -> "Payment declined: ${result.reason}"
is PaymentResult.NetworkError -> "Network error, please retry"
}
Սպառիչ when արտահայտություն. կոմպիլյատորը համոզվում է, որ ամեն դեպք ծածկված է։ Ավելացրեք նոր տարբերակ, և ամեն when արտահայտություն, որը չի մշակում այն, կդադարի կոմպիլյացվել։
Սա գրեթե նույնն է, ինչ գումարային տիպերը այնպիսի լեզուներում, ինչպիսիք են Scala-ն կամ Rust-ը։ Կոմպիլյատորի կողմից սպառիչության ստուգումը հատկապես օգտակար է. երբ նոր տարբերակ է ավելացվում, կոմպիլյատորը ցույց է տալիս յուրաքանչյուր when արտահայտություն, որը պետք է թարմացվի։
Pattern matching (նմուշների համապատասխանեցում)
Sealed տիպերի համար Kotlin-ի when արտահայտությունը առաջարկում է սպառիչ pattern matching՝
sealed interface ApiResponse<out T> {
data class Success<T>(val data: T) : ApiResponse<T>
data class Error(val code: Int, val message: String) : ApiResponse<Nothing>
data object Loading : ApiResponse<Nothing>
}
fun <T> renderResponse(response: ApiResponse<T>): String = when (response) {
is ApiResponse.Success -> "Data: ${response.data}"
is ApiResponse.Error -> "Error ${response.code}: ${response.message}"
ApiResponse.Loading -> "Loading..."
} // Compiler checks exhaustiveness
Օգտագործման դեպքերի մեծ մասի համար սա շատ կարող է. դուք ստանում եք տիպային անվտանգություն և սպառիչության ստուգում, ուստի բացակայող դեպքերը բռնվում են կոմպիլյացիայի ժամանակ։
Tail Call Optimization
Kotlin-ն իսկապես աջակցում է tail call optimization, բայց միայն բացահայտ tailrec անոտացիայի միջոցով և խիստ սահմանափակումներով։
tailrec fun factorial(n: Long, acc: Long = 1): Long =
if (n <= 1) acc
else factorial(n - 1, n * acc)
Դուք պետք է ավելացնեք tailrec անոտացիան։ Ռեկուրսիվ կանչը պետք է լինի tail դիրքում, այսինքն՝ պետք է լինի ֆունկցիայի վերջին գործողությունը։
factorial(10000) // Works without stack overflow
tailrec-ի դեպքում կոմպիլյատորը ռեկուրսիան վերածում է ցիկլի, ուստի խորը ռեկուրսիան չի ստեկի գերբեռնվածություն (stack overflow) առաջացնում։
Սահմանափակումներ.
- Վերաբերում է միայն ուղղակի ռեկուրսիային (փոխադարձ ռեկուրսիան չի աջակցվում)
- Ֆունկցիան պետք է լինի
private,finalկամ լոկալ - Ռեկուրսիվ կանչը պետք է լինի վերջին գործողությունը
Համեմատեք սա Scala-ի հետ, որտեղ TCO-ն ավտոմատ կիրառվում է tail դիրքում գտնվող կանչերի նկատմամբ։ Բացահայտ անոտացիան իրականում թաքնված հնարավորություն է. եթե սխալմամբ գրեք ոչ-tail ռեկուրսիա, կոմպիլյատորը ձեզ անմիջապես կասի՝ այն թողնելու փոխարեն, որ աշխատանքի ժամանակ ձախողվի։
Տիպային անվտանգ nullable-ություն
FP լեզուներին բնորոշ Option/Maybe տիպերի փոխարեն Kotlin-ը հենվում է nullable տիպերի (T?) վրա։
fun findUser(id: String): User? = userRepository.find(id)
Nullable վերադարձվող տիպ. ? վերջածանցը բացակայությունը բացահայտորեն արտահայտում է տիպերի համակարգում։
val username = findUser("123")?.name?.uppercase()
Safe call օպերատորի (?.) շղթաներ. երբ որևէ քայլ տալիս է null, ամբողջ շղթան կարճ միացումով վերադարձնում է null։
val username = findUser("123")?.name?.uppercase() ?: "Unknown"
Elvis օպերատորը (?:) տալիս է լռելյայն արժեք, երբ ձախ կողմը null է։
Այս մոտեցումը աշխատում է և տիպային անվտանգ է, բայց համարժեք չէ Option<T>-ին։ Option-ը ձեզ տալիս է այնպիսի մեթոդներ, ինչպիսիք են map, flatMap, fold, որոնք այն դարձնում են իսկական մոնադ՝
// Kotlin nullable — imperative style
val user: User? = findUser("123")
val department = user?.department?.name ?: "Unknown"
// Option style (not in Kotlin stdlib)
val user: Option<User> = findUser("123")
val department = user
.flatMap { it.department }
.map { it.name }
.getOrElse { "Unknown" }
Շատ գործնական իրավիճակներում Kotlin-ի nullable տիպերը բավարար են, և պարզ դեպքերի համար դրանք, կարելի է ասել, ավելի հեշտ են կարդացվում։ Սակայն երբ ուզում եք ֆունկցիոնալ ոճով շղթայել մի քանի ձախողվող գործողություններ, nullable տիպերը դառնում են անհարմար։ Վերջում գրում եք ներդրված ?.let { } բլոկներ։
Pure FP. ի՞նչն է պակասում
Թվարկենք, թե ինչն է պակասում Kotlin-ին մաքուր ֆունկցիոնալ ծրագրավորման համար. դուք պետք է տեղյակ լինեք այս բացերի մասին՝ նախքան ամբողջովին մաքուր ֆունկցիոնալ մոտեցման անցնելը։
Սահմանափակ pattern matching
when արտահայտությունները լավ են հաղթահարում հիմնական pattern matching-ը, բայց Kotlin-ում չկան guard-եր և destructuring match կետերում՝
// Not possible in Kotlin
when (result) {
is Success(data) if data.isEmpty() -> ... // Guards not supported
is Error(404, _) -> ... // Can't destructure in when
}
Լուծում. Ներդրված պայմանները դրեք ճյուղերի ներսում՝
when (result) {
is ApiResponse.Success -> {
if (result.data.isEmpty()) "Empty data"
else "Data: ${result.data}"
}
is ApiResponse.Error -> {
if (result.code == 404) "Not found"
else "Error: ${result.message}"
}
ApiResponse.Loading -> "Loading..."
}
Այն ավելի բառաշատ է, բայց գործը անում է։ Բացակայող guard-երը նյարդայնացնող են, այլ ոչ թե խոչընդոտ. նույն տրամաբանությունը միշտ կարելի է արտահայտել, պարզապես ավելի խորը ներդրվածությամբ։
Ներկառուցված ֆունկցիաների կոմպոզիցիա չկա
Kotlin-ը չի տրամադրում ֆունկցիաների կոմպոզիցիայի համար ներկառուցված օպերատորներ։ Կոմպոզիցիան պետք է արվի ձեռքով՝
val addOne: (Int) -> Int = { it + 1 }
val double: (Int) -> Int = { it * 2 }
// Manual composition (works but reads right-to-left)
val addThenDouble = { x: Int -> double(addOne(x)) }
// Better: write your own extension
infix fun <A, B, C> ((A) -> B).andThen(g: (B) -> C): (A) -> C = { g(this(it)) }
val composed = addOne andThen double // (1)
composed(5) // 12
Կոմպոզիցիա՝ հատուկ extension ֆունկցիայով
Այնպիսի լեզուներ, ինչպիսին Scala-ն է, տրամադրում են compose և andThen անմիջապես։ Kotlin-ում կամ այդ extension-ները գրում եք ինքներդ (5 տող կոդ), կամ ներմուծում եք գրադարան։ Լուծումը պարզ է, բայց զարմանալի է, որ ստանդարտ գրադարանը դա չի ներառում։
Սխալների համար բնիկ either/result տիպ չկա
Kotlin-ը ունի Result<T> տիպ, բայց այն կառուցվել է հատկապես բացառություններ փաթաթելու համար և չի կարող ներկայացնել կամայական սխալի տիպեր՝
fun divide(a: Int, b: Int): Result<Int> =
if (b == 0) Result.failure(ArithmeticException("Division by zero"))
else Result.success(a / b)
divide(10, 0).getOrElse { -1 }
Խնդիրը. Տիրույթի սխալները չեն կարող նրբագեղ մոդելավորվել՝
sealed interface ValidationError {
data object EmptyEmail : ValidationError
data object InvalidFormat : ValidationError
data class TooLong(val maxLength: Int) : ValidationError
}
// What we want:
fun validateEmail(email: String): Either<ValidationError, Email>
// What Kotlin gives us:
fun validateEmail(email: String): Result<Email> // Can only hold Exception
Առանց Either<E, A>-ի դուք ընտրություն չունեք, քան՝
- Նետել բացառություններ (որը ֆունկցիոնալ չէ)
- Վերադարձնել nullable տիպեր (որը կորցնում է սխալի տեղեկատվությունը)
- Գրել ձեր սեփական Either տիպը (որը նշանակում է boilerplate)
- Հենվել գրադարանի վրա, ինչպիսին Arrow-ն է
Էֆեկտների համակարգ չկա
Kotlin-ում ներկառուցված էֆեկտների համակարգ չկա։ Ֆունկցիոնալ լեզուներում էֆեկտային տիպերը, ինչպիսիք են IO<A>-ն, Option<A>-ն կամ Either<E, A>-ն, փաթաթում են հաշվարկները և արտահայտում դրանց հատկությունները տիպի միջոցով. Option-ը ներկայացնում է առկայություն/բացակայություն, IO-ն՝ գործողություն, որը կարող է ունենալ կողմնակի էֆեկտներ, իսկ Either-ը՝ ձախողում կամ հաջողություն։
// Kotlin: no effect system
fun loadUser(id: String): User = userRepository.find(id)
(String) -> User տիպը ոչինչ չի ասում այն մասին, թե ֆունկցիան իրականում ինչ է անում։ Այն I/O անո՞ւմ է։ Կարո՞ղ է ձախողվել։ Կողմնակի էֆեկտներ առաջացնո՞ւմ է։
Էֆեկտների համակարգերով լեզուները տիպը դարձնում են բացահայտ՝
-- Haskell: IO effect
loadUser :: String -> IO User
// Scala with Cats Effect
def loadUser(id: String): IO[User]
IO-ն ներկայացնում է գործողություն, որը կարող է ունենալ կողմնակի էֆեկտներ։ Արդյունքի փոխարեն ֆունկցիան վերադարձնում է կատարվելիք աշխատանքի նկարագրություն։ Kotlin-ի suspend մոդիֆիկատորը ամենամոտն է էֆեկտի նշիչին, բայց այն պարզապես նշում է coroutine-ների կասեցման կետերը, այլ ոչ թե էֆեկտները ընդհանրապես՝
Higher-kinded տիպեր չկան
Kotlin-ը չի աջակցում higher-kinded տիպեր (HKT), որոնք թույլ են տալիս աբստրակտացնել տիպերի կոնստրուկտորները, ինչպիսիք են List-ը, Option-ը կամ Either-ը։ Առանց HKT-ների հնարավոր չէ ընդհանուր կոդ, որը աշխատում է ցանկացած F[_] տիպի կոնստրուկտորի հետ, ինչը սահմանափակում է, թե որքան հեռու կարելի է գնալ ընդհանուր ֆունկցիոնալ աբստրակցիաներ կառուցելիս։
Scala-ն թույլ է տալիս գրել ֆունկցիաներ, որոնք աշխատում են ցանկացած կոնտեյների տիպի վրա՝
// Generic function that works with any F[_]
def transform[F[_]: Functor, A, B](fa: F[A], f: A => B): F[B] =
fa.map(f)
// Works with List, Option, Either, etc.
transform(List(1, 2, 3), _ * 2) // List(2, 4, 6)
transform(Some(5), _ * 2) // Some(10)
transform(Right(5), _ * 2) // Right(10)
F[ _ ] շարահյուսությունը կարդացվում է որպես «F-ը տիպի կոնստրուկտոր է, որը ընդունում է մեկ տիպի պարամետր»։ Այն թույլ է տալիս կոդը գրել մեկ անգամ և ստիպել աշխատել ցանկացած կոնտեյների նման տիպի հետ։
Kotlin-ը այս աբստրակցիան արտահայտելու որևէ միջոց չի առաջարկում։ Ստիպված կլինեք գրել առանձին իրականացումներ List-ի, nullable տիպերի, Result-ի և այլնի համար։
. Այս պահին Kotlin-ում HKT ավելացնելու պլաններ չկան։
Type class-եր չկան
Kotlin-ի ինտերֆեյսները type class-եր չեն (մեխանիզմ, որը հայտնի է նաև որպես ad-hoc polymorphism)։ Դուք չեք կարող ո՛չ հետընթաց իրականացումներ ավելացնել, ո՛չ էլ սահմանել օրենքներ, որոնց պետք է ենթարկվեն օրինակները՝
// Kotlin interface: must be declared when defining the class
interface Showable {
fun show(): String
}
// Can't make String showable without wrapping it
data class DisplayString(val value: String) : Showable {
override fun show() = value
}
Scala-ն և Haskell-ը թույլ են տալիս type class-ի օրինակ սահմանել ցանկացած առկա տիպի համար՝ առանց դրան դիպչելու՝
trait Showable[A]:
extension (a: A) def show: String
val stringShowable = new Showable[String]:
extension (value: String) def show: String = value
Kotlin-ի extension ֆունկցիաները առաջարկում են նույն առավելություններից մի քանիսը. դրանք լուծվում են ստատիկորեն (կոմպիլյացիայի ժամանակ, հայտարարված տիպի համաձայն)։
Եզրակացություն
Որպես casual FP լեզու՝ Kotlin-ը լավ է դիմանում։ Այն ձեզ սարքավորում է անփոփոխելիությամբ, բարձր կարգի ֆունկցիաներով, հանրահաշվական տվյալների տիպերով և սպառիչ pattern matching-ով։ Առանց որևէ արտաքին կախվածության կարելի է գրել մաքուր, ֆունկցիոնալ կոդ՝ տվյալների փոխակերպման pipeline-ներ, անփոփոխ տիրույթի մոդելներ և մաքուր բիզնես տրամաբանություն։ Թիմերի և նախագծերի մեծամասնության համար դա բավարար է։
Kotlin-ը զիջում է pure FP տարածքում։ Չկա տիպային սխալների մշակում բացի բացառություններից, չկա էֆեկտների հետևում, չկան type class-եր և չկա կոմպիլյատորի կողմից պարտադրվող referential transparency։ Այդ երաշխիքները ստանալու համար ձեզ պետք է Arrow։
Իմ խորհուրդը. մի պայքարեք լեզվի դեմ։ Դիմեք nullable տիպերին, երբ դրանք պարզ են պահում ամեն ինչ, նետեք բացառություններ, երբ այլընտրանքը ավելի վատ կլիներ, և հենվեք sealed դասերի վրա տիրույթի մոդելավորման համար։ Հիմնական բաների համար, ինչպիսին ֆունկցիաների կոմպոզիցիան է, գրեք ձեր սեփական 5 տողանոց extension-ները։ Բայց երբ բռնեք ինքներդ ձեզ հատուկ Either տիպ կառուցելիս, ժամանակն է Arrow ներմուծելու։
Մաս 2-ում կդիտարկենք, թե ինչպես է Arrow-ը փակում այս բացերը և երբ է այդ կախվածությունը ձեր նախագծին ավելացնելը արդարացվում։