Perguntas[scala](coding)

Eu estava tentando anexar um Seq[String]a um vazio existenteSeq[String]

var enrichmentColumnsList: Seq[String] = Seq.empty
datasetEnricherConf.map(u => u.columnMappingsConf).foreach {
  columnMappingConf =>
    for (i <- 0 to columnMappingConf.size) {
      var cond = columnMappingConf.map(_.destColumnName)
      println(s"cond:$cond")
      enrichmentColumnsList= cond
    }
}


println(s"enrichmentColumnsList:$enrichmentColumnsList")

cond:List(NODE)
cond:List(NODE)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
enrichmentColumnsList:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)

Ele inicializa com a última ocorrência da lista.

Eu esperava algo como abaixo:

enrichmentColumnsList:List(NODE,NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)

Copiei o código do repositório telegram/bot4s, coloquei parte do código em "object Main extends App", criei o arquivo sbt e instalei as bibliotecas.

import cats.instances.future._
import cats.syntax.functor._
import com.bot4s.telegram.api.RequestHandler
import com.bot4s.telegram.api.declarative.Commands
import com.bot4s.telegram.clients.{FutureSttpClient, ScalajHttpClient}
import com.bot4s.telegram.future.{Polling, TelegramBot}
import com.bot4s.telegram.methods.SendDice

import scala.util.Try
import scala.concurrent.Future

/** Generates random values.
 */


class RandomBot(val token: String) extends TelegramBot
  with Polling
  with Commands[Future] {

  //LoggerConfig.factory = PrintLoggerFactory()
  // set log level, e.g. to TRACE
  //LoggerConfig.level = LogLevel.TRACE

  // Use sttp-based backend
  implicit val backend = SttpBackends.default
  override val client: RequestHandler[Future] = new FutureSttpClient(token)

  // Or just the scalaj-http backend
  // override val client: RequestHandler[Future] = new ScalajHttpClient(token)

  val rng = new scala.util.Random(System.currentTimeMillis())
  onCommand("coin" or "flip") { implicit msg =>
    reply(if (rng.nextBoolean()) "Head!" else "Tail!").void
  }
  onCommand("real" | "double" | "float") { implicit msg =>
    reply(rng.nextDouble().toString).void
  }
  onCommand("/die" | "roll") { implicit msg =>
    reply("⚀⚁⚂⚃⚄⚅" (rng.nextInt(6)).toString).void
  }
  onCommand("random" or "rnd") { implicit msg =>
    withArgs {
      case Seq(Int(n)) if n > 0 =>
        reply(rng.nextInt(n).toString).void
      case _ => reply("Invalid argumentヽ(ಠ_ಠ)ノ").void
    }
  }
  onCommand("choose" | "pick" | "select") { implicit msg =>
    withArgs { args =>
      replyMd(if (args.isEmpty) "No arguments provided." else args(rng.nextInt(args.size))).void
    }
  }

  onCommand("auto") { implicit msg =>
    request(SendDice(msg.chat.id)).void
  }
  // Extractor
  object Int {
    def unapply(s: String): Option[Int] = Try(s.toInt).toOption
  }
}


object Main extends App {
  val bot = new RandomBot("tokenhere")
  val eol = bot.run()
  println("Press [ENTER] to shutdown the bot, it may take a few seconds...")
  scala.io.StdIn.readLine()
  bot.shutdown() // initiate shutdown
  // Wait for the bot end-of-life
  Await.result(eol, Duration.Inf)
}

ThisBuild / version := "0.1.0-SNAPSHOT"

ThisBuild / scalaVersion := "2.13.16"

lazy val root = (project in file("."))
  .settings(
    name := "Meower"
  )

// Core with minimal dependencies, enough to spawn your first bot.
libraryDependencies += "com.bot4s" %% "telegram-core" % "5.8.4"

// Extra goodies: Webhooks, support for games, bindings for actors.
libraryDependencies += "com.bot4s" %% "telegram-akka" % "5.8.4"

mas depois disso falhei na construção com:

C:\Usuários\днс\Music\play-samples-3.0.x\Meower\src\main\scala\Main.scala:25:26 não encontrado: valor SttpBackends val implícito backend = SttpBackends.default

