Início / user-1780261

codeaperature's questions

Martin Hope
codeaperature
Asked: 2025-04-30 01:33:49 +0800 CST
  • 6

Como um padrão corresponde ao Sucesso ou ao Falha neste método:

trait FunctionApi:
     def computeTry(funct: Try[String] => Unit): Unit = ??? // some ops

def actUponTry(functionApi: FunctionApi): String = {

     // This below could be something other than match as 
     // long as `Success` or `Failure` is apparent)

     functionApi.computeTry(...) match
     // When Try is ... (get Try + exception or value)
     // Success(value) => // Act on Success & value
                  s"Success with $value" 
     // Failure(ex) =>    // Act on Failure & ex 
                  s"Failure with exception ${ex.getString}"

}

E se FunctionApihouver outro método chamado computeTry2is computeTry2(funct: Try[Long] => Unit): Unit, esse "teste de correspondência" pode ser mais genérico?

Não use bibliotecas externas.

Talvez Como fazer a correspondência de padrões de uma função em Scala? seja útil?

Talvez haja uma maneira de usar outra característica ou método wrapper para extrair os parâmetros de Sucesso/Falha?

EDIÇÃO ADICIONAL:

O objetivo final é atribuir uma Promessa para promulgar um Futuro. (Quero fazer essa parte sozinho.) O código de chamada poderia ser assim:

val success = Success("Some String")
val succeeding = new FunctionApi:
    def computeTry(continuation: Try[String] => Unit): Unit =
        continuation(success)
val wasSuccess = actUponTry(succeeding).computeTry()

EDIÇÃO #2: Consegui fazer isso funcionar. Vou fechar este problema conforme ele evoluiu.

  def actUponTry(functionApi: FunctionBasedApi): StringBasedApi = {
    class StringBasedApiX extends StringBasedApi {
      def computeTry(): String = {
        functionApi.computeTry {
          case Success(value) => s"Success with $value"
          case Failure(ex) => s"Failure with exception ${ex.getMessage}"
        }
      }
    }
    new StringBasedApiX
  }

/**
  * Dummy example of a callback-based API
  */

trait FunctionBasedApi:
  def computeTry(funct: Try[String] => String): String

  /**
   * API similar to [[CallbackBasedApi]], but based on `String` instead
   */
trait StringBasedApi:
  def computeTry(): String

com código de teste:

  test("test matching") {
    val success = Success("Some String")
    val stringBasedApi = new FunctionBasedApi:
      def computeTry(funct: Try[String] => String): String = funct(success)
    val wasSuccess = actUponTry(stringBasedApi).computeTry()
    assertEquals(wasSuccess,  s"Success with ${success.get}")
  }

Mas descobri que a maneira como eu estava tentando fazer isso com futuros funciona de forma diferente do código acima (acima... Não consegui fazer a correspondência do padrão).

scala