Nebenläufigkeit und Ökosystem

import scala.concurrent.{Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration.*

def quadrat(n: Int): Future[Int] = Future { n * n }

@main def main(): Unit =
  val f = for
    a <- quadrat(3)
    b <- quadrat(4)
  yield a + b
  println(Await.result(f, 5.seconds))

  val viele = Future.sequence((1 to 5).map(quadrat))
  println(Await.result(viele, 5.seconds))

  val fehler = Future { 1 / 0 }.recover { case _: ArithmeticException => -1 }
  println(Await.result(fehler, 5.seconds))

val fib: LazyList[BigInt] = BigInt(0) #:: BigInt(1) #:: fib.zip(fib.tail).map(_ + _)

@main def main(): Unit =
  lazy val teuer = { println("berechne"); 42 }
  println("vorher")
  println(teuer)
  println(teuer)
  val s = LazyList.from(1).map(_ * 2).filter(_ % 3 == 0)
  println(s.take(4).toList)
  println((1 to 1000000).view.map(_ * 2).filter(_ % 7 == 0).take(3).toList)
  println(fib.take(12).toList)
  println(Iterator.iterate(1)(_ * 3).takeWhile(_ < 500).toList)

import scala.util.Using
import java.nio.file.{Files, Path}

@main def main(): Unit =
  val p = Files.createTempFile("scala", ".txt")
  Files.writeString(p, "eins\nzwei\ndrei\n")
  val zeilen = Using(scala.io.Source.fromFile(p.toFile))(_.getLines().toList).get
  println(zeilen)
  println(zeilen.map(_.length))
  Files.delete(p)
  println(Files.exists(p))

//> using scala 3
//> using dep com.lihaoyi::os-lib:0.10.0
@main def hallo() = println(os.pwd)