C:\Users\днс\Music\play-samples-3.0.x\Meower\src\main\scala\Main.scala:26:49 não foi possível encontrar o valor implícito para o parâmetro backend: sttp.client3.SttpBackend[scala.concurrent.Future,Any] Ocorreu um erro em um aplicativo envolvendo argumentos padrão. override val client: RequestHandler[Future] = new FutureSttpClient(token)

C:\Usuários\днс\Music\play-samples-3.0.x\Meower\src\main\scala\Main.scala:71:3 não encontrado: valor Await Await.result(eol, Duration.Inf)

C:\Usuários\днс\Music\play-samples-3.0.x\Meower\src\main\scala\Main.scala:71:21 não encontrado: valor Duration Await.result(eol, Duration.Inf)

O que preciso fazer para corrigir esses problemas?

Pesquisei "Não é possível encontrar SttpBackends + "Ocorreu um erro em um aplicativo envolvendo argumentos padrão." e tentei corrigir meu código, mas não obtive sucesso...

Fundo:

Eu tenho um Actor chamado Peer. Dentro da minha aplicação, a Peerrepresenta uma conexão entre o servidor que o criou e outro servidor. É essencialmente um http-client.

Quando a instância é executada pela primeira vez, o PeerManagerconsulta o banco de dados para obter a lista de entradas do servidor. Em seguida, ele cria um Peerator para esse servidor. O estado do Peerdepende de seu RegistrationStatuscampo ( PENDING_OUT , PENDING_IN , REGISTERED , ...)

A Peertem uma função de recebimento padrão que se parece com esta:

  override def receive: Receive = {
    case FirstTick =>
      system.log.info("receive FirstTick")
      timers.startTimerWithFixedDelay(TickKey, Tick, FiniteDuration(2, TimeUnit.SECONDS))
    case Tick =>
      system.log.info("receive Tick")
      // process every state until all are complete
      var statesLeft = false
      
      states = states.sortWith{ (s1, s2) => s1.order > s2.order }

      for (state <- states) {
        if (!state.complete) {
          statesLeft = true
          if (state.waitForPing) {
            context.become(pingService(state))
          } else {
            context.become(state.behavior)
          }
        }
      }

      if (!statesLeft) context.become(pingService(null))
  }

Isso basicamente permite a Peertransição por uma lista de estados, executando o comportamento de cada estado até que ele esteja completo.

Um conjunto de estados pode se parecer com isto:

    case PENDING_OUT =>
        Seq(
          new InitState(0, peer),
          new SessionHandshake(1, peer),
          new WaitMessages(2, peer)
        )

Um exemplo de um dos estados:

class WaitAccept(order: Int, peer: Peer)(implicit system: ActorSystem) extends PeerState(order, false, true) {

  override def behavior: Receive = {
    case Tick =>
      system.log.info("Waiting for accept")
      if (complete) peer.getContext.unbecome()

    case rA@RegistrationAccept(serverID, serverIP, _) =>
      system.log.info(s"Processing RegistrationAccept: ${rA.toProtoString}")
      complete = true
  }
  
}

PeerStatesuperclasse:

abstract case class PeerState(var order: Int, var complete: Boolean, var waitForPing: Boolean) {

  def behavior: Receive // <- must be overridden
  
}

Esse estado faz com que o peer fique sentado esperando por uma mensagem 'RegistrationAccept', gerada quando o usuário clica em 'Aceitar' na página da web.

O problema:

Alguns dos estados (por exemplo, Handshakeo estado que é responsável por trocar chaves de criptografia) enviam httpmensagens para o serverque o Peeré gerado para. Se a instância que recebe a mensagem encontrar um Peercom o solicitado serverID, o PeerManagerencaminhará essa mensagem para o Peerusando askassim:

case peerRequest@PeerRequest(serverID, SessionRequest(sessionRequest), _) =>
      // get the relevant peer for the requested serverID
      val peerEntry = peerMap.get(serverID)
      if (peerEntry.isDefined) {
        // ask the peer Actor for a response to the sessionRequest, block and wait for this response, then send it back to the peerManager

        val peerState = queryPeerState(peerEntry.get)    // <-- the issue

        if (peerState.isInstanceOf[SessionHandshake]) {  // <-- the issue
          try {
            sender() ! Await.result((peerEntry.get ? (self, sessionRequest)).mapTo[PeerResponse.Response], timeout.duration)
          } catch {
            case e: TimeoutException =>
              sender() ! PeerResponse.Response.StatusResponse(HydraStatusCodes.PEER_MANAGER_TIMEOUT.getStatusResponse)
          }
        } else {
          sender() ! PeerResponse.Response.StatusResponse(HydraStatusCodes.PEER_NOT_READY.getStatusResponse)
        }
      } else {
        sender() ! PeerResponse.Response.StatusResponse(HydraStatusCodes.PEER_NOT_READY.getStatusResponse)
      }

