تقدير المشروع
← كل المقالات

مقارنة بين Cats Effect وZIO

مقارنة جنبًا إلى جنب بين ZIO وCats Effect، وهما مكتبتان رائعتان في Scala. وتوفر كل منهما أدوات لكتابة تطبيقات غير متزامنة ومتزامنة التنفيذ.

19 دقائق قراءة
ScalaCats EffectZioMonad

برمجة غير متزامنة ومتزامنة التنفيذ لـ Scala، آمنة من حيث الأنواع وقابلة للتركيب

شعار موقع ZIO

بيئة تشغيل غير متزامنة نقية لـ Scala

شعار موقع Cats Effect

يهدف هذا المقال إلى المقارنة بين مكتبتين رائعتين في Scala: ZIO وCats Effect. وتوفر كل منهما أدوات لكتابة تطبيقات غير متزامنة ومتزامنة التنفيذ.

وقد أثبتت كلتاهما جدارتها في الميدان وتعملان في بيئات الإنتاج لدى شركات كثيرة. والأهم من ذلك أن كلتيهما تقومان على نموذج البرمجة الوظيفية – فهما تنفّذان نظام تأثيرات وظيفيًا. وسنتناول فلسفة المكتبتين وميزاتهما الأساسية وما يجمع بينهما وما يفرّق. ولن أدخل في التفاصيل الدقيقة – فجوانب كثيرة من هاتين المكتبتين تحتاج إلى مقالات مستقلة.

وسأركّز على أحدث إصدارات كلتيهما: سلسلة ZIO 2.x وCats Effect 3.x.

مونَد IO

تعتمد Cats Effect وZIO كلتاهما على نوع بيانات مخصص لتعليق الحسابات، يُعرف بمونَد IO. ففي CE يُسمى IO، أما في ZIO فهو ZIO ببساطة (مع أنه تُستخدم أيضًا بعض الأسماء البديلة المتخصصة مثل URIO أو Task – سنتحدث عنها لاحقًا).

يتيح لنا مونَد IO تعليق الحسابات التي تنتج قيمة وقد تُحدث أثرًا جانبيًا. والفكرة المركزية أن هذه الإجراءات يمكن تركيبها وتحويلها تمامًا كأي قيمة أخرى في البرمجة الوظيفية. وبعد ذلك يمكن تقييم البرامج المبنية من تركيب عدة IO، ويُفضَّل أن يتم ذلك عند نقطة دخول التطبيق، المعروفة بـ «نهاية العالم» (end-of-the-world). ويسمى المكوّن الذي ينفّذ هذه البرامج بكفاءة بيئة التشغيل (runtime)، وهو في قلب المكتبتين.

الميزات الأساسية

توفر كل مكتبة مجموعة من المركّبات (combinators) لتعليق الحسابات غير النقية ذات الأثر الجانبي والتعامل معها. وإليك نظرة موجزة.

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.

//> 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 التي تقيّم البرنامج.

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 يعني الشيء نفسه الذي يعنيه المعامل الوحيد لـ IO في CE – نوع القيمة المعادة عند التقييم الناجح، أي قناة النجاح. والنوع الثاني E هو قناة الأخطاء – ويحدد نوع (أو أنواع) الأخطاء التي قد يفشل بها التطبيق. وتشير Nothing في قناة الأخطاء إلى أن البرنامج لن يفشل (أو على الأقل لا يُتوقع أن يفشل). أما الأول R فهو البيئة – ويسرد كل التبعيات اللازمة لتقييم البرنامج. والبرنامج الذي تكون بيئته من النوع Any يصف تطبيقًا بلا تبعيات.

وتعرّف ZIO عددًا من الأسماء البديلة للتسهيل. فمثلًا يمثل UIO[A] تأثيرًا ينتج قيمة A ولا يمكن أن يفشل بأي خطأ متوقع ولا يحتاج إلى شيء من البيئة. والقائمة الكاملة للأسماء البديلة متاحة هنا.

وكما تفعل CE، توفر ZIO سمة مساعدة لإقلاع تطبيق جديد: ZIOApp، التي تجلب بيئة التشغيل الافتراضية في ZIO.

//> 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 ()
}

وباستثناء توقيع نوع النتيجة، تبدو المكتبتان وتبدوان في الاستخدام متشابهتين حتى الآن. لننتقل الآن إلى أول فرق كبير – معالجة الأخطاء.

معالجة الأخطاء

