Baeldung/scala-tutorials

This repository is a comprehensive collection of Scala tutorial examples and reference implementations, covering core language features, functional programming patterns, and various ecosystem libraries. It provides concrete code samples for building applications using frameworks like Play, Akka, and Lagom, alongside utilities for data processing, persistence, and testing. The system serves as an educational resource demonstrating idiomatic Scala practices across Scala 2 and Scala 3, including build tooling with SBT and integration with external services.

53 changes.

The project focused on migrating core build infrastructure and Play Framework modules to Scala 3 while standardizing automated maintenance workflows. This period saw the addition of extensive code samples covering modern Scala libraries, Akka, ZIO, Cats Effect, and various design patterns, alongside comprehensive test coverage for these new examples.

37 changes.

This period focused on migrating core tutorial modules to Scala 3 and expanding the library with comprehensive examples for language features, collections, and functional programming patterns. It also introduced new educational content for Akka, Spark, Play, and GraalVM, accompanied by extensive unit and integration tests to ensure code correctness.

56 changes.

This period focused on expanding the repository with comprehensive examples for Scala 3 language features, such as match types, opaque types, and inline macros. It also introduced extensive demonstration code for popular libraries including ZIO, Tapir, Cats, and various persistence tools, alongside significant additions to core string and number utility modules.

This location introduces a Play Framework application demonstrating Scala templating features. It includes controllers for rendering static content (article lists) and dynamic menus with price formatting, as well as a comprehensive form handling module supporting simple inputs, multi-field forms, constraint validation, and custom field formatters. The view layer provides Scala HTML templates for these components, wired together via standard Play routes and configuration files.

play-scala/play-templates · high confidence

This location introduces a complete Play Framework application for tracking flight arrivals, featuring an \ArrivalController\ that exposes an \/arrivals\ endpoint, a service layer with an \ArrivalDecoratorService\ that classifies planes by name length, and repository implementations for both H2 (in-memory) and PostgreSQL via Slick. The project includes Guice dependency injection modules to wire these components, configuration files for H2 and PostgreSQL environments, and database evolutions. It also provides a comprehensive test suite: unit tests for the \SourceAction\ filter and \ArrivalDecoratorService\, isolated unit tests using in-memory mocks, H2-based integration tests, and manual PostgreSQL integration tests, alongside a Docker Compose setup for the PostgreSQL service.

play-scala/application-tests · high confidence

This change introduces a new Scalafix setup for the scala-sbt/scalafix module, including a \.scalafix.conf\ file that enables the \DisableSyntax\ and \RemoveUnused\ rules (specifically prohibiting vars, throws, and nulls). It also adds the necessary build infrastructure (\project/build.properties\ with sbt 1.12.8 and \project/plugins.sbt\ with sbt-scalafix 0.12.1) and provides two Scala source files (\DisableSyntaxDemo.scala\ and \RemoveUnusedDemo.scala\) that demonstrate code patterns before and after applying these linting rules.

scala-sbt/scalafix · high confidence

The project now includes a Scala example demonstrating the WartRemover static analysis tool, upgraded to sbt 1.8.3. It features a custom 'BaeldungWart' that flags string literals containing 'Baeldung' and shows how to suppress warnings using annotations for both built-in and custom rules.

scala-sbt/wart-remover · high confidence

This change introduces the configuration files required for custom error handling in the Play Framework application. The \application.conf\ file registers a custom error handler (\errors.CustomErrorHandler\), while \logback.xml\ configures logging with colored console output and file appenders. Additionally, the \routes\ file defines endpoints for demonstrating various error scenarios, including no error, exceptions, internal errors, not found, and bad request.

play-scala/custom-error-handling/conf · high confidence

A new AcronymGenerator object has been introduced in the scala-strings module, providing an acronymUsingSplit method that extracts the first letter of each word from a given text, filters out non-letters and empty strings, and returns the result as an uppercase string.

scala-strings/src/main/scala/com/baeldung/scala/strings/acronym · high confidence

This update introduces new Scala code demonstrating Akka Streams error recovery and Akka Typed actor supervision. The \scala-akka-3/src\ area now includes \Main.scala\ and \package.scala\ in the \errors\ package, which implement \RestartSource\ with backoff settings and a \parseWithRecover\ flow that handles parsing exceptions by returning \Either\ types. Additionally, \AkkaTyped.scala\ demonstrates typed actor behavior with \SupervisorStrategy.restart\ for handling \IllegalStateException\s. These changes are accompanied by corresponding unit tests in \ErrorRecoveryUnitTest.scala\ and \StreamUnitTest.scala\ to verify the new error handling and stream processing logic.

scala-akka-3/src · high confidence

This change introduces the foundational configuration for Akka gRPC and Event Sourcing within the scala-akka-2 module. It adds a Protobuf definition (\akka.proto\) specifying the \MessageExchangeService\ with RPCs for sending messages and streaming, alongside an \application.conf\ file that configures the gRPC client to connect to localhost:8080, enables HTTP/2 on the server, and sets up in-memory journaling and local snapshot storage for Akka Persistence.

scala-akka-2/src/main/resources · high confidence

New Ammonite script examples have been added to demonstrate core scripting features, including argument parsing, constants, file system operations via ammonite-ops, and variable arguments. The location also includes a README linking to relevant articles on Ammonite scripting and file operations.

ammonite · high confidence

The application now includes GraalVM native-image configuration files (jni-config, reflect-config, resource-config, etc.) and a Scala entry point (Main.scala) that sets up an Akka HTTP server on port 9000. This enables the application to be compiled into a native executable, improving startup time and reducing memory footprint for deployment.

scala-graalvm/scala-graalvm-http-app · high confidence

This location introduces a complete Guice dependency injection setup for the Play Scala application. It includes a \LoggingFilter\ that records request URIs, execution times, and adds a \Request-Time\ header to responses, along with a \UserController\ that logs user retrieval actions. The example also demonstrates service binding and named injection through \UserModule\ and \OrderModule\, wiring \UserService\ and distinct \OrderValidationService\ implementations (Business and Enterprise) into \OrderService\, which utilizes a sequence of \OrderPipelineProcessor\ functions for order processing.