O problema ocorre quando a outra instância Peernão está no estado correto para receber a mensagem. Se isso acontecer, eu gostaria de responder com o apropriado HydraStatusCode. A abordagem mais normal para mim é de alguma forma perguntar em Peerque estado ela está antes de encaminhar a mensagem e, se estiver no estado errado, retornar o StatusCode apropriado.

No entanto, para conseguir isso, eu teria que implementar QueryStatecase em todos os lugares em que tenho Receivecomportamento. Isso parece desajeitado e bagunçado e, como um engenheiro habilidoso, não sinto que seja a maneira certa de fazer isso.

Gostaria de implementar isso de alguma forma na PeerStateclasse como comportamento padrão que sempre é chamado para um QueryState, ou de alguma forma permitir que eles PeerManagerchamem uma referência ao Peerobjeto diretamente em vez de ao ActorRef (mas sei que isso não é possível)

Existe alguma outra abordagem para isso ou a maneira mais bagunçada é provavelmente a melhor?

Quero converter a classe de caso UserDTO para a classe de caso User. Encontro a solução na conversão de classe de caso sem forma.

class SameFieldConverter[T] {
def apply[S, SR <: HList, TR <: HList, MR <: HList, IR <: HList](s: S)(implicit
  genS: LabelledGeneric.Aux[S, SR],
  genT: LabelledGeneric.Aux[T, TR],
  merger: Merger.Aux[SR, HNil, MR],
  intersection: Intersection.Aux[MR, TR, IR],
  align: Align[IR, TR]) = genT.from(intersection(merger(genS.to(s), HNil)))

mas tenho problemas com campos diferentes, por exemplo, em UserDTO tenho o nome do campo, sobrenome, mas em User tenho o nome completo.

  case class UserDTO(name:String, surname:String, age:Int){
    def toDomain:User = User(name + surname, age)
  }
  case class User(fullName:String, age:Int)

Também tenho problemas com nomes de campos diferentes, por exemplo, nome -> sobrenome

case class UserDTO(name:String, surname:String, age:Int)
case class User(firstName:String, surname:String, age:Int)

Eu penso sobre a solução como em um alias de pena ("nome", _.surname), mas tenho um cérebro pequeno. Eu também estava pensando em olhar para o uso da API de reflexão scala

Problema:

Fiquei indo e voltando na última semana ou mais tentando configurar meu cliente Scala+AKKA para poder enviar mensagens para um servidor executando o NGINX.

Continuo recebendo o erro: javax.net.ssl.SSLHandshakeException: (certificate_unknown)

Configurar:

nginxconfiguração:

server {
    listen 443 ssl default_server;
    listen [::]:443 ssl default_server;
    server_name localhost;

    ssl_certificate /home/hydra/.localhost-ssl/localhost.crt;           //<- combined certificates (server_cert + rootCA)
    ssl_certificate_key /home/hydra/.localhost-ssl/localhost-key.key;

    ssl_trusted_certificate /home/hydra/.localhost-ssl/rootCA.crt;      //<- just the rootCA

    index index.html index.htm;
    root /home/hydra/ui/;

    location / {
        try_files $uri.html $uri/index.html
        @public
        @nextjs;
        add_header Cache-Control "public, max-age=3600";
    }

    location @public {
        add_header Cache-Control "public, max-age=3600";
    }

    location /ping {
        proxy_pass http://localhost:8080;
    }

    location @nextjs {
            proxy_pass http://localhost:3000;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection 'upgrade';
            proxy_set_header Host $host;
            proxy_cache_bypass $http_upgrade;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-Proto https;
            proxy_set_header X-Forwarded-For $remote_addr;
            proxy_set_header X-Forwarded-Host $remote_addr;
    }
}

solicitação do cliente:

