Գնահատել նախագիծը
← Բոլոր հրապարակումները

Cats Effect-ի և ZIO-ի համեմատություն

ZIO-ն և Cats Effect-ը՝ Scala-ի երկու հիանալի գրադարաններ, համեմատված կողք կողքի։ Դրանցից յուրաքանչյուրը գործիքներ է առաջարկում ասինխրոն և կոնկուրենտ հավելվածներ գրելու համար։

19 րոպե
ScalaCats EffectZioMonad

Scala-ի համար ասինխրոն և կոնկուրենտ ծրագրավորում, որը տիպային անվտանգ է և կոմպոզիցիոն

Կարգախոսը ZIO-ի կայքում

Մաքուր ասինխրոն runtime Scala-ի համար

Կարգախոսը Cats Effect-ի կայքում

Այս հոդվածի նպատակն է համեմատել Scala-ի երկու հիանալի գրադարան՝ ZIO-ն և Cats Effect-ը։ Դրանցից յուրաքանչյուրը գործիքներ է առաջարկում ասինխրոն և կոնկուրենտ հավելվածներ գրելու համար։

Երկուսն էլ փորձված են «մարտում» և աշխատում են production-ում բազմաթիվ ընկերություններում։ Ավելին՝ երկուսն էլ հիմնված են ֆունկցիոնալ ծրագրավորման պարադիգմայի վրա. դրանք իրականացնում են ֆունկցիոնալ էֆեկտների համակարգ։ Կդիտարկենք գրադարանների հիմքում ընկած փիլիսոփայությունը, դրանց հիմնական հնարավորությունները, ինչը նրանց ընդհանուր է և որտեղ են տարբերվում։ Մանրուքների մեջ չեմ խորանա. այդ գրադարանների բազմաթիվ ասպեկտներ առանձին հոդվածներ կպահանջեին։

Կկենտրոնանամ երկուսի նորագույն տարբերակների վրա՝ ZIO 2.x շարքը և Cats Effect 3.x։

IO monad-ը

ԵՒ՛ Cats Effect-ը, և՛ ZIO-ն հիմնվում են հաշվարկները կասեցնելու համար նախատեսված հատուկ տվյալների տիպի վրա, որը հայտնի է որպես IO monad։ CE-ում այն կոչվում է IO, իսկ ZIO-ում պարզապես ZIO է (թեև օգտագործվում են նաև որոշ մասնագիտացված ալիասներ, ինչպես URIO կամ Task, – այդ մասին՝ ավելի ուշ)։

IO monad-ը թույլ է տալիս կասեցնել հաշվարկներ, որոնք արժեք են արտադրում և կարող են կողմնակի էֆեկտ առաջացնել։ Հիմնական գաղափարն այն է, որ նման գործողությունները կարելի է կոմպոզիցիայի ենթարկել և ձևափոխել ճիշտ այնպես, ինչպես ֆունկցիոնալ ծրագրավորման ցանկացած այլ արժեք։ Կոմպոզիցիայի ենթարկված IO-ներից կառուցված ծրագրերը հետո կարելի է գնահատել, իդեալականորեն՝ հավելվածի մուտքի կետում, որը հայտնի է որպես «end-of-the-world»։ Այդ ծրագրերը արդյունավետ կատարող բաղադրիչը կոչվում է runtime, և այն երկու գրադարանների սրտում է։

Հիմնական հնարավորությունները

Յուրաքանչյուր գրադարան առաջարկում է կոմբինատորների շարք՝ անմաքուր, կողմնակի էֆեկտներով հաշվարկները կասեցնելու և դրանց հետ աշխատելու համար։ Ահա կարճ ակնարկ։

Cats Effect

CE-ում անմաքուր կոդը ֆունկցիոնալ էֆեկտի վերածելու ամենահեշտ ձևը հաշվարկը IO-ով փաթաթելն է՝ apply մեթոդի օգնությամբ։

val io: IO[Int] = IO(StdIn.readInt())

Քանի որ գործողությունը գնահատվում է ծույլ եղանակով (կասեցված), արժեքը կարելի է անվտանգ կերպով վերօգտագործել ծրագրի տարբեր մասերում, և այն ամեն անգամ նույն կերպ կվարվի։
Երբ հաստատ գիտենք, որ մեր կոդը կողմնակի էֆեկտներ չունի և պարզապես արժեք է վերադարձնում, կարող ենք այն IO-ի մեջ փաթաթել IO.pure-ով։

val pureIO: IO[Int] = IO.pure(42)

CE-ն նաև բազմաթիվ կոմբինատորներ է տրամադրում հաճախ օգտագործվող էֆեկտներ ստեղծելու համար, օրինակ՝

  • ընթացիկ ժամանակի ստացում (IO.realTime)
  • ստանդարտ մուտքից տողի ընթերցում (IO.readLine)
  • տողի տպում (IO.printLine)
  • որոշ ժամանակ քնելը (IO.sleep)
  • և շատ այլ բաներ