play-scala/dependency-injection/app/guice · high confidence

New model classes for Order and User have been introduced in the application, each equipped with implicit JSON writes to enable automatic serialization. The Order model includes fields for ID, user ID, date, and enterprise status, while the User model contains ID and name, ensuring both can be easily converted to JSON format for API responses.

play-scala/dependency-injection/app/models · high confidence

This change introduces a new Scala module demonstrating the NscalaTime library. It includes a main source file (\NscalaTime.scala\) showcasing DateTime creation, JDK interoperability, querying, field access, manipulation, and formatting, along with a corresponding unit test file (\NscalaTimeUnitTest.scala\) that verifies the types of the generated objects.

scala-libraries-standalone/nscalatime · high confidence

A new Person class has been added to the scala-core-9 module, demonstrating a basic Scala class with a constructor parameter and a custom toString implementation. This serves as companion code for the related article.

scala-core-modules/scala-core-9/src/main/scala/com/baeldung/scala/classT · high confidence

The play-scala/introduction-to-play module now includes a functional example application demonstrating the Play Framework in Scala. This adds a HomeController with endpoints for a welcome page and a number-summing utility, along with the corresponding Scala HTML templates (main, firstexample, index) and static assets (CSS/JS) to render the UI.

play-scala/introduction-to-play · high confidence

This location introduces a new Play Framework application demonstrating how to schedule asynchronous tasks. It includes an Akka actor (\AsyncTaskInActor\) for processing messages, a Guice module (\ActorsModule\) to bind the actor, and a controller (\AsyncTaskController\) that exposes a \/async\ endpoint. The controller illustrates scheduling patterns using \scheduleOnce\ for delayed execution and \scheduleAtFixedRate\ for recurring tasks, along with immediate actor messaging.

play-scala/async-tasks · high confidence

This location introduces a new Play Scala application demonstrating how to read configuration settings from application.conf. It includes a service layer that retrieves player details (name, email, age, signup date, and optional Twitter handle) using both individual key lookups and a custom ConfigLoader for complex types like Date, alongside the corresponding controller, view, and route definitions to display this data.

play-scala/configuration-access · high confidence

This location introduces a complete sample application demonstrating how to serve and compile static assets in a Play Scala project. It includes a controller and routes for serving an index page and a greeting endpoint, alongside source files for CoffeeScript, TypeScript, SCSS, and LESS that are compiled into JavaScript and CSS. The entry also provides the necessary build configuration (SBT plugins for asset compilation), TypeScript configuration, and unit tests to verify the controller behavior and asset rendering.

play-scala/caching-in-play, play-scala/play-static-assets · high confidence

This change introduces a new Scala example demonstrating the Refined library for type-level validation. The main source file provides code snippets showing how to apply refined types to integers, characters, strings, and collections, as well as how to define custom validators for case classes. A corresponding unit test file verifies these validation behaviors, ensuring that refined types correctly enforce predicates and return appropriate success or failure results.

scala-libraries-standalone/refined · high confidence

New example source files have been added to the scala-akka-2 module, providing reference implementations for several Akka capabilities. These include an HTTP server for movie management, a Service-Actor discovery pattern using the Receptionist, a gRPC message exchange service (client, server, and implementation), an Event Sourced Bank Account, a Server-Sent Events consumer for Wikimedia streams, and demonstrations of actor message forwarding and HTTP query parameter handling.

scala-akka-2/src/main/scala-2 · high confidence

This change introduces a new collection of Scala 2 library examples within the \scala-2-libraries\ module. It includes a Finch-based REST API demonstrating both simple endpoints and a full CRUD service backed by SQLite and Cats Effect, as well as Kafka producers and consumers supporting Avro and JSON serialization with schema registry integration. Additionally, it adds examples for Apache Pulsar (using pulsar4s) for synchronous and asynchronous message handling, and a comprehensive set of caching demonstrations using ScalaCache with Guava, Caffeine, and Cats Effect backends, alongside utilities for enumerations and optics.

scala-2-modules/scala2-libraries · high confidence

Added new Scala 2 source files and unit tests demonstrating the use of the Scala Reflection API. The changes include a \Person\ case class and its interface, alongside tests that show how to instantiate classes, invoke methods, access private fields, and use reification at runtime using \scala.reflect.runtime.universe\.

reflection · high confidence

The scala2-core module now includes a comprehensive set of tutorial examples demonstrating core Scala 2 concepts. This addition covers argument parsing using libraries like Args4J, Clist, Scallop, and Scopt, as well as manual parsing with pattern matching. It also introduces examples for type bounds (context, view, and implicit conversions), idiomatic exception handling using Option, Try, Either, and Cats Validated, and basic language features like control structures, classes, and macros.

scala-2-modules/scala2-core · high confidence

The scala-libraries-2 module now includes a set of Scala 3 code examples demonstrating the Chimney library for data transformation. These examples cover codecs, isomorphisms, partial transformers, patching, and automatic case class transformations, providing users with reference implementations for mapping between domain and DTO models using the Chimney DSL.

scala-libraries-2 · high confidence

A new \PowerMacro\ implementation has been added to the Scala 3 core modules, introducing a compile-time macro that unrolls power computations. This allows the \showAsPowerTerm\ function to generate optimized code for integer powers at compile time, provided the exponent is a known constant.

scala-core-modules/scala-core-9/src/main/scala/com/baeldung/scala/tastyfiles · high confidence

The scala-core module now includes a new Scala 3 source directory (scala-3) containing examples for multiple pattern matches and union type patterns. Additionally, the main scala source directory has been populated with new sample files demonstrating for-loops, higher-order functions, lazy vals, partial functions, comprehensive pattern matching techniques (including string interpolation and extractors), sealed classes for algebraic data types, and trait composition.

scala-core-modules/scala-core/src/main · high confidence