صُممت كل مكتبة حول المعالجة غير المتزامنة، التي قد يعمل فيها حساب واحد على خيوط كثيرة خلال حياته. ولذلك لا يمكننا الاعتماد ببساطة على آليات اللغة القياسية لرمي الاستثناءات والتقاطها. ولهذا توفر CE وZIO آلية مخصصة لإطلاق الأخطاء ونشرها ومعالجتها.

ZIO

تعالج ZIO الأخطاء بطريقتها المميزة، فهي تفرّق بين ثلاثة أنواع من الأخطاء:

  • أخطاء متوقعة، تُعرف بـ الإخفاقات (failures)
  • أخطاء غير متوقعة – العيوب (defects)
  • أخطاء قاتلة

سنبدأ بالأخطاء المتوقعة. تريد ZIO التأكد من أننا نتعامل معها بشكل صحيح. وتفعل ذلك بوضع أنواع الأخطاء المتوقعة في معامل النوع الثاني لديها – قناة الأخطاء. وفي كل مرة نطلق فيها خطأ بواسطة ZIO.fail، يظهر تلقائيًا في توقيع النوع.

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

محاولة تركيب هذا الـ 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 بواجهة برمجية غنية ومرنة لإدارة الأخطاء. يمكننا مثلًا معالجة بعض الأخطاء فقط بواسطة catchSome، أو كل الأخطاء دفعة واحدة بواسطة catchAll.

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

كما تتعامل ZIO مع الواجهات البرمجية التي تدير الأخطاء عبر Either. فباستخدام ZIO.either يمكننا نقل الخطأ من قناة الأخطاء في ZIO إلى Either على قناة النجاح (ZIO[R, E, A] => ZIO[R, Nothing, Either[E, A]]). وللانتقال في الاتجاه المعاكس، ZIO[R, Nothing, Either[E, A]] => ZIO[R, E, A]، توجد ZIO.absolve.

وماذا عن العيوب إذن؟ إنها تمثل سلوكًا استثنائيًا معيبًا للتطبيق لا ينبغي أن يحدث في المسار العادي، ولا يُفترض بنا التقاطها. وتوصي أدلة ZIO بدلًا من ذلك بنهج Let it crash (دعه ينهار). ويُطلق العيب بواسطة ZIO.die.

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

وبينما يمكن أن تكون الإخفاقات من أي نوع، يجب أن تكون العيوب المُبلَّغ عنها نوعًا فرعيًا من Throwable. وعادةً لا تكون هناك حاجة إلى ذلك، لكن يمكن مع ذلك التقاط العيوب بعوامل مثل catchAllDefects. وهناك أيضًا orDie التي تحوّل إخفاقًا عاديًا (طالما أنه نوع فرعي من Throwable) إلى عيب، وresurrect التي تحوّل العيب إلى إخفاق مرة أخرى.

وأخيرًا، تمثل الأخطاء القاتلة إخفاقات كارثية في JVM، مثل أخطاء OOM. ولا توفر ZIO أي وسيلة لاعتراضها أو معالجتها.

Cats Effect

نهج CE في معالجة الأخطاء أبسط. لا توجد قنوات أخطاء مصنّفة بالأنواع، والأخطاء الوحيدة التي يمكننا إطلاقها هي أنواع فرعية من Throwable. ثم إما نلتقطها لاحقًا في مجرى التنفيذ، أو يُسقط الاستثناء غير المعالَج التطبيق. وهي من هذه الناحية تعمل كثيرًا مثل عيوب ZIO.

تُطلق الأخطاء بواسطة IO.raiseError.

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

وللتقاطها يمكننا استخدام handleError أو handleErrorWith.

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

وداخليًا، تعتمد CE على MonadError من Cats، مع تثبيت نوع الخطأ على Throwable.

لكن هل من الممكن الحصول على أخطاء مصنّفة بالأنواع في CE؟ ما زال بإمكاننا تضمين Either داخل IO، وتساعد دالتان مساعدتان على نقل الأخطاء بين Either وقناة الأخطاء في CE. فالدالة 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 transformers). ومع ذلك، فإن استخدام محوّلات المونَد ليس بسلاسة العمل مع قناة الأخطاء المدمجة في ZIO.

هيكلة التطبيق

ننتقل إلى الموضوع التالي – كيف ينبغي هيكلة تطبيقات Scala المبنية بأنظمة التأثيرات الوظيفية؟ قد تعتمد أجزاء من شيفرة الأعمال على أجزاء أخرى من النظام تنفّذ جوانب مختلفة من المنطق. وقد تكون هناك أيضًا تبعيات بنية تحتية (ما يسمى سياق التطبيق): مسجِّل (logger) أو مديرو قواعد البيانات أو عملاء HTTP.