  private val sslContext: SSLContext = SSLManager.getClientSSLContext
  private val connectionContext = ConnectionContext.httpsClient(sslContext)

...

    val request = HttpRequest(method = HttpMethods.GET, uri = s"https://${server.serverIP}/ping")
    http.singleRequest(request, connectionContext).pipeTo(self)

createClientContext:

  def getClientSSLContext: SSLContext = {
    val keyStore = KeyStore.getInstance("JKS")
    keyStore.load(null, null) // Create an empty keystore
    keyStore.setCertificateEntry("rootCA", loadRootCertificate())

    // Set up a TrustManager that trusts the root CA certificate
    val trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm)
    trustManagerFactory.init(keyStore)
    val trustManagers = trustManagerFactory.getTrustManagers

    // Create an SSLContext with the custom TrustManager
    val sslContext = SSLContext.getInstance("TLS")
    sslContext.init(null, trustManagers, new SecureRandom())
    sslContext
  }

Escrevendo rootCApara arquivo:

    val rootCA = new StringBuilder()
    rootCA.append("-----BEGIN CERTIFICATE-----\n")
    rootCA.append(Base64.getEncoder.encodeToString(rootCACertificate.getEncoded))
    rootCA.append("\n-----END CERTIFICATE-----")
    writeFile(ROOT_CA_PATH, Seq(rootCA.toString))

Como crio o certificado do servidor assinado:

def createCSR(keyPair: KeyPair, subject: String, keyAlgorithm: String): PKCS10CertificationRequest = {
    val csrGen = new PKCS10CertificationRequestBuilder(new X500Name(subject), SubjectPublicKeyInfo.getInstance(keyPair.getPublic.getEncoded))
    val signer = new JcaContentSignerBuilder("SHA256with" + keyAlgorithm).build(keyPair.getPrivate)
    csrGen.build(signer)
  }

  // Sign the CSR with the root CA's private key to generate a certificate
  def signCertificate(csr: PKCS10CertificationRequest, rootCACertificate: X509Certificate, rootCAPrivateKey: PrivateKey): X509Certificate = {
    val notBefore = new Date()
    val notAfter = new Date(notBefore.getTime + 36500L * 24 * 60 * 60 * 1000) // Valid for 1 year

    val certGen = new X509v3CertificateBuilder(
      new X500Name("CN=Hydra SSL Certificate"),
      new BigInteger(128, new Random()),
      notBefore,
      notAfter,
      csr.getSubject,
      csr.getSubjectPublicKeyInfo
    )

    // Add SubjectAlternativeName (SAN) extension
    val sanNames = Array[GeneralName](
      new GeneralName(GeneralName.iPAddress, SERVER_IP)
    )

    val generalNames = new GeneralNames(sanNames)
    certGen.addExtension(Extension.subjectAlternativeName, false, generalNames)

    // Sign with root CA's private key
    val signer = new JcaContentSignerBuilder("SHA256withRSA").build(rootCAPrivateKey)
    val certificateHolder: X509CertificateHolder = certGen.build(signer)

    // Convert to a JCE certificate
    val converter = new JcaX509CertificateConverter().setProvider("BC")
    converter.getCertificate(certificateHolder)
  }

...

    // Step 1: Load Root CA certificate and private key
    val rootCACertificate = loadRootCertificate()
    val rootCAPrivateKey = loadRootPrivateKey()

    // Step 2: Generate new key pair for SSL certificate
    val keyPair = generateKey("RSA")

    // Step 3: Create CSR (Certificate Signing Request)
    val csr = createCSR(keyPair, s"CN=hydra_server_$SERVER_ID, O=Hydra, C=UK", "RSA")

    // Step 4: Sign the CSR with the Root CA to generate the SSL certificate
    val sslCertificate = signCertificate(csr, rootCACertificate, rootCAPrivateKey)

O que eu tentei:

Após consultar chatGPT, tentei o comandoopenssl s_client -connect 192.168.0.4:443 -showcerts

A saída deste comando pode ser encontrada aqui .

