Условное поведение со свободными монадами

Question

Я следую учебнику здесь: http://typelevel.org/cats/datatypes/freemonad.html и пытается изменить его для работы с кешем перед хранилищем значений ключей. Это то, к чему я пришел, но я получаю ошибку компилятора с valueGetOperation. Я понимаю, почему я получаю ошибку компиляции, я просто не понимаю, как ее обойти. Какова наилучшая практика условного поведения при использовании свободной монады?

import cats.data.Coproduct 
import cats.free.{Free, Inject} 

object KvStore { 
    sealed trait KvOp[A] 
    case class Get[T](key: String) extends KvOp[Option[T]] 
    case class Put[T](key: String, value: T) extends KvOp[Unit] 
    case class Delete[T](key: String) extends KvOp[Unit] 
} 

object CacheStore { 
    sealed trait CacheOp[A] 
    case class Get[T](key: String) extends CacheOp[Option[T]] 
    case class Put[T](key: String, value: T) extends CacheOp[Unit] 
    case class Delete[T](key: String) extends CacheOp[Unit] 
} 

type WriteThruCache[A] = Coproduct[KvStore.KvOp, CacheStore.CacheOp, A] 

class KvOps[F[_]](implicit I: Inject[KvStore.KvOp, F]) { 
    import KvStore._ 
    def get[T](key: String): Free[F, Option[T]] = Free.inject[KvOp, F](Get(key)) 
    def put[T](key: String, value: T): Free[F, Unit] = Free.inject[KvOp, F](Put(key, value)) 
    def delete[T](key: String): Free[F, Unit] = Free.inject[KvOp, F](Delete(key)) 
} 

object KvOps { 
    implicit def kvOps[F[_]](implicit I: Inject[KvStore.KvOp, F]): KvOps[F] = new KvOps[F] 
} 

class CacheOps[F[_]](implicit I: Inject[CacheStore.CacheOp, F]) { 
    import CacheStore._ 
    def get[T](key: String): Free[F, Option[T]] = Free.inject[CacheOp, F](Get(key)) 
    def put[T](key: String, value: T): Free[F, Unit] = Free.inject[CacheOp, F](Put(key, value)) 
    def delete[T](key: String): Free[F, Unit] = Free.inject[CacheOp, F](Delete(key)) 
} 

object CacheOps { 
    implicit def cacheOps[F[_]](implicit I: Inject[CacheStore.CacheOp, F]): CacheOps[F] = new CacheOps[F] 
} 

def valueWriteOperation[T](implicit Kv: KvOps[WriteThruCache], Cache: CacheOps[WriteThruCache]): ((String, T) => Free[WriteThruCache, Unit]) = { 
    (key: String, value: T) => 
    for { 
     _ <- Kv.put(key, value) 
     _ <- Cache.put(key, value) 
    } yield() 
} 

// This is where I'm stuck 
// desired behavior: If the value isn't in the cache, load it from the kv store and put it in the cache 
def valueGetOperation[T](implicit Kv: KvOps[WriteThruCache], Cache: CacheOps[WriteThruCache]): ((String) => Free[WriteThruCache, Option[T]]) = { 
    (key: String) => 
    for { 
     cacheOption <- Cache.get[T](key) 
     kvOption <- Kv.get[T](key) if cacheOption.isEmpty // value withFilter is not a member of cats.free.Free[A$A39.this.WriteThruCache,Option[T]] 
    } yield cacheOption.orElse(kvOption) 
} 

Answer 1

Как вы знаете, в for понимания, когда вы используете if он обессахаренный компилятор для вызова метода withFilter, и если он не доступен он возвращается к filter методе. Если они не реализованы, вы получите ошибку компилятора.

Однако вы можете просто использовать ifelse!

for { 
    booleanValue <- myfreeAlbebra.checkCondidtion(arg1, arg2) 
    valueToReturn <- if (booleanValue) { 
    myfreeAlbebra.someValue 
    } else { 
    myfreeAlbebra.someOtherValue 
    } 
} yield valueToReturn 

в качестве альтернативы вы можете сделать что-то вроде:

for { 
    booleanValue <- myfreeAlbebra.checkCondidtion(arg1, arg2) 
    valueToReturnOpt <- myfreeAlbebra.someValue 
    fallbackValue <- myfreeAlbebra.someOtherValue 
} yield valueToReturnOpt.getOrElse(fallbackValue) 

formar один присвоит значение valueToReturn в зависимости от booleanValue. Таким образом, будет интерпретироваться только одна ветвь. Более поздняя версия будет оценивать оба значения и возвращать один из них в зависимости от того, будет ли valueToReturnOpt пустым.

Лично я хотел бы попробовать что-то вроде:

def valueGetOperation[T](implicit Kv: KvOps[WriteThruCache], Cache: CacheOps[WriteThruCache]): ((String) => Free[WriteThruCache, Option[T]]) = { 
    (key: String) => 
    for { 
     cacheOption <- Cache.get[T](key) 
     returnedValue <- if (cacheOption.isEmpty) Cache.get[T](key) else Kv.get[T](key) 
    } yield returnedValue 
} 

Answer 2

Следующие предложения Матеуш», это то, что я придумал:

def withFallback[A[_], T](loadedValue: Option[T], fallback: => Free[A, Option[T]]): Free[A, Option[T]] = { 
    if(loadedValue.isDefined) { 
    Free.pure[A, Option[T]](loadedValue) 
    } else { 
    fallback 
    } 
} 

def valueGetOperation[T](implicit Kv: KvOps[WriteThruCache], Cache: CacheOps[WriteThruCache]): ((String) => Free[WriteThruCache, Option[T]]) = { 
    (key: String) => 
    for { 
     cachedOption <- Cache.get[T](key) 
     actualValue <- withFallback[WriteThruCache, T](cachedOption, fallback = Kv.get[T](key)) 
    } yield actualValue 
} 

Если стандартная конструкция для реализации withFallback я бы рад узнать об этом.

Answer 3

Вы также можете использовать OptionT#orElse.

import cats.data.OptionT 

type KV[A] = Free[WriteThruCache, A] 

def valueGetOperation[T](
    implicit 
    Kv: KvOps[WriteThruCache], 
    Cache: CacheOps[WriteThruCache] 
): String => KV[Option[T]] = 
    key => OptionT[KV, T](Cache.get[T](key)).orElse(OptionT[KV, T](Kv.get[T](key))).value 

Или OptionT#orElseF:

def valueGetOperation[T](
    implicit 
    Kv: KvOps[WriteThruCache], 
    Cache: CacheOps[WriteThruCache] 
): String => KV[Option[T]] = 
    key => OptionT[KV, T](Cache.get[T](key)).orElseF(Kv.get[T](key)).value 

Обратите внимание, что с -Ypartial-unification флагом в Scala 2.12 вам не нужно KV типа псевдоним, и вы можете написать OptionT(...) вместо OptionT[KV, T](...).