IO արժեքները մոնադիկ են և տրամադրում են այնպիսի մեթոդներ, ինչպիսիք են map-ը և flatMap-ը, որոնք թույլ են տալիս IO-ները համադրել ավելի մեծ ծրագրերի մեջ.

//> using dep "org.typelevel::cats-effect:3.5.1"
val program: IO[String] = for {
  _ <- IO.println("What is your name?")
  name <- IO.readLine
  _ <- IO.sleep(1.second)
  _ <- IO.println(s"Hello, $name")
} yield name

CE ծրագրի արդյունքի տիպը IO է։ Այն ընդունում է մեկ A տիպային արգումենտ, որը սահմանում է ծրագրի հաջող գնահատման դեպքում արտադրվող արժեքի տիպը։

Հավելվածի մուտքի կետը սահմանելու համար CE-ն առաջարկում է IOApp trait-ը։

//> using dep "org.typelevel::cats-effect:3.5.1"
import cats.effect.{IO, IOApp}

import scala.concurrent.duration.*

object CatsApp extends IOApp.Simple {

 override def run: IO[Unit] =
   for {
     _ <- IO.sleep(2.seconds)
     _ <- IO.println("Hello World")
   } yield ()
}

Սա CE հավելվածը սկսելու խորհուրդ տրվող եղանակն է։ Այն ներառում է CE-ի լռելյայն runtime-ը, որը գնահատում է ծրագիրը։

ZIO

ZIO-ում IO.apply-ի համարժեքը ZIO.attempt-ն է։ Այն վերցնում է կողմնակի էֆեկտներով կոդը և տեղադրում ZIO համատեքստում։ Մաքուր արժեքները նույնպես կարելի է փաթաթել ZIO-ով՝ ZIO.succeed-ի միջոցով։

val t: ZIO[Any, Throwable, Long] =
  ZIO.attempt(System.currentTimeMillis())

ZIO-ն առաջարկում է օպերատորների համանման հավաքածու առօրյա գործողությունների համար։ Օրինակ՝ Console.readLine-ը ստանդարտ մուտքից կարդում է տեքստի տող, Clock.currentTime-ը ստանում է ժամանակը, իսկ ZIO.sleep-ը ծրագիրը դադարեցնում է տրված ժամանակով։ Յուրաքանչյուր օպերատոր վերադարձնում է ZIO օբյեկտ, որը կարելի է համադրել flatMap և map ֆունկցիաներով։

val zio: ZIO[Any, IOException, Int] = for {
  _ <- Console.printLine("Calculating random number:")
  _ <- ZIO.sleep(2.seconds)
  result <- Random.nextInt
} yield result

Ծրագրի կառուցվածքը նման է CE հավելվածին, սակայն աչքի են ընկնում արդյունքի տիպերը։ Մեկ ընդհանուր պարամետրի փոխարեն ZIO տիպն ունի երեքը։ Դրանցից յուրաքանչյուրի իմաստը կուսումնասիրենք հաջորդ պարբերություններում, իսկ առայժմ՝ կարճ ակնարկ։

Վերջին պարամետրը՝ A-ն, նշանակում է նույնը, ինչ CE-ի IO-ի միակ պարամետրը՝ հաջող գնահատման դեպքում վերադարձվող արժեքի տիպը, այսինքն՝ success channel-ը։ Երկրորդ տիպը՝ E-ն, error channel-ն է. այն նշում է այն սխալի տիպը (կամ տիպերը), որով հավելվածը կարող է ձախողվել։ Error channel-ում Nothing-ը ցույց է տալիս, որ ծրագիրը չի ձախողվի (կամ գոնե չի սպասվում, որ կձախողվի)։ Առաջինը՝ R-ը, միջավայրն է. այն թվարկում է ծրագիրը գնահատելու համար անհրաժեշտ բոլոր կախվածությունները։ Այն ծրագիրը, որի միջավայրը Any տիպի է, նկարագրում է առանց կախվածությունների հավելված։

ZIO-ն հարմարության համար սահմանում է մի շարք ալիասներ։ Օրինակ՝ UIO[A]-ն ներկայացնում է էֆեկտ, որն արտադրում է A արժեք, չի կարող ձախողվել որևէ սպասվող սխալով և միջավայրից ոչինչ չի պահանջում։ Ալիասների ամբողջական ցանկը հասանելի է այստեղ։

Ինչպես CE-ն, ZIO-ն էլ տրամադրում է օժանդակ trait՝ նոր հավելված սկսելու համար՝ ZIOApp, որը ներառում է ZIO-ի լռելյայն runtime-ը։

//> using dep "dev.zio::zio:2.0.15"
import zio.*

object ZIOApp extends ZIOApp {

 def run: ZIO[ZIOAppArgs, IOException, Unit] =
   for {
     _ <- ZIO.sleep(2.seconds)
     _ <- Console.printLine("Hello World")
   } yield ()
}