أبسط طريقة لتمرير التبعيات عبر مخطط الكائنات هي المنشئات (constructors). وخيار آخر خاص بـ Scala هو استخدام implicits (أي given/using في Scala 3).

وعادةً يُستخدم الأول لمنطق الأعمال، والثاني للسياق المتعلق بالبنية التحتية.

وفي Scala الوظيفية، نادرًا ما نعتمد على أطر حقن التبعيات (DI) القائمة على الانعكاس (reflection) لربط التبعيات. وأشهر النهجين هما بناء مخطط الكائنات يدويًا أو استخدام مكتبة مساعدة قائمة على الماكرو مثل MacWire.

وهذان النهجان يصلحان لأي تطبيق Scala – فهل لدى ZIO أو CE ما تقدمانه إضافةً هنا؟

ZIO

لقد تناولنا الأخطاء في ZIO وكيف تستخدم معامل نوع لضمان معالجة الاستثناءات بشكل صحيح. لكن ماذا عن معامل نوع البيئة؟ إنه يتيح لنا وصف التبعيات اللازمة لتقييم برنامج ZIO معين. وتمثل هذه التبعيات طبقات التطبيق، التي يصفها نوع بيانات اسمه ZLayer.

إليك مثالًا. لنفترض أننا نريد بناء تطبيق يستخدم طبقة قائمة على خريطة بسيطة في الذاكرة. نبدأ بتعريف العقد الخاص بالطبقة – أي واجهة:

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 ─────────────
─────────────────────────────────────
يتطلب تأثيرك خدمة غير موجودة في البيئة.
يرجى توفير طبقة للنوع التالي:
1. KVStore

ولإزالة الخطأ علينا توفير الطبقة الصحيحة. لكن لننفّذ السمة أولًا:

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)

تتركّب الطبقات بشكل جيد جدًا، ويمكن أن تعتمد إحداها على الأخرى – فقد تحتاج طبقة الوصول إلى قاعدة البيانات مثلًا إلى مسجِّل. وهي مرنة أيضًا، إذ يمكن بناؤها من مصادر كثيرة: تأثيرات ZIO ودوال وقيم، بل وحتى موارد يلزم إدارة دورة حياتها.

الطبقات ميزة قوية فريدة في ZIO، وهي مكمّل جدير بما توفره اللغة أصلًا (مثل implicits). ولدى ZIO طريقة صارمة الرأي لبناء مخطط الكائنات: أن تعلن التبعيات عبر المنشئات، ثم تحوّل هذه المنشئات إلى قيم (reify) بواسطة الطبقات.

Cats Effect

ليس لدى CE نظير مدمج لطبقات ZIO، لذا نعتمد عادةً على ما توفره اللغة نفسها.

وثمة طريقة أخرى لتوفير سياق التطبيق، تظهر بكثرة في قواعد شيفرة CE، وهي استخدام مونَد Reader. وعادةً نعمل مع محوّل مونَد لـ Reader – هو 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 بواسطة Resource.eval.

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. وتمثل النطاقات (scopes)، مثل Resource، مدة حياة مورد واحد أو أكثر. ويمكن إنشاء نطاق بالدالة 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 يحتوي 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 والمتسلسلة بواسطة flatMap. ويمكن لبيئتَي تشغيل ZIO وCE توزيع عشرات الآلاف من الألياف على بضعة خيوط نظام فقط.

وفي CE يُبدأ ليف جديد باستدعاء start على IO؛ وفي ZIO تُسمى الدالة المكافئة fork. وللانتظار حتى ظهور نتيجة ليف نستدعي join (في ZIO وCE). ويمكن إيقاف الليف وإلغاء حسابه بواسطة 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)، حيث تطابق دورة حياة الليف البنية النحوية للشيفرة. فمثلًا تشغّل عوامل مثل parSequence (في CE) أو collectAllPar (في ZIO) عدة عمليات على التوازي. فهي تبدأ عددًا من الألياف لتنفيذ العمليات بالتزامن وتغلقها عند انتفاء الحاجة إليها.

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

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