Introduced a new example file demonstrating how to define single-line and multi-line strings using triple quotes and stripMargin in Scala 3. The examples also cover string concatenation via the concat method and the + operator, as well as string interpolation using s-, f-, and raw- interpolators for formatting variables and literals.

scala-strings/src/main/scala/com/baeldung/scala/strings/definition · high confidence

The scala-lang-2 module now includes new Scala 3 code examples and corresponding unit tests covering inheritance patterns (single, multiple, hierarchical, multilevel, and hybrid), type lambdas, singleton objects, void types (Unit, Null, Nothing, Option, List), and trait composition. These additions provide learners with concrete, test-backed demonstrations of these core Scala concepts.

scala-lang-modules/scala-lang-2 · high confidence

This update adds a comprehensive set of Scala 3 code examples and corresponding unit tests to the \scala-lang-3\ module. The new content covers key language features including enums, extension methods, given/using (replacing Scala 2 implicits), intersection and union types, opaque type aliases, inline definitions, main methods, and multiversal equality. The tests verify the correct behavior of these features, such as type-safe conversions, extension method application, and compile-time checks.

scala-lang-modules/scala-lang-3 · high confidence

New Scala 3 source files have been added to the \scala-test/src/main\ directory to serve as code samples. These include a Currency DSL implementation with type-safe currency amounts, a simple BankAccount class for Behavior-Driven Development (BDD) examples, and a set of models and services (InventoryService, InventoryTransactionDao) demonstrating how to use Mockito with ScalaTest for mocking dependencies like Kafka producers and DAOs.

scala-test/src/main · high confidence

The scala-lang module now includes a comprehensive set of new Scala 3 code examples and corresponding unit tests covering core language features. These additions demonstrate call-by-value and call-by-name parameter evaluation, conditional expressions, equality and case class semantics, function and method definitions (including extension methods and tail recursion), variable mutability, operator usage, package import and stacking mechanisms, and the type hierarchy. The new test suite validates these concepts using ScalaTest and JUnit.

scala-lang-modules/scala-lang · high confidence

Introduced a new Scala Native module demonstrating native application development, including a main application entry point that prints messages, performs string concatenation and length checks using Scala Native's unsafe APIs, and interfaces with external C libraries (specifically curl) via extern declarations and linking.

scala-native · high confidence

Added a new \scala-sbt/app-packaging\ module containing example Scala applications and their build configurations. This includes a standard sbt-based app (\Main.scala\) and a Scala CLI-based app (\ScalaCliApp.scala\), along with the necessary \sbt-assembly\, \sbt-native-packager\, and \sbt-proguard\ plugin definitions to demonstrate different packaging strategies for Scala applications.

scala-sbt/app-packaging · high confidence

A new benchmark module has been introduced to demonstrate the performance implications of Scala's @specialized type annotation. The implementation includes JMH benchmarks comparing generic classes with and without specialization, specifically testing scenarios where all types are specialized versus only specific primitive types (Int, Boolean) are specialized.

specialized-benchmark · high confidence

A new Scala source file has been added to the documentation module, providing code examples that demonstrate the use of context functions (using clauses), opaque types, and extension methods. The included examples illustrate how to summon implicit values from the scope, pass them explicitly, and utilize the \also\ extension method for side-effecting operations on values.

scala-lang-modules/scala-lang-5 · high confidence

The scala-design-patterns module now includes source code demonstrating two specific Scala design patterns. The Cake Pattern is implemented in CakePattern.scala, showcasing trait-based dependency injection with components for test environments, execution, and logging. The Magnet Pattern is implemented in MagnetPattern.scala, demonstrating how to use implicit conversions and type projections to handle overloaded methods with different argument types (such as List\[Int\] and List\[String\]) that would otherwise cause compiler erasure errors.

scala-design-patterns/src/main · high confidence

New Scala source files and unit tests have been added to the repository, providing a basic 'Hello World' application and a REST service example using http4s. The basic project includes a unit test verifying the greeting message, while the REST project defines a simple route returning a 'Hello, World!' response.

scala-with-maven/hello-world · high confidence

The tutorial module now includes a new \Notifications.scala\ file demonstrating Scala pattern matching and destructuring techniques. It defines a \Notification\ trait with \Email\ and \SMS\ case classes, along with a generic \Processed\ wrapper and specific processing functions to illustrate how to destructure and handle different notification types.

scala-core-modules/scala-core-9/src/main/scala/com/baeldung/scala/destructuring · high confidence

This location introduces a new set of examples and tests for Scala testing libraries. It includes a \SimpleS3Uploader\ utility and corresponding integration tests using TestContainers (LocalStack) to demonstrate S3 interactions. Additionally, it adds unit test suites for MUnit, uTest (covering async, retry, and nested tests), ScalaCheck (generators, properties, and command-based testing), and ScalaMock (mocking styles, argument matching, and function mocking).

scala-libraries-testing · high confidence

A new ScalaPy sample has been added to demonstrate interoperability between Scala and Python, including calling Python's len() on a list and accessing dictionary values, with a local block used to manage memory and avoid garbage collection warnings.

scala-python · high confidence

The scalatra module now includes a complete tutorial application demonstrating core Scalatra capabilities. This includes servlets for basic HTTP authentication (using a custom BasicAuth strategy), database operations via Slick and H2 (with schema creation and user management endpoints), and Twirl-based HTML views. The application is configured with separate development and production bootstrap classes, standard logging via Logback, and a C3P0 connection pool, along with unit tests for the main servlet.

scalatra/src · high confidence

This change introduces a complete example application for managing kitten records using the Tapir library. It defines REST endpoints for CRUD operations (GET, POST, PUT, DELETE) on kitten resources in the endpoint module, implements the server logic using Akka HTTP in the server module (including Swagger documentation generation), and provides synchronous client examples in the client module to demonstrate how to interact with the API.

scala-libraries-standalone/tapir/client, scala-libraries-standalone/tapir/endpoint, scala-libraries-standalone/tapir/server · high confidence

