Scala

Scala to język hybrydowy, który w unikalny sposób łączy najlepsze cechy obu paradygmatów: • Programowanie Obiektowe (OOP): Jego fundamentem jest enkapsulacja, czyli łączenie danych i operujących na nich metod w spójne jednostki zwane obiektami. Promuje dziedziczenie i polimorfizm. W Scali wszystko jest obiektem, nawet funkcje i typy proste, co jest rozwinięciem idei z Javy. • Programowanie Funkcyjne (FP): Jego fundamentem są funkcje jako 'obywatele pierwszej kategorii' – można je przypisywać do zmiennych, przekazywać jako argumenty i zwracać z innych funkcji. Promuje niezmienność danych (immutability) i unikanie efektów ubocznych (side effects), co prowadzi do bardziej przewidywalnego i łatwiejszego do testowania kodu. Jak Scala je łączy? Scala pozwala na tworzenie klas i obiektów (OOP), ale jednocześnie dostarcza potężnych narzędzi do pisania kodu w stylu funkcyjnym: niemutowalne kolekcje, funkcje wyższego rzędu, dopasowywanie wzorców i typy takie jak `Option` czy `Either`. Programista w Scali może płynnie przechodzić między oboma paradygmatami, wybierając najlepsze narzędzie do rozwiązania danego problemu. Promuje to pisanie kodu, który jest zarówno dobrze ustrukturyzowany (OOP), jak i bezpieczny i przewidywalny (FP).

Różnica leży w sposobie, w jaki kolekcje reagują na operacje modyfikacji. • Kolekcje niemutowalne (Immutable): Są domyślnym i preferowanym typem kolekcji w Scali (np. `List`, `Vector`). Po ich utworzeniu nie można ich zmienić. Każda operacja, która wygląda jak modyfikacja (np. dodanie elementu), w rzeczywistości zwraca nową, zmodyfikowaną kopię kolekcji, pozostawiając oryginał nienaruszonym. Procentuje to w postaci bezpieczniejszego i bardziej przewidywalnego kodu, zwłaszcza w środowiskach wielowątkowych, gdzie eliminuje ryzyko konfliktów w dostępie do danych. • Kolekcje mutowalne (Mutable): Znajdują się w pakiecie `scala.collection.mutable` (np. `ArrayBuffer`, `mutable.Map`). Mogą być modyfikowane w miejscu, co oznacza, z operacje takie jak dodanie elementu zmieniają oryginalną kolekcję. Są one czasem używane w specyficznych, krytycznych pod względem wydajności algorytmach, ale ich użycie wymaga większej ostrożności. W idiomatycznej Scali zdecydowanie preferuje się kolekcje niemutowalne, ponieważ idealnie wpisują się one w paradygmat funkcyjny i prowadzą do bardziej solidnego oprogramowania.

Klasy przypadku (case classes) to specjalny, zwięzły typ klas w Scali, zoptymalizowany do modelowania niemutowalnych danych. Można je traktować jak 'ulepszone' klasy do przechowywania danych (odpowiednik `record` w Javie czy `data class` w Kotlinie). Ich główne zalety wynikają z tego, że kompilator Scali automatycznie generuje dla nich wiele standardowego, ale uciążliwego kodu (boilerplate): 1. Niemutowalność domyślnie: Wszystkie parametry konstruktora są domyślnie publicznymi, niemutowalnymi polami (`val`). 2. Sensowne `equals` i `hashCode`: Automatycznie generowane metody, które porównują instancje na podstawie wartości ich pól, a nie referencji. 3. Czytelna metoda `toString`: Umożliwia łatwe debugowanie. 4. Metoda `copy`: Pozwala na tworzenie kopii obiektu z ewentualną modyfikacją wybranych pól, co jest kluczowe przy pracy z niemutowalnymi danymi. 5. Wsparcie dla dekonstrukcji: Co najważniejsze, case classy doskonale integrują się z dopasowywaniem wzorców (pattern matching), pozwalając na łatwe 'rozpakowanie' ich zawartości. Dzięki temu, zamiast pisać kilkadziesiąt linii kodu, wystarczy jedna: `case class User(id: Int, name: String)`.

