Scala od podszewki

Scala to słowo, które ostatnio nie schodzi z ust programistów Javy. Pod tą nazwą kryje się język łączący światy programowania funkcyjnego i obiektowego. Jego ogromną zaletą jest działanie w oparciu o wirtualną maszynę Javy. Pozwala to między innymi na bezproblemową komunikację i współdzielenie kodu między oboma językami. James Gosling, twórca Javy, zapytany o to, jakiego języka oprogramowania działającego w ten sposób użyłby obecnie (gdyby nie mógł wykorzystać Javy), odparł bez zastanowienia: „Scala!”. To chyba najlepszy dowód na to, że ten język wart jest Twojego czasu!

Dzięki tej książce opanujesz Scalę szybko i bezboleśnie, więc będziesz mógł wykorzystać jej zalety już w najbliższym projekcie. W trakcie lektury poznasz składnię, fundamentalne zasady tworzenia oprogramowania w Scali oraz konwencje kodowania w tym języku. W kolejnych rozdziałach dowiesz się, czym są niejawne widoki, jakie typy danych masz do dyspozycji i jakie są ich ograniczenia.

Co jeszcze? Integracja Scali z Javą to niezwykle istotny temat, dający Ci pole do popisu! Ponadto poznasz wzorce stosowane w programowaniu funkcyjnym. Słowo wstępne do tej niezwykłej książki napisał sam Martin Odersky - twórca języka Scala! Niniejsza książka jest najlepszym kompendium wiedzy na temat programowania w tym języku. Musisz ją mieć!

Poznaj:

• konwencje obowiązujące w Scali
• składnię języka
• najlepsze wzorce projektowe stosowane w programowaniu funkcyjnym
• potencjał języka Scala!

Poznaj i wykorzystaj potęgę programowania funkcyjnego.

Spis treści:

Rozdział 1. Scala: język mieszany (17)

• 1.1. Programowanie funkcyjne i obiektowe w jednym (18)
  • 1.1.1. Koncepty funkcyjne (20)
  • 1.1.2. Analiza konceptów funkcyjnych w Google Collections (22)
• 1.2. Statyczne typowanie a ekspresywność kodu (23)
  • 1.2.1. Zamiana stron (24)
  • 1.2.2. Wnioskowanie na temat typów (24)
  • 1.2.3. Uproszczona składnia (25)
  • 1.2.4. Wartości i konwersje domniemane (26)
  • 1.2.5. Słowo kluczowe implicit (27)
• 1.3. Wygodna współpraca z JVM (28)
  • 1.3.1. Java w Scali (28)
  • 1.3.2. Scala w Javie (29)
  • 1.3.3. Zalety JVM (30)
• 1.4. Podsumowanie (31)

Rozdział 2. Podstawowe zasady (33)

• 2.1. Eksperymenty w środowisku REPL (33)
  • 2.1.1. Programowanie sterowane eksperymentami (34)
  • 2.1.2. Obejście zachłannego parsowania (36)
  • 2.1.3. Elementy języka niedostępne w REPL (37)
• 2.2. Myślenie wyrażeniami (38)
  • 2.2.1. Unikanie instrukcji return (39)
  • 2.2.2. Modyfikowalność (41)
• 2.3. Obiekty niemodyfikowalne (43)
  • 2.3.1. Równoważność obiektów (44)
  • 2.3.2. Współbieżność (48)
• 2.4. None zamiast null (51)
  • 2.4.1. Zaawansowane techniki wykorzystania klasy Option (52)
• 2.5. Równoważność polimorficzna (55)
  • 2.5.1. Przykład: biblioteka obsługująca kalendarz (55)
  • 2.5.2. Polimorficzna implementacja metody equals (57)
• 2.6. Podsumowanie (59)

Rozdział 3. Parę słów na temat konwencji kodowania (61)

• 3.1. Unikanie konwencji pochodzących z innych języków (62)
  • 3.1.1. Porażka z blokami kodu (63)
• 3.2. Wiszące operatory i wyrażenia w nawiasach (66)
• 3.3. Znaczące nazwy zmiennych (67)
  • 3.3.1. Unikanie w nazwach znaku $ (68)
  • 3.3.2. Parametry nazwane i wartości domyślne (71)
• 3.4. Oznaczanie przesłaniania metod (73)
• 3.5. Adnotacje optymalizacyjne (78)
  • 3.5.1. Optymalizacja tableswitch (79)
  • 3.5.2. Optymalizacja wywołań ogonowych (81)
• 3.6. Podsumowanie (84)

Rozdział 4. Obiektowość (85)

• 4.1. W ciele obiektu lub cechy - tylko kod inicjalizujący (86)
  • 4.1.1. Opóźniona inicjalizacja (86)
  • 4.1.2. Wielokrotne dziedziczenie (87)
• 4.2. Puste implementacje metod abstrakcyjnych w cechach (89)
• 4.3. Kompozycja może obejmować dziedziczenie (93)
  • 4.3.1. Kompozycja i dziedziczenie razem (96)
  • 4.3.2. Klasyczne konstruktory... z niespodzianką (97)
• 4.4. Wydzielenie interfejsu abstrakcyjnego do postaci osobnej cechy (99)
  • 4.4.1. Interfejsy, z którymi można porozmawiać (101)
  • 4.4.2. Nauka płynąca z przeszłości (102)
• 4.5. Określanie typów zwracanych przez publiczne API (103)
• 4.6. Podsumowanie (105)

Rozdział 5. Domniemane wartości i widoki podstawą ekspresywnego kodu (107)

• 5.1. Słowo kluczowe implicit (108)
  • 5.1.1. Identyfikatory (dygresja) (109)
  • 5.1.2. Zakres i wiązania (111)
  • 5.1.3. Wyszukiwanie wartości domniemanych (115)