Արդյունքի տիպի ստորագրությունից բացի, երկու գրադարաններն էլ առայժմ նման տեսք և զգացողություն ունեն։ Այժմ անցնենք առաջին մեծ տարբերությանը՝ սխալների մշակմանը։

Սխալների մշակում

Յուրաքանչյուր գրադարան նախագծված է ասինխրոն մշակման շուրջ, որտեղ մեկ հաշվարկը իր կյանքի ընթացքում կարող է աշխատել բազմաթիվ թրեդերի վրա։ Դրա պատճառով մենք չենք կարող պարզապես հենվել լեզվի ստանդարտ մեխանիզմների վրա՝ exception-ներ նետելու և բռնելու համար։ Ահա թե ինչու CE-ն և ZIO-ն առաջարկում են հատուկ մեխանիզմներ սխալներ առաջացնելու, տարածելու և մշակելու համար։

ZIO

ZIO-ն սխալները մշակում է իր յուրահատուկ ձևով՝ տարբերելով սխալների երեք տեսակ.

  • սպասվող սխալներ, որոնք հայտնի են որպես failures
  • չսպասվող սխալներ՝ defects
  • ճակատագրական սխալներ

Սկսենք սպասվող սխալներից։ ZIO-ն ուզում է համոզվել, որ մենք դրանց հետ ճիշտ ենք վարվում։ Այն դա անում է՝ սպասվող սխալի տիպերը տեղադրելով իր երկրորդ տիպային պարամետրում՝ error channel-ում։ Ամեն անգամ, երբ ZIO.fail-ով սխալ ենք առաջացնում, այն ավտոմատ կերպով հայտնվում է տիպի ստորագրության մեջ։

val failedZIO: ZIO[Any, String, Nothing] = ZIO.fail("Ups :(")

Այս ZIO-ն մեկ այլ ZIO-ի հետ համադրելու փորձը, որն ունի տարբեր սխալի տիպ, հանգեցնում է կոմպիլյացիայի սխալի։ Այս կերպ ZIO-ն երաշխավորում է, որ սխալը ինչ-որ կերպ մշակվել է։ Այն լուծելու համար պետք է կամ ձևափոխենք սխալները հասանելի բազմաթիվ օպերատորներից որևէ մեկով, կամ դրանք հեռացնենք ստորագրությունից՝ սխալը մշակելով։

def app: ZIO[Any, Throwable, Unit] = for {
  name <- Console.readLine("What's your name?")
  _ <- failedZIO //this will prevent the code from compiling
  _ <- Console.printLine(s"Hello, $name!")
  } yield ()

ZIO-ն ունի սխալների կառավարման հարուստ, ճկուն API։ Կարող ենք, օրինակ, միայն որոշ սխալներ մշակել catchSome-ով, կամ բոլոր սխալները միանգամից՝ catchAll-ով։

failedZIO.catchAll(error => Console.printLine(s"Error: $error"))

ZIO-ն նաև փոխգործակցում է այն API-ների հետ, որոնք սխալները կառավարում են Either-ի միջոցով։ ZIO.either-ի օգնությամբ կարող ենք սխալը ZIO-ի error channel-ից տեղափոխել success channel-ի Either-ի մեջ (ZIO[R, E, A] => ZIO[R, Nothing, Either[E, A]])։ Հակառակ ուղղությամբ՝ ZIO[R, Nothing, Either[E, A]] => ZIO[R, E, A], կա ZIO.absolve-ը։

Իսկ ի՞նչ է defect-ների դեպքում։ Դրանք ներկայացնում են հավելվածի բացառիկ, թերի վարքը, որը չպետք է առաջանա նորմալ ընթացքում, և մենք չպետք է դրանք բռնենք։ ZIO-ի ուղեցույցները փոխարենը խորհուրդ են տալիս Let it crash մոտեցումը։ Defect-ը առաջացվում է ZIO.die-ով։

val crashedZIO = ZIO.die(new IllegalStateException("SAD"))

Մինչդեռ failure-ները կարող են լինել ցանկացած տիպի, հաղորդվող defect-ները պետք է լինեն Throwable-ի ենթատիպ։ Սովորաբար դա պետք չէ, բայց defect-ները դեռ կարելի է բռնել այնպիսի օպերատորներով, ինչպիսին catchAllDefects-ն է։ Կա նաև orDie-ն, որը սովորական failure-ը (քանի դեռ այն Throwable-ի ենթատիպ է) դարձնում է defect, և resurrect-ը, որը defect-ը վերադարձնում է failure-ի։

Վերջապես, ճակատագրական սխալները ներկայացնում են JVM-ի աղետալի ձախողումներ, օրինակ՝ OOM սխալները։ ZIO-ն դրանք որսալու կամ մշակելու միջոց չի տալիս։

Cats Effect