Isso me ajudou a verificar se, nginxde fato, estava enviando toda a cadeia, na ordem correta (pode ser confirmado pela data - o rootCA(certificado 1 na saída) foi gerado em 02/07/2025, o certificado do servidor (certificado 0) foi gerado hoje.

Então o que estou fazendo errado/perdendo na minha configuração?

Tenho o seguinte CSV que é publicado por um terceiro com os valores para uma coluna específica contendo uma vírgula (por algum motivo inexplicável). Os valores para a coluna estão ausentes ou entre colchetes/aspas duplas, pois representam um intervalo.

A seguir está um desses registros do CSV:

A,B
xxxxxxxxx,"['05-01', '06-30']"
yyyyyyyyy,"['04-01', '04-30']"
zzzzzzzzz,

O culpado é a segunda coluna, como é óbvio. Existe uma maneira de analisar corretamente esse CSV no Apache Spark (Scala) para ter o seguinte dataframe:

+---+----------+------------------------+
|A             |B                       |
+---+-----------------------------------+
|xxxxxxxxx     |"['05-01', '06-30']"    |
|yyyyyyyyy     |"['04-01', '04-30']"    |
|zzzzzzzzz     |null                    |
+---+----------+------------------------+

Tenho uma classe que é um Ator:

class Client(server: Server, systemActor: ActorRef) extends Actor {
...
}

Tenho uma lista que gerencia clientes conectados. O ator que gera os atores clientes observa uma lista de "servidores" no banco de dados e gera uma conexão de cliente para cada um, assim:

private val clientList = mutable.ArrayBuffer.empty[Client]

class RegistrationWatcherActor(val systemActor: ActorSystem) extends Actor with Timers {

  implicit val system: ActorSystem = context.system

  timers.startSingleTimer(TickKey, FirstTick, FiniteDuration(1, TimeUnit.SECONDS)) // wait 10 seconds to give database time to initiate

  private def checkRegistrations(): Unit = {
    val database = DatabaseUtil.getInstance
    val serversOutgoing: Seq[Server] = database.getAll[Server](classOf[Server])

    for (server <- serversOutgoing) {
      val client = clientList.find{ client => client.server == server }
      if (client.isEmpty) { // client for this server was not found, so create one
        
      }
    }
  }

  def receive: Receive = {
    case FirstTick =>
      timers.startTimerWithFixedDelay(TickKey, Tick, FiniteDuration(1, TimeUnit.SECONDS))
    case Tick =>
      checkRegistrations()
  }
}

O Problema

Na verificação, if (client.isEmpty)gostaria de criar uma instância de Client, gerá-la como um ator e colocar a referência na lista para que ela não seja criada novamente. Como você pode ver, meu método de identificar se o cliente foi criado ou não é verificar se ele está serverIDarmazenado no banco de dados.

O ideal é fazer:

val client = new Client(server, systemActor)
systemActor.actorOf(Props(client), server.serverID)
clientList.append(client)

Alguma sugestão, por favor?

Alternativa

Percebi que posso fazer clientListuma lista de Stringe armazenar o serverIDaqui. No entanto, eventualmente gostaria que o RegistrationWatcherpudesse ter controle sobre aspectos do cliente, então uma referência ao Clientobjeto seria preferível.

Estou escrevendo testes de integração de código skunk com postgres usando scala-test-containers , munit e munit-cats-effect , usando Mill e Scala 3. Sou novo no Cats Effect .

A configuração que estou tentando alcançar é:

• O conjunto de testes inicia o contêiner postgres e cria a sessão skunk uma vez para todo o conjunto (e interrompe o contêiner quando o conjunto é concluído).
• Cada teste ocorre dentro de sua própria transação de banco de dados skunk que é revertida para manter os testes isolados.

Abaixo está o código até agora, com o qual o compilador está ok, exceto pela chamada para rollback, que requer um skunk.util.Origin. Não vejo nenhuma referência a esse tipo na documentação do skunk e não consigo descobrir como devo trazê-lo para o escopo.

Como posso fazer a chamada para rollbackcompilar neste código? Onde está o Origin implícito ausente?

import cats.effect.IO
import munit.CatsEffectSuite
import org.testcontainers.utility.DockerImageName
import cats.effect.kernel.Resource
import skunk.*
import skunk.implicits.*
import natchez.Trace.Implicits.noop
import munit.catseffect.IOFixture
import cats.implicits.catsSyntaxFlatMapOps

val container: Resource[IO, PostgreSQLContainer] =
  Resource.make
    (for {
      c <- IO(PostgreSQLContainer(
        DockerImageName.parse("postgres:17-alpine")
      ))
      _ <- IO.blocking(c.start())
    } yield c)
    (c => IO.blocking(c.stop()))

val sessionResource: Resource[IO, Session[IO]] =
  container.flatMap { c =>
    Session.single[IO](
      host = "localhost",
      port = 5432,
      user = c.username,
      password = Some(c.password),
      database = c.databaseName
    )
  }

def useWithRollback[T](s: Session[IO])(f: Transaction[IO] => IO[T]) =
  s.transaction.use { xa =>
    for {
      result <- f(xa)
      _ <- xa.rollback()  // fails compilation: needs implicit skunk.util.Origin
    } yield result
  }

class PgIntegrationTests extends CatsEffectSuite:

  val session = ResourceSuiteLocalFixture(
    "skunk session",
    sessionResource
  )

  override def munitFixtures = List(session)

  def withDb[T](f: Transaction[IO] => IO[T]) =
    useWithRollback(session())(f)

A ideia é que um teste seria algo como

  test("something") {
    withDb { xa =>
      for {
        result <- callMyCode(xa)
        _ <- assertIO(result, <expected result>)
      } yield ()
    }
  }

A compilação acima falha, useWithRollbackcom

[error] 41 |      _ <- xa.rollback()
[error]    |           ^^^^^^^^^^^
[error]    |           None of the overloaded alternatives of method rollback in trait Transaction with types
[error]    |            (implicit o: skunk.util.Origin): cats.effect.IO[skunk.data.Completion]
[error]    |            (savepoint: xa.Savepoint)(implicit o: skunk.util.Origin): cats.effect.IO[skunk.data.Completion]
[error]    |           match arguments ()

do qual eu deduzo que ele está procurando por um Originno escopo. Como posso trazer isso Originpara o escopo? Por que a página skunk Transaction (linkada acima) não tem esse problema onde ele chama rollbackem seu exemplo?

Obrigado pelo seu tempo.

PS: O arquivo de construção do Mill build.sc:

import mill._, scalalib._

object devmap extends ScalaModule {
  def scalaVersion = "3.5.1"
  def ivyDeps = Agg(
    ivy"org.tpolecat::skunk-core:0.6.4",
    ivy"org.typelevel::cats-effect:3.5.7"
  )

  object test extends ScalaTests with TestModule.Munit {
    def ivyDeps = Agg(
      ivy"org.scalameta::munit::0.7.29",
      ivy"org.typelevel::munit-cats-effect:2.0.0",
      ivy"com.dimafeng::testcontainers-scala-postgresql:0.41.5",
      ivy"org.postgresql:postgresql:42.7.4",
      ivy"com.lihaoyi::pprint:0.9.0"
    )
  }
}

Certo, então eu estava tentando aprender Scala em um livro didático, mas ele foi escrito antes do Scala 3 ser lançado, então grande parte do código de exemplo não compila.

Veja como o livro apresenta argumentos de linha de comando:

println(args(0).toDouble+args(1).toDouble)

e minha melhor tentativa de converter isso em algo compatível com Scala 3:

@main def main(args: Array[String]) = {  
  println(args(0).toDouble+args(1).toDouble)
}

e aqui está o que o compilador me diz:

[error] ./add.scala:1:1
[error] No given instance of type scala.util.CommandLineParser.FromString[Array[String]] was found for parameter fs of method parseArgument in object CommandLineParser
[error] @main def main(args: Array[String]) = {
[error] ^

Como eu conserto isso? Há outra pergunta como essa já postada, mas as respostas parecem estar todas escritas em versões anteriores do Scala. Quanto ao guia de lançamento oficial, ele recomenda usar algo a ver com CLP, o que eu não entendo.

Digamos que eu tenha um futuro definido da seguinte forma

val fut = Future {
  println("Doing some work")
  Thread.sleep(5000)
  println("Work done")
}

Estou acessando este futuro mais tarde, mas gostaria que ele fosse executado na inicialização em vez de quando eu referenciasse o futuro.

Li em algum lugar que isso pode ser executado imediatamente fazendo:

scala.concurrent.ExecutionContext.Implicits.global.execute(fut)

No entanto, isso não será compilado, pois execute só pega um Runnable. Existe uma maneira de executar esse future imediatamente em um thread diferente?