• 5.2. Wzmacnianie klas za pomocą domniemanych widoków (119)
• 5.3. Parametry domniemane i domyślne (124)
• 5.4. Ograniczanie zakresu encji domniemanych (130)
  • 5.4.1. Przygotowywanie encji domniemanych do zaimportowania (131)
  • 5.4.2. Parametry i widoki domniemane bez podatku od importu (133)
• 5.5. Podsumowanie (137)

Rozdział 6. System typów (139)

• 6.1. Typy (140)
  • 6.1.1. Typy i ścieżki (141)
  • 6.1.2. Słowo kluczowe type (143)
  • 6.1.3. Typy strukturalne (144)
• 6.2. Ograniczenia typów (151)
• 6.3. Parametry typu i typy wyższego rzędu (153)
  • 6.3.1. Ograniczenia parametrów typu (153)
  • 6.3.2. Typy wyższego rzędu (155)
• 6.4. Wariancja (156)
  • 6.4.1. Zaawansowane adnotacje wariancji (160)
• 6.5. Typy egzystencjalne (163)
  • 6.5.1. Formalna składnia typów egzystencjalnych (165)
• 6.6. Podsumowanie (167)

Rozdział 7. Łączenie typów z wartościami i widokami domniemanymi (169)

• 7.1. Ograniczenia kontekstu i ograniczenia widoku (170)
  • 7.1.1. Kiedy stosować domniemane ograniczenia typu? (171)
• 7.2. Dodawanie typów do parametrów domniemanych (172)
  • 7.2.1. Manifesty (172)
  • 7.2.2. Korzystanie z manifestów (173)
  • 7.2.3. Ograniczenia typu (175)
  • 7.2.4. Wyspecjalizowane metody (177)
• 7.3. Klasy typu (178)
  • 7.3.1. FileLike jako klasa typu (181)
  • 7.3.2. Zalety klas typu (184)
• 7.4. Egzekucja warunkowa z użyciem systemu typów (185)
  • 7.4.1. Heterogeniczne listy typowane (187)
  • 7.4.2. Cecha IndexedView (190)
• 7.5. Podsumowanie (196)

Rozdział 8. Wybór odpowiedniej kolekcji (197)

• 8.1. Wybór odpowiedniego rodzaju kolekcji (198)
  • 8.1.1. Hierarchia kolekcji (198)
  • 8.1.2. Traversable (200)
  • 8.1.3. Iterable (203)
  • 8.1.4. Seq (204)
  • 8.1.5. LinearSeq (205)
  • 8.1.6. IndexedSeq (207)
  • 8.1.7. Set (208)
  • 8.1.8. Map (208)
• 8.2. Kolekcje niemodyfikowalne (210)
  • 8.2.1. Vector (210)
  • 8.2.2. List (212)
  • 8.2.3. Stream (213)
• 8.3. Kolekcje modyfikowalne (216)
  • 8.3.1. ArrayBuffer (217)
  • 8.3.2. Nasłuchiwanie zdarzeń zmiany kolekcji za pomocą domieszek (217)
  • 8.3.3. Synchronizacja z użyciem domieszek (218)
• 8.4. Zmiana czasu ewaluacji za pomocą widoków i kolekcji równoległych (218)
  • 8.4.1. Widoki (219)
  • 8.4.2. Kolekcje równoległe (221)
• 8.5. Pisanie metod, które można wykorzystać na wszystkich typach kolekcji (223)
  • 8.5.1. Optymalizacja algorytmów dla różnych typów kolekcji (226)
• 8.6. Podsumowanie (229)

Rozdział 9. Aktorzy (231)

• 9.1. Kiedy stosować aktorów? (232)
  • 9.1.1. Zastosowanie aktorów do wyszukiwania (232)
• 9.2. Typowane, przezroczyste referencje (235)
  • 9.2.1. Realizacja algorytmu rozprosz-zgromadź przy użyciu OutputChannel (236)
• 9.3. Ograniczanie błędów do stref (240)
  • 9.3.1. Strefy błędu w przykładzie rozprosz-zgromadź (240)
  • 9.3.2. Ogólne zasady obsługi awarii (243)
• 9.4. Ograniczanie przeciążeń za pomocą stref planowania (244)
  • 9.4.1. Strefy planowania (245)
• 9.5. Dynamiczna topologia aktorów (247)
• 9.6. Podsumowanie (251)

Rozdział 10. Integracja Scali z Javą (253)

• 10.1. Różnice językowe pomiędzy Scalą a Javą (254)
  • 10.1.1. Różnice w opakowywaniu typów prostych (255)
  • 10.1.2. Widoczność (259)
  • 10.1.3. Nieprzekładalne elementy języka (260)
• 10.2. Uwaga na domniemane konwersje (263)
  • 10.2.1. Tożsamość i równoważność obiektów (263)
  • 10.2.2. Łańcuchy domniemanych widoków (265)
• 10.3. Uwaga na serializację w Javie (267)
  • 10.3.1. Serializacja klas anonimowych (269)
• 10.4. Adnotowanie adnotacji (271)
  • 10.4.1. Cele adnotacji (272)
  • 10.4.2. Scala i pola statyczne (273)
• 10.5. Podsumowanie (274)

Rozdział 11. Wzorce w programowaniu funkcyjnym (277)

• 11.1. Teoria kategorii w informatyce (278)
• 11.2. Funktory i monady oraz ich związek z kategoriami (281)
  • 11.2.1. Monady (284)
• 11.3. Rozwijanie funkcji i styl aplikacyjny (286)
  • 11.3.1. Rozwijanie funkcji (286)
  • 11.3.2. Styl aplikacyjny (288)
• 11.4. Monady jako przepływy pracy (291)
• 11.5. Podsumowanie (295)