A new Scala object, TwosComplement, has been introduced in the scala-core-9 module to calculate the two's complement of a binary string. It provides two public methods, convertWithFold and convertUsingRecursion, which implement the conversion logic using functional folding and tail-recursive approaches respectively, allowing users to easily compute two's complement representations.

scala-core-modules/scala-core-9/src/main/scala/com/baeldung/scala/twoscomplement · high confidence

A new Scala object, UniformCaseChecker, has been introduced in the scala-core-9 module to provide multiple approaches for determining if a string consists entirely of uppercase or entirely of lowercase letters. The utility exposes four distinct methods—convertAndCheck, isUpperLowerAndForAll, regexCheck, and countAndCheck—allowing users to verify case uniformity using different implementation strategies such as string comparison, character filtering with forall, regular expressions, or character counting.

scala-core-modules/scala-core-9/src/main/scala/com/baeldung/scala/uniformcase · high confidence

This change introduces new source files and tests demonstrating ZIO logging and zio-json usage. The logging examples provide configurable layers for console, file, and SLF4J output, along with a metrics logger that publishes to Prometheus. The JSON examples demonstrate encoding and decoding of case classes and algebraic data types (ADTs), including the use of discriminators for ADT serialization. Tests verify the correct behavior of these logging levels and JSON serialization/deserialization processes.

zio-2/src · high confidence

A new \StringWrapper\ object has been introduced in the \camelcase\ package, providing an implicit \toCamelCase\ method for strings. This feature allows users to convert space- or underscore-separated strings into camelCase format using two underlying implementation strategies: a map-reduce approach and a stream-based approach.

scala-strings/src/main/scala/com/baeldung/scala/strings/camelcase · high confidence

This change introduces a new \CustomErrorHandler\ that intercepts HTTP errors, redirecting 404 Not Found responses to a demo home page and displaying a generic message for other client errors, while also catching server exceptions to return a standardized internal server error response. It also adds an \ErrorDemoController\ with endpoints to simulate various error states (such as throwing runtime exceptions or returning specific HTTP status codes) for testing the new error handling logic.

play-scala/custom-error-handling · high confidence

A new example demonstrating how to define a custom string interpolator in Scala has been added to the interpolation module. The \CustomInterpolatorObj\ file introduces an implicit class that extends \StringContext\, allowing users to create a \custom\ interpolator that converts the resulting string to uppercase.

scala-strings/src/main/scala/com/baeldung/scala/strings/interpolation · high confidence

This change introduces a new set of Scala source files and a configuration file to the \scala-core-dates\ module. It adds a \DateParser\ for parsing date strings using simple split or regex methods, and a \DateListGenerator\ offering multiple functional approaches (recursive, fold, iterator, tabulate) to generate lists of dates. It also includes examples for working with Java's \LocalDate\ and \SimpleDateFormat\ (including thread-safe usage in futures), Joda-Time, and NScalaTime for date parsing and period measurement. Additionally, it provides utilities for calculating differences between dates using \ChronoUnit\ and \Period\, and for converting Java durations to Scala finite durations, supported by a new \application.conf\ defining a timeout value.

scala-core-modules/scala-core-dates/src/main · high confidence

This update introduces a new educational module in scala-core-10 that illustrates the behavioral differences between using \val\ and \def\ within Scala traits. The included source code and unit tests demonstrate how \val\ fields are evaluated at instantiation (resulting in consistent values like a cached timestamp), whereas \def\ methods are evaluated on each call (resulting in dynamic values like a fresh timestamp). It also covers trait linearization and initialization order, showing how the order of mixing in traits affects the final computed result.

scala-core-modules/scala-core-10 · high confidence

The scala-strings module now includes two new demonstration files. ByteArrayToString.scala provides code samples for converting byte arrays to strings using different methods (toString, new String, map/toChar) and character sets (UTF-8, UTF-16LE). KeywordCounter.scala demonstrates how to fetch text from a URL, split it into words, and use parallel collections to count keyword occurrences in a large text file.

scala-strings/src/main/scala/com/baeldung/scala/strings/bytes · high confidence

The scala-core-io module now includes a new FileDeletion utility object providing two methods for removing files and directories: deleteRecursively using the legacy java.io.File API and deleteNio using the java.nio.file API with a SimpleFileVisitor. Corresponding unit tests verify that both approaches correctly remove a directory tree and its contents. Additionally, new tests for scala.io.Source demonstrate eager string conversion, line-by-line processing, and handling of infinite streams.

scala-core-modules/scala-core-io · high confidence

The scala-libraries-fp module now includes a comprehensive set of Scala source files demonstrating functional programming patterns and library usage. This adds examples for Cats (including Area calculations, Semigroups, Monoids, Show instances, and data validation with Validated), Spire (covering Numeric, Integral, Fractional types, algebraic groups, monoids, and macro-based syntax), and Scalaz (demonstrating lenses, custom type classes, and enums). Additionally, the module introduces http4s examples for building a simple client and server, and fs2 examples for stream processing and asynchronous operations.

scala-libraries-fp/src/main · high confidence

An internal Scala script (ClassRenamer.scala) has been added to automate the renaming of test files and their corresponding class names to follow a unified standard. The tool walks the source tree, identifies test files ending in Test.scala, Spec.scala, Tests.scala, or Suite.scala, and renames them to UnitTest.scala. It also updates the class name inside the file to match the new filename, significantly reducing manual effort for developers maintaining naming consistency.

internal-scripts · high confidence

A new 'Introduction to SBT' project has been added to the repository, providing a starter example for users learning the build tool. The project is configured with sbt version 1.12.8 and includes a basic Scala application structure with a 'Hello' object and associated unit tests using ScalaTest 3.2.11.

scala-sbt/intro-to-sbt · high confidence

A new \IsomorphicStringsChecker\ object has been added to the Scala core modules, providing methods to determine if two strings are isomorphic. The implementation offers two approaches: one using distinct count comparisons and another using grouped maps, both verifying the mapping relationship in both directions.

