Library with Shopping Basket

Step-by-Step Enhancements

case class Book(title: String, author: String, year: Int, category: String, price: Double)

class ShoppingBasket {
  private var items: List[Book] = List()

  def addBook(book: Book): Unit = {
    items = book :: items
  }

  def totalCost: Double = {
    items.map(_.price).sum
  }

  def showBasket(): Unit = {
    println("Shopping Basket:")
    items.foreach(book => println(s"${book.title} - ${book.price}"))
  }
}

object EnhancedLibraryManagement extends App {
  var library = List(
    Book("1984", "George Orwell", 1949, "Dystopian", 15.99),
    Book("To Kill a Mockingbird", "Harper Lee", 1960, "Fiction", 10.99),
    Book("The Great Gatsby", "F. Scott Fitzgerald", 1925, "Classic", 8.99),
    Book("Brave New World", "Aldous Huxley", 1932, "Dystopian", 12.99),
    Book("Moby Dick", "Herman Melville", 1851, "Classic", 9.99),
    Book("The Catcher in the Rye", "J.D. Salinger", 1951, "Fiction", 14.99)
  )

  def addBook(library: List[Book], book: Book): List[Book] = {
    book :: library
  }

  def searchBooks(library: List[Book], query: String): List[Book] = {
    library.filter(book => book.title.contains(query) || book.author.contains(query))
  }

  def filterByCategory(library: List[Book], category: String): List[Book] = {
    library.filter(_.category == category)
  }

  def totalBooks(library: List[Book]): Int = {
    library.length
  }

  def averagePublicationYear(library: List[Book]): Double = {
    if (library.isEmpty) 0.0
    else library.map(_.year).sum.toDouble / library.length
  }

  def sortBooksByTitle(library: List[Book]): List[Book] = {
    library.sortBy(_.title)
  }

  def sortBooksByYear(library: List[Book]): List[Book] = {
    library.sortBy(_.year)
  }

  def groupBooksByCategory(library: List[Book]): Map[String, List[Book]] = {
    library.groupBy(_.category)
  }

  def partitionBooksByYear(library: List[Book], year: Int): (List[Book], List[Book]) = {
    library.partition(_.year < year)
  }

  def collectTitlesAfterYear(library: List[Book], year: Int): List[String] = {
    library.collect {
      case Book(title, _, y, _, _) if y > year => title
    }
  }

  def averagePublicationYearByCategory(library: List[Book]): Map[String, Double] = {
    val groupedByCategory = library.groupBy(_.category)
    groupedByCategory.mapValues(books => books.map(_.year).sum.toDouble / books.length)
  }

  println("Initial Library:")
  library.foreach(println)

  // Add a new book
  val newBook = Book("Sapiens", "Yuval Noah Harari", 2011, "Non-Fiction", 19.99)
  library = addBook(library, newBook)

  println("\nLibrary after adding a new book:")
  library.foreach(println)

  // Search for books
  val searchQuery = "George Orwell"
  val searchResults = searchBooks(library, searchQuery)

  println(s"\nSearch results for '$searchQuery':")
  searchResults.foreach(println)

  // Filter by category
  val category = "Dystopian"
  val dystopianBooks = filterByCategory(library, category)

  println(s"\nBooks in the '$category' category:")
  dystopianBooks.foreach(println)

  // Calculate statistics
  val total = totalBooks(library)
  val averageYear = averagePublicationYear(library)

  println(s"\nTotal number of books: $total")
  println(f"Average publication year: $averageYear%.2f")

  // Sort books by title
  val sortedByTitle = sortBooksByTitle(library)
  println("\nBooks sorted by title:")
  sortedByTitle.foreach(println)

  // Sort books by year
  val sortedByYear = sortBooksByYear(library)
  println("\nBooks sorted by year:")
  sortedByYear.foreach(println)

  // Group books by category
  val groupedByCategory = groupBooksByCategory(library)
  println("\nBooks grouped by category:")
  groupedByCategory.foreach { case (category, books) =>
    println(s"$category:")
    books.foreach(println)
  }

  // Partition books by year
  val (before2000, after2000) = partitionBooksByYear(library, 2000)
  println("\nBooks published before 2000:")
  before2000.foreach(println)
  println("\nBooks published after 2000:")
  after2000.foreach(println)

  // Collect titles of books published after 1950
  val titlesAfter1950 = collectTitlesAfterYear(library, 1950)
  println("\nTitles of books published after 1950:")
  titlesAfter1950.foreach(println)

  // Calculate average publication year by category
  val avgYearByCategory = averagePublicationYearByCategory(library)
  println("\nAverage publication year by category:")
  avgYearByCategory.foreach { case (category, avgYear) =>
    println(s"$category: $avgYear%.2f")
  }

  // Shopping Basket functionality
  val basket = new ShoppingBasket()
  basket.addBook(library.head)
  basket.addBook(library(1))
  basket.addBook(library(2))
  basket.showBasket()
  println(s"Total cost: ${basket.totalCost}")
}