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))

25
Vector(1, 4, 9, 16, 25)
-1

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)

vorher
berechne
42
42
List(6, 12, 18, 24)
List(14, 28, 42)
List(0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89)
List(1, 3, 9, 27, 81, 243)

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))

List(eins, zwei, drei)
List(4, 4, 4)
false

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