scala-core-modules/scala-core-9/src/main/scala/com/baeldung/scala/isomorphic · high confidence

The scala-libraries-os module now includes example code demonstrating how to execute OS commands and read files using the os-lib library (OsApp.scala) and the standard scala.sys.process API (ScalaSysApp.scala). A log4j2 configuration file has also been added to support logging in these examples.

scala-libraries-os · high confidence

A new Palindrome object has been added to the Scala core modules, providing three methods to determine if a string is a palindrome: checking by reversing the string, using tail-recursive comparison, and using forall with index mapping. All methods first sanitize the input by removing non-alphanumeric characters and converting to lowercase.

scala-core-modules/scala-core-9/src/main/scala/com/baeldung/scala/palindrome · high confidence

The scala-libraries module now includes sample implementations for several libraries. CSV reading and writing are demonstrated using Apache Commons CSV, OpenCSV, ScalaCSV, and a simple custom reader/writer. JSON handling is shown via Circe conversions. Database interactions are illustrated with a Slick configuration for PostgreSQL and a Play Framework database example. Additionally, Elasticsearch operations are demonstrated using Elastic4s, and AWS SQS messaging is shown via an async client backed by ElasticMQ.

scala-libraries/src/main · high confidence

A new sbt-info module has been introduced to demonstrate generating build information and performing code coverage analysis. It configures sbt 1.3.9 with the sbt-buildinfo (0.10.0) and sbt-scoverage (2.0.8) plugins, providing Scala 2 examples that output build metadata as strings and XML, alongside code coverage capabilities.

scala-sbt/sbt-info · high confidence

A new \CapitalizeWords\ object has been introduced in the \scala-strings\ module, providing three methods for capitalizing text: \capitalizeWords\ for standard sentence casing, \capitalizeTitleCase\ which respects a set of common exclusion words (like 'is', 'in', 'the'), and \capitalizeWordsPreserveSpaces\ which capitalizes the first letter of each word while maintaining original spacing.

scala-strings/src/main/scala/com/baeldung/scala/strings/capitalize · high confidence

The introduction-to-play sample now includes the standard configuration files required to run a Play application in Scala. This adds a default application.conf, a logback.xml configuration for structured logging with colored console output, a messages file for internationalization, and a routes file defining basic endpoints for the home page, a sum calculation, and static asset serving.

play-scala/introduction-to-play/conf · high confidence

This change introduces the initial configuration files for the Play Scala dependency injection example, establishing the application's runtime behavior. The \application.conf\ file configures Google Guice to enable \UserModule\, \OrderModule\, and a \LoggingFilter\, while the \routes\ file defines a GET endpoint for \/users\ that routes to the Guice-based \UserController\. Additionally, \logback.xml\ is added to configure structured logging with both file and console appenders, setting specific log levels for Play, application, and access logs to support debugging and monitoring.

play-scala/dependency-injection/conf · high confidence

The rest-api module now includes its core configuration files, establishing the foundation for the application. The routes file defines the API endpoints for managing todo items, including creating, retrieving, marking as done, and deleting tasks. Logging is configured via logback.xml to output to the console with colored levels and specific logger settings for Play and the application. Standard Play configuration files for application settings and internationalization messages are also present.

play-scala/rest-api/conf · high confidence

This change introduces the initial configuration files for the Play Scala application. The application.conf sets a default cache expiry of 5 minutes for the Twitter cache and configures environment-variable-based secrets for the Twitter API bearer token. The logback.xml configures logging to output to both file and console with specific log levels for Play, application, and wrapper components. The routes file defines the API endpoint for recent Twitter searches and static asset serving.

play-scala/caching-in-play/conf · high confidence

A new Main.scala file has been added to the sbt-release module, providing a basic entry point that prints 'Hello world!' to the console. This serves as the foundational executable class for the release tooling.

sbt-release/src · high confidence

Added a new Scala-based Lagom implementation for the Hello service, including the API definitions (HelloService with submit and status endpoints), data models (Job, JobAccepted, JobStatus), and the service implementation (HelloServiceImpl). The implementation features a distributed worker architecture using Akka Cluster and consistent hashing to route job submissions to worker nodes, with job status updates published via Lagom PubSub. Configuration for Cassandra persistence and a simple Play router for the /api/play endpoint are also included.

scala-lagom/hello-api, scala-lagom/hello-impl · high confidence

This update adds a comprehensive set of Scala source files and resource files to the ZIO module, providing examples for ZIO 2. The new content covers core ZIO concepts such as effect creation, error handling, resource management, and fiber-based concurrency. It also includes demonstrations of ZIO Streams for data processing, ZIO Prelude for type classes and map-reduce patterns, and integration with Apache Kafka using zio-kafka. Additionally, sample text files are added to support the stream processing examples.

zio/src/main · high confidence

A new article on Scala.js has been added to the site, featuring a basic example application that renders a test paragraph to the DOM and includes a corresponding unit test to verify the output.

scala-js · high confidence

This location introduces a new ZIO-HTTP application example that demonstrates building a REST API with ZIO. It includes a recipe management service with in-memory storage, HTTP endpoints for CRUD operations, WebSocket support for ingredients, and middleware for logging and headers. The example also provides a client application to interact with the server and unit tests for the recipe HTTP handlers.

zio3 · high confidence

Added new Scala source files demonstrating Akka HTTP and Akka Stream usage. The Akka HTTP example (AkkaRoutes.scala) defines a set of routes handling GET and POST requests for 'hello', 'hello-name', and 'hello-user' endpoints, including parameter extraction and header-based authorization checks. The Akka Stream example (Main.scala and package.scala) implements a stream processing pipeline that parses string pairs, compares answers, and counts correct results using standard Akka Stream components like Source, Flow, and Sink.

scala-akka-2/src/main/scala · high confidence

Added a new \ReadingCSV\ object in the \scala-akka-2\ module that provides four methods for processing CSV data using Akka Streams. The \read\ and \readFromString\ methods expose raw line-based streaming, while \readWithAlpakka\ and \readWithAlpakkaAsMap\ leverage the Alpakka CSV library to parse lines into lists of strings or maps, respectively.