CE-ի մոտեցումը սխալների մշակմանը ավելի պարզ է։ Տիպավորված error channel-ներ չկան, և մենք կարող ենք առաջացնել միայն Throwable-ի ենթատիպերը։ Այնուհետև կամ դրանք բռնում ենք ներքևում, կամ չմշակված exception-ը կործանում է հավելվածը։ Այս առումով դրանք շատ նման են ZIO-ի defect-ներին։

Սխալները առաջացվում են IO.raiseError-ով։

val failedIO: IO[Nothing] = IO.raiseError(
   new IllegalStateException("NOPE")
)

Դրանք բռնելու համար կարող ենք օգտագործել handleError կամ handleErrorWith։

failedIO.handleErrorWith (
   error => IO.println(s"Error: $error")
)

Ներսում CE-ն հենվում է Cats-ի MonadError-ի վրա՝ սխալի տիպը ֆիքսված Throwable։

Հնարավո՞ր է, սակայն, CE-ում ունենալ տիպավորված սխալներ։ Մենք կարող ենք Either-ը ներդնել IO-ի մեջ, և երկու օգնական մեթոդ օգնում են սխալները տեղափոխել Either-ի և CE error channel-ի միջև։ attempt մեթոդը մեզ տանում է IO[A]-ից IO[Either[Throwable, A]]-ի, իսկ rethrow-ն կատարում է հակառակ ձևափոխությունը։ Զգույշ եղեք. այս մեթոդները անսխալական չեն։ Ոչինչ մեզ չի խանգարում, օրինակ, մի քանի անգամ attempt կանչել և ստանալ խորը ներդրված Either։

val io: IO[Either[Throwable, Either[Throwable, Int]]]
 = IO(1).attempt.attempt //doesn't really make sense

Ներդրված մոնադների ստեկերի (օրինակ՝ Either-ը IO-ի ներսում) հետ աշխատելը կարող է անհարմար դառնալ։ Ահա թե ինչու գոյություն ունի տվյալների տիպերի հատուկ կատեգորիա, որը դա պարզեցնում է՝ monad transformer-ները։ Այդուհանդերձ, monad transformer-ների օգտագործումը այնքան սահուն չէ, որքան ZIO-ի ներկառուցված error channel-ի հետ աշխատելը։

Հավելվածի կառուցվածքը

Անցնենք հաջորդ թեմային՝ ինչպե՞ս պետք է կառուցվեն ֆունկցիոնալ էֆեկտների համակարգերով գրված Scala հավելվածները։ Բիզնես կոդի մասերը կարող են հենվել համակարգի այլ մասերի վրա, որոնք իրականացնում են տրամաբանության տարբեր հատվածներ։ Կարող են լինել նաև ինֆրաստրուկտուրային կախվածություններ (այսպես կոչված հավելվածի համատեքստ)՝ logger, տվյալների բազայի կառավարիչներ կամ HTTP կլիենտներ։

Կախվածությունները օբյեկտների գրաֆով ներքև փոխանցելու ամենապարզ եղանակը կոնստրուկտորներն են։ Մեկ այլ, Scala-ին հատուկ տարբերակ implicit-ների օգտագործումն է (given/using Scala 3-ում)։

Առաջինը սովորաբար օգտագործվում է բիզնես տրամաբանության համար, երկրորդը՝ ինֆրաստրուկտուրային համատեքստի։

Ֆունկցիոնալ Scala-ում մենք հազվադեպ ենք կախվածությունները միացնելու համար հենվում reflection-ի վրա հիմնված DI ֆրեյմվորքների վրա։ Ամենահայտնի մոտեցումները օբյեկտների գրաֆը ձեռքով կառուցելն է կամ macro-ների վրա հիմնված օժանդակ գրադարանի, ինչպես MacWire-ի, օգտագործումը։

Այս մոտեցումները աշխատում են ցանկացած Scala հավելվածի համար. ուրեմն ZIO-ն կամ CE-ն այստեղ լրացուցիչ ինչ-որ բան ունե՞ն առաջարկելու։

ZIO

Մենք արդեն քննարկել ենք սխալները ZIO-ում և այն, թե ինչպես է այն օգտագործում տիպային պարամետր՝ համոզվելու համար, որ exception-ները ճիշտ են մշակվում։ Իսկ ի՞նչ է միջավայրի տիպային պարամետրը։ Այն թույլ է տալիս նկարագրել տվյալ ZIO ծրագիրը գնահատելու համար անհրաժեշտ կախվածությունները։ Այս կախվածությունները ներկայացնում են հավելվածի շերտեր, որոնք նկարագրվում են ZLayer անունով տվյալների տիպով։

Ահա օրինակ։ Ենթադրենք՝ ուզում ենք կառուցել հավելված, որն օգտագործում է շերտ՝ հիմնված պարզ in-memory map-ի վրա։ Սկսում ենք շերտի պայմանագրի՝ ինտերֆեյսի սահմանումից.