`Future` w Scali to podstawowy mechanizm do obsługi obliczeń asynchronicznych. Jest to obiekt, który działa jak 'uchwyt' lub 'obietnica' na wartość, która zostanie obliczona w przyszłości. Gdy uruchamiamy długotrwałą operację (np. zapytanie do bazy danych, odwołanie do zewnętrznego API) wewnątrz `Future`, nie blokuje ona głównego wątku. Zamiast tego, operacja wykonuje się w tle, a my natychmiast otrzymujemy obiekt `Future`, który początkowo jest 'pusty'. `Future` może zakończyć się w jeden z dwóch sposobów: • Sukcesem (`Success[T]`): Obliczenie się powiodło i `Future` zawiera wynik o typie `T`. • Porażką (`Failure[Throwable]`): W trakcie obliczeń wystąpił błąd i `Future` zawiera wyjątek, który go spowodował. Jak pomaga? Umożliwia pisanie nieblokującego, reaktywnego kodu. Zamiast czekać na wynik, możemy zarejestrować funkcje zwrotne (callbacks) (np. za pomocą `onComplete`), które zostaną wykonane, gdy `Future` się zakończy. Co ważniejsze, `Future` wspiera kompozycję w stylu funkcyjnym za pomocą metod takich jak `map`, `flatMap` i `filter`, co pozwala na eleganckie łączenie wielu operacji asynchronicznych w jeden, czytelny potok przetwarzania.

Akka to zaawansowany toolkit i środowisko uruchomieniowe do budowania wysoce współbieżnych, rozproszonych i odpornych na błędy (resilient) aplikacji na JVM. Jej fundamentem jest model aktorów. Model ten rozwiązuje problemy tradycyjnej współbieżności opartej na współdzielonej pamięci, wątkach i blokadach (locks), która jest skomplikowana i podatna na błędy (np. zakleszczenia - deadlocks, warunki wyścigu - race conditions). Jak działa model aktorów? • Zamiast wątków i blokad, mamy lekkich aktorów. Aktor to obiekt, który ma swój stan wewnętrzny, zachowanie i skrzynkę pocztową (mailbox). • Stan aktora jest w pełni enkapsulowany i niedostępny z zewnątrz. Jedynym sposobem interakcji z aktorem jest wysłanie mu asynchronicznej, niemutowalnej wiadomości. • Aktor przetwarza wiadomości ze swojej skrzynki pocztowej jedna po drugiej, sekwencyjnie. Dzięki temu jego stan wewnętrzny nigdy nie jest modyfikowany przez wiele wątków naraz, co eliminuje potrzebę stosowania blokad. • W odpowiedzi na wiadomość, aktor może: zmienić swój stan, wysłać wiadomości do innych aktorów lub stworzyć nowych aktorów. Model ten radykalnie upraszcza pisanie i rozumowanie o kodzie współbieżnym, a Akka dodatkowo zapewnia mechanizmy nadzoru (supervision) i lokalizacji (location transparency), co ułatwia budowanie skalowalnych i odpornych na awarie systemów rozproszonych.

Dopasowywanie wzorców (Pattern Matching) to jedna z najpotężniejszych i najbardziej ekspresyjnych cech Scali. Jest to mechanizm podobny do instrukcji `switch` z innych języków, ale o znacznie większych możliwościach. Pozwala on na dopasowanie wartości do serii wzorców (patterns) i wykonanie odpowiedniego bloku kodu. Używa się do tego składni `match`. Czym przewyższa `switch`? • Może dopasowywać dowolne wartości, nie tylko stałe: np. `case x if x > 0 => ...` • Dekonstrukcja (Unpacking): To jego największa siła. Potrafi 'rozpakować' złożone typy danych, takie jak case classy, krotki czy listy, i przypisać ich składowe do zmiennych. ```scala case class Person(name: String, age: Int) person match { case Person("Jan", age) => println(s"To jest Jan w wieku $age") case Person(name, 30) => println(s"To jest $name i ma 30 lat") } ``` • Dopasowywanie typów: Może sprawdzać typ zmiennej (`case s: String => ...`). • Kompletność sprawdzana przez kompilator: Jeśli dopasowujemy wartość typu 'sealed' (np. case classy dziedziczące po 'sealed trait'), kompilator ostrzeże nas, jeśli nie obsłużymy wszystkich możliwych przypadków, co eliminuje błędy. Pattern matching prowadzi do bardziej bezpiecznego, zwięzłego i czytelnego kodu niż kaskada instrukcji `if-else` czy `switch`.