Scala od podszewki - ebook
Scala od podszewki - ebook
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
- 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)
| Kategoria: | Programowanie |
| Zabezpieczenie: |
Watermark
|
| ISBN: | 978-83-246-6062-9 |
| Rozmiar pliku: | 4,7 MB |