trait KVStore {
  def put(key: Int, value: String): ZIO[Any, Throwable, Unit]
  def get(key: Int): ZIO[Any, Throwable, Option[String]]
}

Այժմ կարող ենք շերտը կանչել ZIO.service-ով, կամ դրա վրա ֆունկցիա կանչել ZIO.serviceWithZIO-ով կամ ZIO.serviceWith-ով։

val app: ZIO[KVStore, Throwable, Unit] = for {
  _ <- ZIO.serviceWithZIO[KVStore](_.put(1, "Adrian"))
  _ <- ZIO.serviceWithZIO[KVStore](_.put(2, "Zygmunt"))
  user <- ZIO.serviceWithZIO[KVStore](_.get(1))
  _ <- Console.printLine(s"User: $user")
} yield ()

ZIO-ն նկատում է, որ կոդը վերաբերում է շերտին, և թարմացնում է միջավայրի տիպը՝ համապատասխանաբար. այստեղ միջավայրի տիպը ներառում է KVStore։ Եթե փորձենք այս ZIO տիպը վերագրել մեկին, որը այդ կախվածությունը չի պահանջում, կստանանք օգտակար կոմպիլյացիայի ժամանակի սխալի հաղորդագրություն.

───────────── ZIO APP ERROR─────────────
─────────────────────────────────────
Ձեր էֆեկտը պահանջում է ծառայություն, որը միջավայրում չկա։
Խնդրում ենք տրամադրել շերտ հետևյալ տիպի համար՝
1. KVStore

Սխալը վերացնելու համար պետք է տրամադրել ճիշտ շերտը։ Սակայն սկզբում իրականացնենք trait-ը.

class InMemKVStore(val s: Ref[Map[Int, String]]) extends KVStore {
  override def put(key: Int, value: String): Task[Unit]
    = s.update(_.updated(key, value))
  override def get(key: Int): Task[Option[String]]
    = s.get.map(_.get(key))
}

Այժմ կարող ենք ստեղծել շերտը։ Կոդը կտեղադրենք companion object-ում.

object InMemoryKVStore {
  val layer: ZLayer[Any, Nothing, InMemoryKVStore] = ZLayer {
    Ref.make(Map.empty[Int, String]).map(InMemoryKVStore(_))
  }
}

Շերտերը տրամադրվում են provide մեթոդով (բոլորը միանգամից փոխանցելով) կամ provideSome-ով (տրամադրելով միայն մի մասը)։

val appWithDeps: ZIO[Any, Throwable, Unit] =
   app.provide(InMemoryKVStore.layer)

Շերտերը շատ լավ համադրվում են, և կարող են կախված լինել միմյանցից. օրինակ՝ տվյալների բազայի հասանելիության շերտին կարող է logger պետք լինել։ Դրանք նաև ճկուն են, քանի որ կարող են կառուցվել բազմաթիվ աղբյուրներից՝ ZIO էֆեկտներ, ֆունկցիաներ, արժեքներ և նույնիսկ ռեսուրսներ, որոնց կյանքի ցիկլը պետք է կառավարվի։

Շերտերը հզոր հնարավորություն են, որը եզակի է ZIO-ի համար, և արժանի լրացում այն բանի, ինչ լեզուն արդեն առաջարկում է (օրինակ՝ implicit-ները)։ ZIO-ն օբյեկտների գրաֆը կառուցելու իր կարծիքն ունեցող եղանակ ունի. կախվածությունները հայտարարել կոնստրուկտորների միջոցով, իսկ հետո այդ կոնստրուկտորները reify անել որպես արժեքներ՝ շերտերի օգնությամբ։

Cats Effect

CE-ն չունի ZIO-ի շերտերի ներկառուցված համարժեք, ուստի սովորաբար հենվում ենք այն բանի վրա, ինչ տրամադրում է հենց լեզուն։

Հավելվածի համատեքստը տրամադրելու մեկ այլ եղանակ, որը CE կոդային բազաներում բավականին հաճախ է հանդիպում, Reader monad-ի օգտագործումն է։ Մենք սովորաբար աշխատում ենք Reader-ի monad transformer-ի հետ՝ ReaderT (հայտնի է նաև որպես Kleisli)։ Այն ունի որոշ թերություններ. ReaderT-ը և IO-ն առանձին մոնադներ են և չեն կարող ուղղակիորեն համադրվել։ Երկուսն էլ մեկ for-comprehension-ում օգտագործելու համար պետք է IO-ն բարձրացնենք ReaderT-ի մեջ՝ ReaderT.liftF-ով։

val app: ReaderT[IO, KVStore, Unit] = for {
  _ <- ReaderT((store: KVStore) => store.put(1, "Adrian"))
  _ <- ReaderT((store: KVStore) => store.put(2, "Zygmunt"))
  user <- ReaderT((store: KVStore) => store.get(1))
  //we need to lift IO to ReaderT
  _ <- ReaderT.liftF(IO.println(s"User: $user")) 
} yield ()