scala-akka-2/src/main/readingcsv · high confidence

Added a comprehensive set of Scala code samples in the cats-effects module demonstrating Cats Effect 3 patterns. These include fiber cancellation strategies (direct and safe), parallel vs. sequential execution, error handling with ApplicativeError, and resource management using bracket and Resource. The samples also cover IOApp usage (simple, argument, and context-based), deferred synchronization, and lazy IO evaluation.

cats-effects/src/main · high confidence

A new IsSortedCollection object has been added to the scala-core-9 module, providing multiple methods to verify whether a list is sorted in ascending or descending order. Users can now check list ordering using approaches such as sorting comparison, sliding window checks, zip-based iteration, lazy zip for efficiency, or a tail-recursive algorithm, all supporting both ascending and descending directions via a dedicated Direction enum.

scala-core-modules/scala-core-9/src/main/scala/com/baeldung/scala/sort · high confidence

Added a new Play Framework-based REST API module that exposes endpoints for creating, retrieving, marking as done, and deleting todo list items. The API uses in-memory storage and supports JSON serialization for request and response bodies.

play-scala/rest-api · high confidence

This update adds a set of new Scala 3 code samples to the collections module, demonstrating practical usage of core data structures and algorithms. The new files include an LRU cache implementation using mutable LinkedHashMap, basic examples for Lists, Sets, and Maps, and two implementations of fixed-size lists (one using a circular buffer array and another using a mutable Queue). Additionally, it introduces code for calculating simple and weighted moving averages on stock price data, and a performance comparison application illustrating the difference between eager \zip\ and lazy \lazyZip\ operations on large lists.

scala-core-collections-modules/scala-core-collections-3/src/main · high confidence

This release adds a suite of new Scala 3 collection utilities and map operations to the library. In the collections module, users gain extension methods for finding the first matching element in a sequence, fully flattening nested collections, locating the last element satisfying a predicate, rotating sequences, and generating random fixed-size samples. It also introduces a custom lazy list implementation for demonstrating lazy evaluation and a standard list implementation, alongside methods for checking if one list is a sublist of another. In the map module, new examples demonstrate various ways to iterate over map keys and values, filter maps using different approaches (filter, collect, withFilter), and merge maps by combining values for duplicate keys.

scala-core-collections-modules/scala-core-collections-2, scala-core-collections-modules/scala-core-map · high confidence

This update adds new educational code examples to the Scala 3 core modules. It introduces demonstrations of Scala 3 brace syntax (including no-parenthesis calls and code blocks) in the \braces\ package, implements both standard and type-safe builder patterns for a \Guitar\ model in the \builderpattern\ package, and provides multiple implementations for reversing lists in \reverselists\. Additionally, it expands the \stackabletrait\ package with examples covering mixins, decorator-style composition, and stackable traits with explicit base and core traits, alongside utilities for handling \Future\ failures in \futurelist\.

scala-core-modules/scala-core-8/src/main · high confidence

The scala-core-fp module has been migrated to Scala 3 and now includes a comprehensive set of new tutorials covering core functional programming concepts. These additions include examples and unit tests for first-class functions (such as currying, closures, and higher-order functions), monoids and semigroups, type classes, functors, and the free monad pattern. The module also introduces new articles on the Tagless Final pattern, case objects versus enumerations, and the differences between foldLeft and reduceLeft, providing learners with updated, idiomatic Scala 3 code samples for these topics.

scala-core-modules/scala-core-fp · high confidence

Added demonstration code and unit tests for several Scala 3 features, including match types, transparent traits, inline and quote macros, given/using contextual abstractions, export clauses, the locally block, and the @targetName annotation.

scala-lang-modules/scala-lang-4 · high confidence

A new tutorial module (scala-core-7) has been added to demonstrate key Scala 3 concepts, including type inference for variables and functions, the use of the \@specialized\ annotation for performance, the \apply\ method pattern, and the \Product with Serializable\ trait. The module also provides examples for array manipulation (copying, initializing, and converting between Array and WrappedArray), counting character occurrences in strings, and the implications of using the \return\ keyword on referential transparency and inlining.

scala-core-modules/scala-core-4, scala-core-modules/scala-core-7 · high confidence

The scala-core-3 module now includes a comprehensive set of new Scala 3 code examples and corresponding unit tests covering access modifiers, companion objects, implicit parameters, Option builders (when/unless), non-strict data structures (streams/views), and asynchronous futures. These additions provide users with updated, compiler-warning-free examples for these core Scala concepts, aligned with the recent Scala 3.4 migration.

scala-core-modules/scala-core-3 · high confidence

The scala-core-5 module has been introduced, providing a new set of educational articles and corresponding unit tests for core Scala features. This includes examples and tests for Algebraic Data Types (using a chess piece model), method inlining annotations (@inline/@noinline), lambda expressions, various list creation methods (cons, apply, range, fill, etc.), rich wrappers/implicits, the @switch annotation for pattern matching optimization, and performance comparisons between Vector and List for operations like appending, prepending, random access, and iteration.

scala-core-modules/scala-core-5 · high confidence

This module adds new educational code samples and documentation for several Scala collection operations. It includes examples for converting Java lists to Scala sequences (supporting both Scala 2.12 and 2.13 APIs), calculating list averages using various methods (naive, double precision, and fold), and converting lists to tuples of varying sizes. Additionally, it provides detailed tests and explanations for filtering, taking while, and dropping while elements, as well as removing matching elements from both immutable and mutable collections.

scala-core-collections-modules/scala-core-collections-4 · high confidence

A new tutorial module has been added to the scala-core-collections location, providing code examples and unit tests for various Scala collection operations. The examples cover array manipulation, parallel collections (including folding and mapping), list iteration, recursive and iterative duplicate removal, list splitting, and Java-to-Scala collection conversions. The module includes comprehensive unit tests for these functionalities using ScalaTest.