ومرة أخرى، توفر المكتبتان واجهات برمجية وقدرات متشابهة، لكن هناك بعض الفروق اللافتة. ففي ZIO تكون الألياف مُشرَفًا عليها ومرتبطة بدورة حياة آبائها. فعندما يشعّب ليف (الأب) ألياف جديدة ثم ينتهي، تُقاطَع جميع أبنائه أيضًا. ويتطلب إنشاء ليف غير مُدار العامل forkDaemon. أما في CE، فعلى العكس، فالألياف غير مُشرَف عليها. ونحتاج إلى مورد خاص، هو Supervisor، يربط دورة حياة الألياف بدورة حياته. وقد يبدو الفرق دقيقًا، لكنه قد يربك عند الانتقال بين المكتبتين.

وتأتي ZIO وCE كلتاهما بمكتبات قياسية قوية تدعم التزامن. فهما توفران إشارات (semaphores) ومراجع ذرية (atomic references) وطوابير متزامنة وغير ذلك الكثير. وإضافة إلى ذلك، تمنحنا مشاريع يقودها المجتمع مثل ZIO Actors أو Cats STM قدرات أكثر.

المعالجة المتدفقة

مع المعالجة المتدفقة (streaming)، لا يوجد في الذاكرة سوى جزء من البيانات في أي لحظة، لذا يمكننا معالجة بيانات لا نهائية بموارد محدودة. وتستطيع ZIO وCE كلتاهما التباهي بمكتبات ناضجة وفعّالة لعمليات التدفق. تستخدم CE مكتبة fs2 كتبعية، بينما تأتي ZIO بمكتبة ZIO Streams.

وتتخذ مكتبتا التدفق بعض خيارات التصميم نفسها. فكلتاهما وظيفية وقائمة على السحب (pull-based)، وتعالجان البيانات على شكل أجزاء (chunks) (كتحسين للأداء). كما توفران واجهة برمجية تصريحية عالية المستوى قابلة للمقارنة للتعبير عن مسارات عمل معقدة متزامنة.

وهذا مثال بسيط لتدفق مبني بـ fs2:

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

تُقيَّم تدفقات fs2 بكسل، لذا يتطلب استهلاكها استدعاء 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) الغرض نفسه تقريبًا الذي تؤديه دالة compile في fs2 – استهلاك التدفق. وميزته أنه قيمة يمكن تحويلها ودمجها مع مصارف أخرى.

الفلسفة والتصميم والنظام البيئي

حتى الآن تناولنا أهم أوجه التشابه والاختلاف بين المكتبتين. لننظر الآن إلى أهداف التصميم التي وضعها مطوّروهما.

تسعى ZIO إلى أن تكون عملية قدر الإمكان. فهي تتبع نهج «البطاريات مضمّنة»، محاولةً توفير كل ما يلزم لبناء تطبيق وظيفي حديث جاهزًا من الصندوق.

أما CE فعلى العكس أخف وأقل صرامة في آرائها. وكثير من الميزات المدمجة في ZIO تقدمها CE عبر طيف واسع من المكتبات الخارجية.

وإضافة إلى ذلك، تتبع CE نهج Tagless Final: فكل نوع بيانات، مثل Resource أو Ref أو Stream في fs2، يمكنه أن يأخذ F[_] مجردًا بوصفه نوع التأثير. والشرط الوحيد على F[_] هو تنفيذه لفئات الأنواع (typeclasses) التي تعرّفها مكتبة Cats Effect. ونتيجة لذلك لا نكون مقيدين بـ IO كتنفيذ للمونَد – وهي درجة مرونة إضافية لا توفرها ZIO.

وللمكتبتين معًا أنظمة بيئية غنية وسريعة النمو من المكتبات للوصول إلى قواعد البيانات وتحليل JSON وعملاء وخوادم HTTP وغير ذلك الكثير. وتتبع مكتبات CE عادةً Tagless Final وتعمل مع أي نظام تأثيرات ينفّذ فئات أنواع CE. ولحسن الحظ توفر ZIO هذه عبر وحدة interop-cats، التي تجعل أيضًا من الممكن تشغيل مكتبات ZIO مع CE.

الخلاصة

بهذا نصل إلى نهاية هذه المقارنة الموجزة بين أنظمة التأثيرات الشائعة في Scala. لم أمنح درجات ولا آراء حاسمة، لكنني آمل أن يفيدك المقال إن كنت محتارًا بين CE وZIO لمشروعك القادم. كما تجاوزت الاختبارات المعيارية (benchmarks)، التي يمكن أن تكون موضوعًا شيقًا لمقال منفصل.

تستحق المكتبتان كلتاهما التجربة، وكلتاهما خيار متين لبناء تطبيقات حديثة موجّهة نحو البرمجة الوظيفية.