Անհրաժեշտ կախվածությունները կարելի է տրամադրել run մեթոդով.

val program: IO[Unit] = app.run(InMemoryKVStore)

Ռեսուրսների կառավարում

Թե՛ CE-ն, թե՛ ZIO-ն նախագծված են այն նախադրյալով, որ ռեսուրսների անվտանգ կառավարումը առաջին տեղում է։

Հետաքրքիր է, որ դրանցից յուրաքանչյուրը մի փոքր տարբեր մեխանիզմ է օգտագործում՝ ռեսուրսները, երբ այլևս պետք չեն, հուսալիորեն ազատելու համար։

Cats Effect

Սկսենք CE-ից, որն առաջարկում է Resource անունով հատուկ տիպ։ Այն նկարագրում է այն, ինչ անհրաժեշտ է ռեսուրսի կյանքի ցիկլը կառավարելու համար՝ ինչպես այն պատրաստել և ինչպես քանդել։ Նոր Resource ստեղծվում է make մեթոդով, որն ընդունում է երկու արգումենտ. էֆեկտ, որը նկարագրում է, թե ինչպես բացել ռեսուրսը, և ֆունկցիա, որը վերադարձնում է էֆեկտ, որը սահմանում է՝ ինչպես փակել այն։

def fileWriter(fileName: String): Resource[IO, FileWriter] =   
   Resource.make(
     IO(new FileWriter(fileName))
   )(
     writer => IO(writer.close())
   )

Այնուհետև կարող ենք այն օգտագործել use մեթոդով։

fileWriter("foo.txt").use(writer =>
  IO(writer.write("Hello World!"))
)

Resource-ը մոնադ է, ուստի այն համադրվում է flatMap-ով։ Սա հեշտացնում է ռեսուրսների հիերարխիա կառուցելը, որոնք բացվում են մեկը մյուսի հետևից և փակվում հակառակ կարգով։

val resources: Resource[IO, (FileWriter, Supervisor[IO])] = for {
  writer <- fileWriter("foo.txt")
  supervisor <- Supervisor[IO]
} yield (writer, supervisor)

Resource-ը կարելի է դիտարկել որպես IO-ի ուղեկից։ Այն առաջարկում է մեթոդների համանման հավաքածու, սակայն երկուսը առանձին մոնադներ են և չեն կարող համադրվել միմյանց հետ (ճիշտ ինչպես ReaderT-ը և IO-ն)։ IO-ն և Resource-ը մեկ for-comprehension-ում օգտագործելու համար IO-ն պետք է Resource.eval-ով բարձրացվի Resource-ի մեջ։

val resources: Resource[IO, FileWriter] = for {
  writer <- fileWriter("foo.txt")
  _ <- Resource.eval(IO.println("Allocating file writer"))
} yield writer

ZIO

ZIO 1.x-ի ռեսուրսների կառավարման մոդելը բավականին մոտ է CE-ինին։ Այն նույնպես ներառում է Managed անունով հատուկ տվյալների տիպ, որի հետ կարելի է աշխատել գրեթե ինչպես Resource-ի հետ, և որը աշխատում է ZIO-ի հետ միասին։

ZIO 2-ը փոխեց այս մոտեցումը՝ ներմուծելով Scope։ Ինչպես Resource-ը, scope-ը ներկայացնում է մեկ կամ մի քանի ռեսուրսի կյանքի տևողությունը։ Scope կարելի է ստեղծել ZIO.acquireRelease մեթոդով։

def fileWriter(fileName: String):ZIO[Scope, Throwable, FileWriter] =
   ZIO.acquireRelease(
      ZIO.attempt(new FileWriter(fileName))
   )(
      fw => ZIO.succeed(fw.close())
   )

Ինչպես տեսնում եք, Resource.make մեթոդից տարբերվելով՝ acquireRelease-ը հատուկ նշանակության օբյեկտ չի արտադրում, այլ սովորական ZIO։ Միակ տարբերությունը Scope կոչվող միջավայրի հատուկ արժեքն է։ Լինելով սովորական ZIO էֆեկտ՝ այն կարելի է ազատորեն համադրել flatMap-ով կամ փոխանցել ցանկացած օպերատորի, որը ZIO է սպասում։

Կախարդանքը տեղի է ունենում ZIO.scoped օպերատորում։ Այն ընդունում է ցանկացած ZIO workflow, որի միջավայրում Scope կա, ստեղծում է անհրաժեշտ ռեսուրսները, տրամադրում դրանք և փակում, երբ workflow-ն ավարտվում է։ Լռելյայն ռեսուրսները բացվում են scope-ին ավելացվելու հերթականությամբ և փակվում հակառակ կարգով, թեև դա կարելի է կարգավորել։