scala-core-collections-modules/scala-core-collections, scala-core-modules/scala-core-2 · high confidence

The scala-core-6 module now includes a new set of educational articles and corresponding Scala source code demonstrating core language features. Users can now find examples and tests for breaking out of loops using scala.util.control.Breaks, performing file input and output operations, implementing functional and tail-recursive loops, defining and currying functions, working with Scala Futures and execution contexts, applying the Pimp My Library pattern for implicit conversions, and calculating string lengths recursively. A README has also been added to index these new topics.

scala-core-modules/scala-core-6 · high confidence

This module introduces new Scala code examples demonstrating multiple approaches to summing a list (including reduce, fold, iteration, for-comprehension, and tail recursion) and methods for rounding decimal numbers (up, down, and to the nearest whole). Unit tests are included to verify the correctness of these implementations.

scala-core-modules/scala-core-numbers-2 · high confidence

This update introduces the \scala-strings-2\ module, providing a collection of Scala string manipulation utilities. It adds functions to convert camelCase strings to snake\_case using various approaches (regex, foldLeft, flatMap, pattern matching, and collect), including specific handling for acronyms. It also introduces extension methods to check if strings or sequences are null, empty, or contain only whitespace, along with an opaque \VerifiedString\ type to enforce non-empty constraints at the type level. Additionally, it provides multiple implementations to collapse multiple spaces into a single space, and includes comprehensive unit tests for all new functionality.

scala-core-modules/scala-strings-2 · high confidence

This update adds a collection of new Scala source files and configuration resources to the scala-akka module. The new code includes examples for Akka Typed actor discovery (MathActorDiscovery), Alpakka MongoDB integration (AlpakkaMongoIntegration, CodecRegistry, MongoConnection), HTTP routing (SimpleRouter, App), custom mailboxes (Mailboxes), request-response patterns (Base64Application), scheduling (TimerActor, Greetings), actor supervision (SupervisionApplication), and portfolio management (PortfolioApplication). Additionally, it introduces application configuration for MongoDB connection settings (application.conf) and logging setup using Logback (logback.xml).

scala-akka/src/main · high confidence

A new spark-scala sub-module has been added, providing a collection of Scala 2 tutorials and corresponding unit tests for Apache Spark. The module covers fundamental operations including retrieving the first N rows of a DataFrame, converting RDDs to DataFrames with custom schemas, printing and manipulating RDDs, and performing various DataFrame joins (inner, outer, semi, anti, cross, and self-joins).

spark-scala · high confidence

Added new demonstration code for database interactions in the persistence module. This includes Doobie examples for SQL fragment construction and basic CRUD operations against PostgreSQL, Slick examples defining H2-based entities and table mappings, and a ReactiveMongo connection helper for accessing MongoDB collections. Additionally, new Slick-PG files provide a custom PostgreSQL profile supporting JSONB, arrays, and timestamp with timezone, along with corresponding entity and table definitions.

scala-libraries-persistence/src/main · high confidence

A new \RandomPasswordGenerator\ object has been introduced in the \scala-strings\ module, providing a suite of methods for generating 16-character random strings. These utilities include basic alphanumeric and printable character generators, as well as more secure variants using \java.security.SecureRandom\ that support specific character sets, character exclusions (e.g., avoiding ambiguous characters like '0' and 'O'), and mixed-requirement generation (ensuring at least one lowercase, uppercase, number, and special character).

scala-strings/src/main/scala/com/baeldung/scala/strings/passwordgen · high confidence

The new scala-core-numbers module introduces a collection of Scala utilities for common number operations, including extracting and removing individual digits, calculating factorials, generating Fibonacci sequences, checking for magic numbers, powers of two, and primes, as well as converting numbers to Roman numerals. Each utility provides multiple implementation strategies (e.g., recursion, tail recursion, functional folds, and bitwise operations) to demonstrate different Scala programming techniques.

scala-core-modules/scala-core-numbers · high confidence

A new module has been added to demonstrate configuration management in Scala using three libraries: Typesafe Config, Circe YAML, and Ciris. The module includes example code and configuration files (HOCON, JSON, YAML) for reading settings from environment variables, system properties, and files. It also provides unit tests verifying the parsing of primitive types, nested structures, fallback mechanisms, and YAML serialization/deserialization.

scala-libraries-config · high confidence

The sbt-standalone project now enforces Java specification version compatibility through a new \CompatibleJavaVersion\ object in the project build definition, ensuring that the running JVM meets the required version constraints. Additionally, the build tool itself has been upgraded to version 1.12.8, and the main application entry point has been updated to a simple Scala 3 'Hello from Scala!' output.

sbt-standalone/project · high confidence

The Play application in this module has switched from Guice to Macwire for dependency injection. This change introduces new component traits (UserComponents, OrderComponents) and services that use Macwire's \wire\ and \wireSet\ macros to resolve dependencies, including tagged instances for order validation and pipeline processors. The application loader now assembles these components using Macwire, replacing the previous Guice-based wiring.

play-scala/dependency-injection/app/macwire · high confidence

The Redis examples have been reorganized into a standalone module where all integration tests (covering caching, geospatial, leaderboard, rate limiting, and pub/sub) have been moved from the main source tree into the \src/it\ directory. A shared \RedisManualTest\ trait and a \docker-compose.yml\ file for the Redis service have been added to support this new test structure.

scala-libraries-standalone/redis-intro · high confidence

The scala-core-oop module has been upgraded to Scala 3, bringing the tutorial code up to date with the latest language version. This update includes new sample code demonstrating Scala 3's native \enum\ keyword, providing a modern alternative to the legacy \Enumeration\ pattern. The migration also involved fixing compiler warnings to ensure clean compilation and adding a README to index the module's articles on Object Oriented Programming, generics, and variance.

scala-core-modules/scala-core-oop · high confidence

The repository now enforces consistent code formatting via Scalafmt 3.7.15 (with Scala 2.13 support for legacy modules) and validates that unit test classes end with 'UnitTest' during the build. Automated dependency updates are handled by Scala Steward (configured for weekly PRs), while Mergify automatically merges approved dependency updates. A Jenkins pipeline is introduced to run tutorials, and the build includes aliases for running specific test categories (unit, integration, live, manual).

