Scala od podszewki (ebook)(audiobook)(audiobook)

Spis treści

• Słowo wstępne (7)
• Przedmowa (9)
• Podziękowania (11)
• O książce (13)

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)

Skorowidz (297)

pokaż cały spis treści

ukryj recenzje