Արդյունքի տիպն այլևս միջավայրում Scope չունի, ինչը ազդանշան է, որ կառավարելու ռեսուրսներ այլևս չկան։

def run: ZIO[ZIOAppArgs, Throwable, Unit] =
   ZIO.scoped {
      for {
        writer <- fileWriter("foo.txt")
        _ <- ZIO.attempt(writer.write("Hello World!"))
      } yield ()
   }

Կոնկուրենտություն

CE-ն և ZIO-ն երկուսն էլ հիանալի են կոնկուրենտ հավելվածներ կառուցելու համար։ Դրանց կոնկուրենտության համակարգերը կառուցված են fiber-ի վրա՝ թեթև տրամաբանական թրեդ, որը ներկայացնում է գործողությունների հաջորդականություն։ Այստեղ դա նշանակում է IO monad-ում կասեցված և flatMap-ով շղթայված գործողությունների ցանկ։ ZIO-ի և CE-ի runtime-ները կարող են տասնյակ հազարավոր fiber-ներ մուլտիպլեքսավորել ընդամենը մի քանի համակարգային թրեդի վրա։

CE-ում նոր fiber սկսվում է IO-ի վրա start կանչելով, ZIO-ում համարժեք մեթոդը կոչվում է fork։ Fiber-ի արդյունքին սպասելու համար կանչում ենք join (ZIO և CE)։ Fiber-ը կարելի է կանգնեցնել և նրա հաշվարկը չեղարկել cancel-ով (CE) կամ interrupt-ով (ZIO)

//ZIO 2.x.x
val fiber1: Task[Fiber.Runtime[Throwable, Unit]] = 
  ZIO.attempt(heavyComputations).fork

//CE 3.x.x
val fiber2: IO[FiberIO[Unit]] = IO(heavyComputations).start

Երկու գրադարաններն էլ առաջարկում են ավելի բարձր մակարդակի օպերատորներ, որոնք հետևում են structured concurrency պարադիգմային, որտեղ fiber-ի կյանքի ցիկլը համընկնում է կոդի շարահյուսական կառուցվածքի հետ։ Օրինակ՝ այնպիսի օպերատորներ, ինչպիսիք են parSequence-ը (CE) կամ collectAllPar-ը (ZIO), մի քանի գործողություն կատարում են զուգահեռ։ Դրանք սկսում են մի շարք fiber-ներ՝ գործողությունները կոնկուրենտ կատարելու համար, և փակում են դրանք, երբ այլևս պետք չեն։

//ZIO 2.x.x
val result1 = ZIO.collectAllPar(listOfZIOTasks)

//CE 3.x.x
import cats.syntax.all.*
val result2 = listOfIOTasks.parSequence

Կրկին, երկու գրադարաններն առաջարկում են նման API-ներ և հնարավորություններ, սակայն կան որոշ նկատելի տարբերություններ։ ZIO-ում Fiber-ները վերահսկվում են և կապված են իրենց ծնողների կյանքի ցիկլին։ Երբ fiber-ը (ծնողը) նոր fiber-ներ է fork անում և հետո ավարտվում է, նրա բոլոր երեխաները նույնպես ընդհատվում են։ Չկառավարվող fiber ստեղծելու համար պետք է forkDaemon օպերատորը։ CE-ում, ընդհակառակը, fiber-ները չեն վերահսկվում։ Մեզ պետք է հատուկ ռեսուրս՝ Supervisor, որը fiber-ների կյանքի ցիկլը կապում է իր սեփականին։ Տարբերությունը կարող է նուրբ թվալ, սակայն գրադարանների միջև անցնելիս կարող է շփոթեցնել։

Թե՛ ZIO-ն, թե՛ CE-ն ունեն հզոր ստանդարտ գրադարաններ, որոնք աջակցում են կոնկուրենտությանը։ Դրանք առաջարկում են սեմաֆորներ, ատոմար հղումներ, կոնկուրենտ հերթեր և շատ ավելին։ Դրանից բացի, համայնքի կողմից ղեկավարվող նախագծեր, ինչպես ZIO Actors-ը կամ Cats STM-ը, մեզ տալիս են էլ ավելի շատ հնարավորություններ։

Streaming

Streaming-ի դեպքում ցանկացած պահի հիշողության մեջ գտնվում է տվյալների միայն մի կտոր, ուստի կարող ենք անվերջ տվյալներ մշակել վերջավոր ռեսուրսներով։ Թե՛ ZIO-ն, թե՛ CE-ն կարող են պարծենալ streaming գործողությունների հասուն, արդյունավետ գրադարաններով։ CE-ն որպես կախվածություն օգտագործում է fs2-ը, իսկ ZIO-ն առաքվում է ZIO Streams-ով։

Երկու streaming գրադարանները որոշ նույն դիզայնային ընտրություններն են արել։ Երկուսն էլ ֆունկցիոնալ են և pull-based, և տվյալները մշակում են chunk-երով (որպես արդյունավետության օպտիմիզացիա)։ Դրանք նաև առաջարկում են համադրելի բարձր մակարդակի, դեկլարատիվ API՝ բարդ, կոնկուրենտ workflow-ներ արտահայտելու համար։