(repo-wide) · high confidence

The integration test suite in scala-libraries-persistence has been updated to improve reliability and environment management. The ReactiveMongo tests have been moved to a dedicated live test class (ReactiveMongoLiveTest) and now utilize an embedded MongoDB instance running version 7.0, addressing compatibility issues with newer operating systems in the CI environment. Additionally, the Slick-PG integration test has been renamed to BaeldungPostgresManualTest and now uses Testcontainers to spin up a PostgreSQL 16.4 container, ensuring a consistent and isolated database environment for testing.

scala-libraries-persistence/src/it · high confidence

Added Alpakka MongoDB integration tests; Added JUnit 4 test suite for Scala; Added Scala Gatling load testing module; Added ScalaTest JUnit 5 integration test example; Added ScalaTest examples for double comparison, conditional execution, and eventual consistency; Added ScalaTest unit test examples; Added integration test for Wikimedia SSE consumer; Added integration test suite for sbt 1.9.0 compatibility; Added integration tests for the Scala HTTP client library; Added test suites for Skunk and Slick persistence libraries; Added tests for Scala root import behavior; Added tests for ScalaTest Table-driven property checks; Added unit tests for AcronymGenerator; Added unit tests for Akka 2 modules; Added unit tests for Akka actor patterns and behaviors; Added unit tests for CSV I/O, Circe JSON parsing, and retry logic; Added unit tests for Cake and Magnet design patterns; Added unit tests for Cats Effect cancellation, error handling, and fibers; Added unit tests for CustomErrorHandler; Added unit tests for Guice and MacWire dependency injection examples; Added unit tests for HomeController and MyService in the Play Scala configuration-access sample; Added unit tests for Menu and ViewTemplate controllers; Added unit tests for Option to Either conversion patterns; Added unit tests for Play Scala examples; Added unit tests for PowerMacro; Added unit tests for RandomPasswordGenerator; Added unit tests for Scala 2.12 Map operations; Added unit tests for Scala 3 collections; Added unit tests for Scala 3 pattern matching scenarios; Added unit tests for Scala collection assertions; Added unit tests for Scala core modules and ZIO effects; Added unit tests for Scala core modules and testing utilities; Added unit tests for Scala exception handling patterns; Added unit tests for Scala functional programming libraries; Added unit tests for UniformCaseChecker; Added unit tests for collection sorting verification functions; Added unit tests for core Scala language features; Added unit tests for date and time utilities in the Scala dates module; Added unit tests for isomorphic string checking; Added unit tests for palindrome checking functions; Added unit tests for special character removal strategies; Added unit tests for string capitalization methods; Added unit tests for string comparison scenarios; Added unit tests for string interpolation and regex matching.

The project build has been restructured to centralize version management and update core tooling. SBT has been upgraded to version 1.12.8, and the build now explicitly defines Scala versions (2.13.18, 3.8.2, and deprecated 2.12.21) and key library versions (Play 3.0.4, Play-Slick 6.2.0, ScalaTest-Plus-Play 7.0.2) in dedicated configuration files. Plugin dependencies have been updated to their latest stable releases, including sbt-scalafmt 2.5.6, sbt-scala-native 0.5.10, sbt-scalajs 1.20.2, and the Play framework plugin 3.0.10, ensuring the build environment is synchronized with current ecosystem standards.

project · high confidence

The Play Framework sample modules (including application-tests, async-tasks, caching-in-play, configuration-access, custom-error-handling, dependency-injection, and others) have been migrated to Scala 3. This change updates the \scalaVersion\ setting in each module's \build.sbt\ to use the project's Scala 3 version constant, ensuring these examples compile and run against the Scala 3 compiler.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 49.

• Code Health 76
• Architecture 98
• Maturity 60
• Readiness 29
• Security 72
• Event-Driven 80
• Accessibility 64

• 300 commits — 300 feature/other, 0 fixes

• (repo) — 156 commits
• (root) — 110 commits
• scala-libraries-standalone/tapir — 11 commits
• project/plugins.sbt — 8 commits
• project/build.properties — 5 commits
• project/ScalaVersions.scala — 4 commits
• play-scala/caching-in-play — 3 commits
• scala-sbt/wart-remover — 2 commits
• scalatra/build.sbt — 1 commit

• change: Add Jenkinsfile to run Scala tutorials
• change: Merge branch 'master' into update/de.flapdoodle.embed.mongo-4.24.0
• change: Merge branch 'master' into update/enumeratum-1.9.6
• change: Merge branch 'master' into update/jackson-databind-2.21.0
• change: Merge branch 'master' into update/jackson-module-scala-2.21.0
• change: Merge branch 'master' into update/jedis-7.2.1
• change: Merge branch 'master' into update/kafka-clients-8.2.0-ce
• change: Merge branch 'master' into update/logback-classic-1.5.24
• change: Merge branch 'master' into update/os-lib-0.11.6
• change: Merge branch 'master' into update/pureconfig-0.17.10
• change: Merge branch 'master' into update/sbt-1.12.3
• change: Merge branch 'master' into update/sbt-1.12.3
• change: Merge branch 'master' into update/scala3-library-3.8.2
• change: Merge pull request #2012 from Baeldung/update/logback-classic-1.5.19
• change: Merge pull request #2013 from Baeldung/update/aws-java-sdk-s3-1.12.792
• change: Merge pull request #2014 from Baeldung/update/tapir-core-1.11.46
• change: Merge pull request #2015 from Baeldung/update/zio-prelude-1.0.0-RC42
• change: Merge pull request #2016 from Baeldung/update/circe-core-0.14.15
• change: Merge pull request #2017 from Baeldung/update/kafka-avro-serializer-8.0.1
• change: Merge pull request #2019 from Baeldung/update/kafka-clients-8.0.1-ce
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Baeldung/scala-tutorials was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.