Scala Cats / fs2'de yığın güvenliği ile ilgili nedenler?

İşte fs2 belgelerinden bir parça kod . İşlev goözyinelemeli. Soru, yığının güvenli olup olmadığını nasıl bilebiliriz ve herhangi bir fonksiyonun yığın güvenli olup olmadığını nasıl anlayabiliriz?

import fs2._
// import fs2._

def tk[F[_],O](n: Long): Pipe[F,O,O] = {
  def go(s: Stream[F,O], n: Long): Pull[F,O,Unit] = {
    s.pull.uncons.flatMap {
      case Some((hd,tl)) =>
        hd.size match {
          case m if m <= n => Pull.output(hd) >> go(tl, n - m)
          case m => Pull.output(hd.take(n.toInt)) >> Pull.done
        }
      case None => Pull.done
    }
  }
  in => go(in,n).stream
}
// tk: [F[_], O](n: Long)fs2.Pipe[F,O,O]

Stream(1,2,3,4).through(tk(2)).toList
// res33: List[Int] = List(1, 2)

goBaşka bir yöntemden çağırırsak da yığın güvenli olur mu?

def tk[F[_],O](n: Long): Pipe[F,O,O] = {
  def go(s: Stream[F,O], n: Long): Pull[F,O,Unit] = {
    s.pull.uncons.flatMap {
      case Some((hd,tl)) =>
        hd.size match {
          case m if m <= n => otherMethod(...)
          case m => Pull.output(hd.take(n.toInt)) >> Pull.done
        }
      case None => Pull.done
    }
  }

  def otherMethod(...) = {
    Pull.output(hd) >> go(tl, n - m)
  }

  in => go(in,n).stream
}

Buradaki önceki cevabım faydalı olabilecek bazı arka plan bilgileri veriyor. Temel fikir, bazı efekt türlerinin flatMapdoğrudan yığın güvenli özyinelemeyi destekleyen uygulamalara sahip olmasıdır;flatMap çağrıları açıkça veya özyineleme yoluyla istediğiniz kadar derinlemesine iç ve yığının üzerine taşmazsınız.

Bazı efekt türlerinde flatMap, efektin anlambilimi nedeniyle yığın güvenli olmak mümkün değildir . Diğer durumlarda, bir yığın kasası yazmak mümkün olabilir flatMap, ancak uygulayıcılar performans veya diğer hususlar nedeniyle olmamasına karar vermiş olabilir.

Ne yazık ki, flatMapbelirli bir tür için yığın güvenli olup olmadığını bilmenin standart (hatta geleneksel) bir yolu yoktur . Kediler, tailRecMherhangi bir yasal monadik etki türü için yığın güvenli monadik özyineleme sağlaması gereken bir işlem içerir ve bazen tailRecMyasal olduğu bilinen bir uygulamaya bakmak a'nın flatMapyığın güvenli olup olmadığı hakkında bazı ipuçları verebilir . Durumunda PullÖyle görünüyor bu :

def tailRecM[A, B](a: A)(f: A => Pull[F, O, Either[A, B]]) =
  f(a).flatMap {
    case Left(a)  => tailRecM(a)(f)
    case Right(b) => Pull.pure(b)
  }

Bu tailRecMsadece içinden recursing edilir flatMapve biz biliyoruz Pull'ın Monadörneği yasal olduğunu bu oldukça iyi bir kanıt olan Pulls' flatMapisimli yığını güvenli. Burada faktörünü komplike bir için örnek olmasıdır Pullbir sahiptir ApplicativeErrorüzerine kısıtlamayı Fo Pull'ın flatMapyaptığı değil, ama değişim şey yapmaz bu durumda.

Bu yüzden, buradaki tkuygulama yığın güvenlidir, çünkü flatMapon Pullyığın güvenlidir ve bunun tailRecMuygulanmasına bakmasını biliyoruz . (Biraz daha derine inersek flatMap, yığın için güvenli olduğunu anlayabiliriz , çünkü Pullesas FreeColarak tramplenli bir sarıcıdır .)

Aksi halde gereksiz kısıtlamayı eklememiz gerekse de, muhtemelen tkaçısından yeniden yazmak çok zor olmayacaktır . Ben belgelerin yazarları tahmin ediyorum netlik için bunu seçtim ve onlar bildikleri için 's gayet iyi.tailRecMApplicativeErrorPullflatMap

Güncelleme: işte oldukça mekanik bir tailRecMçeviri:

import cats.ApplicativeError
import fs2._

def tk[F[_], O](n: Long)(implicit F: ApplicativeError[F, Throwable]): Pipe[F, O, O] =
  in => Pull.syncInstance[F, O].tailRecM((in, n)) {
    case (s, n) => s.pull.uncons.flatMap {
      case Some((hd, tl)) =>
        hd.size match {
          case m if m <= n => Pull.output(hd).as(Left((tl, n - m)))
          case m => Pull.output(hd.take(n.toInt)).as(Right(()))
        }
      case None => Pull.pure(Right(()))
    }
  }.stream

Açık bir özyineleme olmadığını unutmayın.

İkinci sorunuzun cevabı, diğer yöntemin neye benzediğine bağlıdır, ancak özel örneğiniz durumunda, >>sadece daha fazla flatMapkatmanla sonuçlanacaktır , bu yüzden iyi olmalıdır.

Sorunuzu daha genel olarak ele almak için, bu konunun tamamı Scala'da kafa karıştırıcı bir karmaşa. Sadece bir türün yığın güvenli monadik özyinelemeyi destekleyip desteklemediğini bilmek için yukarıda yaptığımız gibi uygulamaları incelemeniz gerekmez. Belgelerle ilgili daha iyi sözleşmeler burada yardımcı olacaktır, ancak maalesef çok iyi bir iş çıkarmıyoruz. Her zaman tailRecM"güvenli" olarak kullanabilirsiniz ( F[_]zaten genel olduğunda yapmak isteyeceğiniz şey budur), ancak o zaman bile Monaduygulamanın yasal olduğuna güveniyorsunuz .

Özetlemek gerekirse: bu kötü bir durumdur ve hassas durumlarda bu tür uygulamaların yığın güvenli olduğunu doğrulamak için kesinlikle kendi testlerinizi yazmalısınız.