Ահա fs2-ով կառուցված stream-ի պարզ օրինակ.

val stream: Stream[IO, Int] = Stream.emits(1 to 10)
  .filter(_ % 2 == 0)
  .map(_ * 2)
  .evalTap(num => IO.println(s"Number $num"))

fs2 stream-երը գնահատվում են ծույլ եղանակով, ուստի դրանք սպառելու համար պետք է կանչել compile, որին հաջորդում է եզրափակող մեթոդներից մեկը.

for {
  //we need to compile to consume the stream
  result <- stream.compile.fold(0)(_ + _)
  _ <- IO.println(s"Result: $result")
} yield ()

Իսկ հիմա ZIO-ի օրինակը.

val stream: ZStream[Any, IOException, RuntimeFlags] = 
  ZStream.fromIterable(1 to 10)
   .filter(_ % 2 == 0)
   .map(_ * 2)
   .tap(num => Console.printLine(s"Number $num"))

for {
  result <- stream.run(ZSink.foldLeft(0) (_ + _))
  _ <- Console.printLine(s"Result: $result")
} yield ()

Առաջին հայացքից երկու օրինակները շատ նման են, սակայն կա մեկ հիմնական տարբերություն։ ZIO Streams-ն առաջարկում է աշխատելու համար լրացուցիչ տվյալների տիպ՝ ZSink։ Sink-ը գրեթե նույն նպատակն է ծառայում, ինչ fs2-ի compile մեթոդը՝ stream-ը սպառել։ Դրա առավելությունն այն է, որ այն արժեք է, որը կարելի է ձևափոխել և համադրել այլ sink-երի հետ։

Փիլիսոփայությունը, դիզայնը և էկոհամակարգը

Մինչ այժմ քննարկել ենք երկու գրադարանների ամենակարևոր նմանություններն ու տարբերությունները։ Եկեք հիմա նայենք այն դիզայնային նպատակներին, որոնք դրել են նրանց մշակողները։

ZIO-ն ձգտում է լինել հնարավորինս պրագմատիկ։ Այն հետևում է batteries-included մոտեցմանը՝ փորձելով անմիջապես տրամադրել ժամանակակից ֆունկցիոնալ հավելված կառուցելու համար անհրաժեշտ ամեն ինչ։

CE-ն, ընդհակառակը, ավելի թեթև է և ավելի քիչ «կարծիքներ ունեցող»։ Բազմաթիվ հնարավորություններ, որ ZIO-ում ներկառուցված են, CE-ում տրամադրվում են արտաքին գրադարանների լայն շարքով։

Բացի այդ, CE-ն հետևում է Tagless Final մոտեցմանը. յուրաքանչյուր տվյալների տիպ, ինչպես Resource-ը, Ref-ը կամ fs2-ի Stream-ը, կարող է որպես էֆեկտի տիպ վերցնել աբստրակտ F[_]։ F[_]-ի միակ պահանջն այն է, որ այն իրականացնի Cats Effect գրադարանի սահմանած տիպային դասերը (typeclasses)։ Արդյունքում մենք կապված չենք IO-ին՝ որպես մոնադի իրականացման. լրացուցիչ ճկունություն, որ ZIO-ն չի առաջարկում։

Թե՛ CE-ն, թե՛ ZIO-ն ունեն գրադարանների հարուստ, արագ աճող էկոհամակարգեր՝ տվյալների բազայի հասանելիության, JSON parsing-ի, HTTP կլիենտների և սերվերների ու շատ ավելիի համար։ CE գրադարանները սովորաբար հետևում են Tagless Final-ին և աշխատում են ցանկացած էֆեկտների համակարգի հետ, որն իրականացնում է CE-ի typeclass-ները։ Բարեբախտաբար, ZIO-ն դրանք տրամադրում է interop-cats մոդուլի միջոցով, որը նաև հնարավոր է դարձնում ZIO գրադարանները CE-ի հետ աշխատեցնել։

Ամփոփում

Սա Scala-ի հայտնի էֆեկտների համակարգերի այս կարճ համեմատության ավարտն է։ Ես գնահատականներ կամ կտրուկ կարծիքներ չեմ բաժանել, բայց հուսով եմ՝ հոդվածը կօգնի, եթե ձեր հաջորդ նախագծի համար երկմտում եք CE-ի և ZIO-ի միջև։ Բենչմարկները նույնպես բաց եմ թողել. դրանք կարող են հետաքրքիր թեմա լինել առանձին հոդվածի համար։

Երկու գրադարաններն էլ արժանի են փորձելու, և երկուսն էլ հուսալի ընտրություն են ժամանակակից FP-կողմնորոշված հավելվածներ կառուցելու համար։