cats with scala

出版者:Underscore

作者:Noel Welsh

页数:327

出版时间:2017-11

价格:0

装帧:平装

isbn号码:9781789533835

具体描述

The main goal of this book is to teach system architecture and design using the techniques of modern functional programming. This means designing systems as small composable units, expressing constraints and interactions via the type system, and using composition to guide the construction of large systems in a way that maintains the original architectural vision.

The book also serves as an introduction to the Cats library. We use abstractions from Cats, and we explain the structure of Cats so you can use it without fear in your own code base. The broad ideas are not specific to Cats, but Cats provides an excellent implementation that is beneficial to learn in its own right.

Understand how to express abstractions using type classes.

Learn the key type classes of: Functor, Monoid, Applicative, and Monad.

Understand how to apply type classes to solve practical problems across a variety of domains.

To benefit from this book you should have about a year's experience with Scala, or equivalent experience with a functional language such as Haskell, O'Caml, or Lisp.

目录信息

Preface
Versions
Template Projects
Conventions Used in This Book
Typographical Conventions
Source Code
Callout Boxes
Acknowledgements
Backers
1 Introduction
1.1 Anatomy of a Type Class
1.1.1 The Type Class
1.1.2 Type Class Instances
1.1.3 Type Class Interfaces
1.2 Working with Implicits
1.2.1 Packaging Implicits
1.2.2 Implicit Scope
1.2.3 Recursive Implicit Resolution
1.3 Exercise: Printable Library
1.4 Meet Cats
1.4.1 Importing Type Classes
1.4.2 Importing Default Instances
1.4.3 Importing Interface Syntax
1.4.4 Importing All The Things!
1.4.5 Defining Custom Instances
1.4.6 Exercise: Cat Show
1.5 Example: Eq
1.5.1 Equality, Liberty, and Fraternity
1.5.2 Comparing Ints
1.5.3 Comparing Options
1.5.4 Comparing Custom Types
1.5.5 Exercise: Equality, Liberty, and Felinity
1.6 Controlling Instance Selection
1.6.1 Variance
1.7 Summary
2 Monoids and Semigroups
2.1 Definition of a Monoid
2.2 Definition of a Semigroup
2.3 Exercise: The Truth About Monoids
2.4 Exercise: All Set for Monoids
2.5 Monoids in Cats
2.5.1 The Monoid Type Class
2.5.2 Monoid Instances
2.5.3 Monoid Syntax
2.5.4 Exercise: Adding All The Things
2.6 Applications of Monoids
2.6.1 Big Data
2.6.2 Distributed Systems
2.6.3 Monoids in the Small
2.7 Summary
3 Functors
3.1 Examples of Functors
3.2 More Examples of Functors
3.3 Definition of a Functor
3.4 Aside: Higher Kinds and Type Constructors
3.5 Functors in Cats
3.5.1 The Functor Type Class
3.5.2 Functor Syntax
3.5.3 Instances for Custom Types
3.5.4 Exercise: Branching out with Functors
3.6 Contravariant and Invariant Functors
3.6.1 Contravariant Functors and the contramap Method
3.6.2 Invariant functors and the imap method
3.7 Contravariant and Invariant in Cats
3.7.1 Contravariant in Cats
3.7.2 Invariant in Cats
3.8 Aside: Partial Unification
3.8.1 Unifying Type Constructors
3.8.2 Left-to-Right Elimination
3.9 Summary
4 Monads
4.1 What is a Monad?
4.1.1 Definition of a Monad
4.1.2 Exercise: Getting Func-y
4.2 Monads in Cats
4.2.1 The Monad Type Class
4.2.2 Default Instances
4.2.3 Monad Syntax
4.3 The Identity Monad
4.3.1 Exercise: Monadic Secret Identities
4.4 Either
4.4.1 Left and Right Bias
4.4.2 Creating Instances
4.4.3 Transforming Eithers
4.4.4 Error Handling
4.4.5 Exercise: What is Best?
4.5 Aside: Error Handling and MonadError
4.5.1 The MonadError Type Class
4.5.2 Raising and Handling Errors
4.5.3 Instances of MonadError
4.5.4 Exercise: Abstracting
4.6 The Eval Monad
4.6.1 Eager, Lazy, Memoized, Oh My!
4.6.2 Eval’s Models of Evaluation
4.6.3 Eval as a Monad
4.6.4 Trampolining and Eval.defer
4.6.5 Exercise: Safer Folding using Eval
4.7 The Writer Monad
4.7.1 Creating and Unpacking Writers
4.7.2 Composing and Transforming Writers
4.7.3 Exercise: Show Your Working
4.8 The Reader Monad
4.8.1 Creating and Unpacking Readers
4.8.2 Composing Readers
4.8.3 Exercise: Hacking on Readers
4.8.4 When to Use Readers?
4.9 The State Monad
4.9.1 Creating and Unpacking State
4.9.2 Composing and Transforming State
4.9.3 Exercise: Post-Order Calculator
4.10 Defining Custom Monads
4.10.1 Exercise: Branching out Further with Monads
4.11 Summary
5 Monad Transformers
5.1 Exercise: Composing Monads
5.2 A Transformative Example
5.3 Monad Transformers in Cats
5.3.1 The Monad Transformer Classes
5.3.2 Building Monad Stacks
5.3.3 Constructing and Unpacking Instances
5.3.4 Default Instances
5.3.5 Usage Patterns
5.4 Exercise: Monads: Transform and Roll Out
5.5 Summary
6 Semigroupal and Applicative
6.1 Semigroupal
6.1.1 Joining Two Contexts
6.1.2 Joining Three or More Contexts
6.2 Apply Syntax
6.2.1 Fancy Functors and Apply Syntax
6.3 Semigroupal Applied to Different Types
6.3.1 Semigroupal Applied to Monads
6.4 Validated
6.4.1 Creating Instances of Validated
6.4.2 Combining Instances of Validated
6.4.3 Methods of Validated
6.4.4 Exercise: Form Validation
6.5 Apply and Applicative
6.5.1 The Hierarchy of Sequencing Type Classes
6.6 Summary
7 Foldable and Traverse
7.1 Foldable
7.1.1 Folds and Folding
7.1.2 Exercise: Reflecting on Folds
7.1.3 Exercise: Scaf-fold-ing Other Methods
7.1.4 Foldable in Cats
7.2 Traverse
7.2.1 Traversing with Futures
7.2.2 Traversing with Applicatives
7.2.3 Traverse in Cats
7.3 Summary
8 Case Study: Testing Asynchronous Code
8.1 Abstracting over Type Constructors
8.2 Abstracting over Monads
8.3 Summary
9 Case Study: Map-Reduce
9.1 Parallelizing map and fold
9.2 Implementing foldMap
9.3 Parallelising foldMap
9.3.1 Futures, Thread Pools, and ExecutionContexts
9.3.2 Dividing Work
9.3.3 Implementing parallelFoldMap
9.3.4 parallelFoldMap with more Cats
9.4 Summary
10 Case Study: Data Validation
10.1 Sketching the Library Structure
10.2 The Check Datatype
10.3 Basic Combinators
10.4 Transforming Data
10.4.1 Predicates
10.4.2 Checks
10.4.3 Recap
10.5 Kleislis
10.6 Summary
11 Case Study: CRDTs
11.1 Eventual Consistency
11.2 The GCounter
11.2.1 Simple Counters
11.2.2 GCounters
11.2.3 Exercise: GCounter Implementation
11.3 Generalisation
11.3.1 Implementation
11.3.2 Exercise: BoundedSemiLattice Instances
11.3.3 Exercise: Generic GCounter
11.4 Abstracting GCounter to a Type Class
11.5 Abstracting a Key Value Store
11.6 Summary
· · · · · · (收起)

用户评价

《Cats with Scala》这个书名，瞬间点燃了我对函数式编程的热情。我一直在寻找一本能够深入浅出地讲解Scala函数式编程的书籍，而这个书名透露出一种别样的风格。我不太喜欢那些只罗列API、缺乏理论深度和实践指导的书籍。我更倾向于那种能够通过生动形象的比喻，或者精心设计的案例，来帮助读者理解函数式编程的核心思想的书。我设想，这本书或许会用猫咪的各种特性，来比喻函数式编程中的各种抽象概念。比如，猫咪的“好奇心”是否可以类比于探索未知状态的能力？猫咪的“独立性”是否可以映射到无副作用的函数？我希望这本书能提供很多实际的代码例子，这些例子能够充分展示Cats库在实际开发中的应用，比如如何用它来处理复杂的数据转换、如何编写响应式的系统、如何进行高效的错误处理等等。我更希望这本书能够教会我函数式编程的思维方式，让我能够用函数式的视角去分析和解决问题，而不仅仅是简单地调用库的函数。如果这本书能够让我明白，为什么需要Monad，Monad到底解决了什么问题，并且能够让我熟练地运用Cats来构建具有高度可组合性和可测试性的代码，那我将觉得这本书的价值是巨大的。我非常期待它能够成为我学习Scala函数式编程的一个重要里程碑，并且能够在我未来的开发生涯中，持续发挥作用。

《Cats with Scala》这个书名，对于我来说，不仅仅是一本书名，更像是一个充满魔力的符咒。我是一名资深程序员，深谙各种编程范式，但对于函数式编程，尤其是Scala中的函数式编程，总感觉还有一层窗户纸没有捅破。这本书的出现，给了我一种期待，期待它能够以一种独特的方式，带领我穿越这层迷雾。我猜想，这本书可能会将Cats这个强大的函数式编程库，作为核心讲解内容，但它的重点可能不在于罗列API，而在于深入剖析其背后的设计思想和哲学。我希望书中能够用一些巧妙的比喻，或者精心设计的场景，来解释函数式编程中那些看似抽象的概念，比如类型类、函子、单子等。我尤其期待书中能够提供一些引人入胜的案例，这些案例能够展示如何利用Cats库来解决实际开发中遇到的挑战，比如如何构建响应式的系统、如何进行高效的并发控制、如何实现强大的错误管理等等。如果这本书能够让我真正理解函数式编程的“为什么”和“如何做”，并且让我能够写出更具表现力、更易于推理的代码，那它将是我职业生涯中一本不可多得的宝藏。

《Cats with Scala》这个书名，仿佛像是一串神秘的咒语，瞬间吸引了我。我是一名对新技术保持高度敏感的开发者，一直在寻找能够提升代码质量和开发效率的工具和方法。函数式编程，以其声明式、无副作用的特性，吸引了我很久，但真正深入学习却常常受限于抽象概念的难度。这本书的标题，将“Cats”这个相对轻松的词与“Scala”这个强大的函数式编程语言结合，让我觉得它可能提供了一种不同寻常的学习路径。我设想，书中可能会用一些生动有趣的比喻，比如将猫咪的各种习性，比作函数式编程中的各种概念，从而降低理解的门槛。例如，猫咪的“捕食”行为，是否可以类比于某种数据获取的操作？猫咪的“睡眠”状态，又是否可以映射到某种惰性求值或者资源管理？我非常渴望这本书能够提供大量实用的代码示例，这些示例能够展示Cats库如何帮助我们编写出更简洁、更健壮、更易于测试的代码。我希望它能教会我如何利用Cats来处理复杂的并发场景，如何构建优雅的错误处理流程，以及如何实现高效的数据转换和管道。更重要的是，我希望这本书能教会我函数式编程的思维模式，让我能够从根本上改变我写代码的方式。如果这本书能够帮助我写出真正具有函数式风格的Scala代码，那将是我最大的收获。

当我看到《Cats with Scala》这个书名时，我脑海中立刻浮现出一幅画面：一只灵动的猫咪，在Scala的世界里自由穿梭，巧妙地运用着函数式的各种工具。这让我对这本书充满了期待。我一直对函数式编程充满兴趣，但总觉得它像是一门玄奥的学科，门槛较高。而“Cats”这个词，则赋予了它一种轻松、有趣的色彩，让我觉得这本书或许能以一种更接地气、更易于接受的方式来介绍函数式编程。我希望这本书能够深入讲解Cats库，但不是仅仅停留在API的介绍，而是要讲解其背后的设计哲学和核心概念。例如，书中是否会详细解释Cats是如何实现各种类型类的，以及这些类型类如何帮助我们编写通用的、可复用的代码？我特别期待书中能够提供一些实际的案例，展示如何利用Cats来解决现实世界中的编程挑战，比如如何优雅地处理异步操作、如何构建健壮的错误处理机制、如何进行响应式编程等等。我希望这本书能够帮助我理解函数式编程的真正优势，不仅仅是代码的简洁，更重要的是其带来的可维护性、可测试性和可推理性。我希望读完这本书，我能够真正地掌握函数式编程的思维方式，并且能够熟练地运用Cats库来编写出高质量的Scala代码。这本书能否成为我通往函数式编程世界的一把钥匙，是我最为关注的。

这本《Cats with Scala》光是书名就足以让我好奇不已。我一直对函数式编程的世界充满了向往，但总觉得入门的门槛有些高，概念层层叠叠，让人望而却步。而“Cats”这个词，又带着一丝轻松和趣味，与“Scala”这个略显硬核的技术语言结合，仿佛在暗示着一种更易于理解和接受的学习路径。我设想，这本书会不会用一种非常形象的比喻，比如把Monad、Applicative Functor这些抽象的概念，拆解成猫咪的各种行为，通过观察猫咪的各种状态和互动，来阐释这些函数式编程的核心概念？例如，猫咪在不同情境下的“捕获”行为，是不是可以比喻成某个特定的函子（Functor）操作？或者猫咪在等待主人回家时，那种“不确定性”的状态，是否可以映射到Option类型或者Either类型，来讲解如何处理可能缺失或者失败的值？我非常期待书中能有这样的“类比教学法”，让我能够将那些晦涩的理论，转化为生活中熟悉易懂的场景，从而打通我对函数式编程的理解壁垒。另外，我也会关注书中是否会通过一些实际的小项目来巩固这些知识点，而不是仅仅停留在理论层面。比如，如何利用Cats库来构建一个简单的异步任务处理流程，或者如何用它来优雅地处理复杂的错误路径。毕竟，理论结合实践，才是掌握一门技术的王道。这本书的封面设计我也十分喜欢，简洁又不失艺术感，预示着这是一本值得细细品读的书籍。我迫不及待地想翻开它，看看“Cats”和“Scala”的奇妙碰撞，究竟能擦出怎样的火花，能否真正引领我进入函数式编程的奇妙世界。我希望这本书能像一位耐心而幽默的向导，带我在Scala的函数式编程花园中漫步，而非将我丢进知识的迷宫。

初见《Cats with Scala》的书名，我的内心就涌起一股强烈的探究欲。作为一名对软件开发充满热情的从业者，我深知函数式编程所带来的优雅与高效，但实践中却常常因为概念的抽象和门槛的过高而止步不前。这本书的出现，似乎预示着一种新的学习可能。我猜想，这本书或许会将Scala这门强大的语言与Cats这个函数式编程库结合，通过生动有趣的方式，将原本复杂难懂的函数式概念变得平易近人。我设想，书中可能会用猫咪行为的类比，来解释诸如函子（Functor）、应用函子（Applicative Functor）和单子（Monad）等核心抽象。比如，猫咪在不同情境下的“选择”行为，可能对应着Option的map和flatMap操作；猫咪对环境的“感知”和“响应”，或许可以映射到IO类型的运作。我非常期待书中能提供大量清晰、可执行的代码示例，这些示例不仅要能够正确地运用Cats库，更要能够直观地展示函数式编程的优势，比如如何处理副作用、如何实现并发、如何进行错误管理等。我希望这本书不仅仅是介绍Cats库的API，而是真正教会我函数式编程的思维方式。这本书能否帮助我写出更具组合性、更易于理解和维护的代码？能否在我遇到复杂问题时，提供一套优雅的解决方案？这都是我非常关注的。我希望这本书能成为我深入理解Scala函数式编程的敲门砖，并且能够在我后续的开发工作中，不断提供启发和帮助。

当我第一次看到《Cats with Scala》的书名时，我立刻被它吸引住了。作为一名一直在寻求提升代码质量和开发效率的开发者，我深知函数式编程所带来的巨大潜力。然而，市面上关于函数式编程的书籍，要么过于理论化，要么例子不够贴近实际。这个书名，尤其是“Cats”这个词，给我一种它可能比我之前接触过的任何函数式编程书籍都要有趣和易于理解的预感。我设想，这本书可能会用一些生动的比喻，或者有趣的故事，来讲解像Monad、Applicative Functor这些核心的函数式概念。比如，猫咪在追逐激光点时的那种“不确定性”和“响应性”，是否可以用来解释某些特定的函子操作？我非常渴望书中能够提供大量的实际代码示例，这些示例能够展示Cats库如何在实际的Scala项目中发挥作用，比如如何用来处理复杂的业务逻辑、如何进行高效的并发编程、如何实现优雅的错误处理等等。我希望这本书能够帮助我真正理解函数式编程的优势，并且能够让我写出更具可读性、可维护性和可测试性的代码。这本书能否成为我掌握Scala函数式编程的关键，是我非常期待的。

当我第一次看到《Cats with Scala》这本书名时，我的眼睛亮了起来。作为一名长期在软件开发领域摸爬滚打的从业者，我深知函数式编程的强大之处，但同时也体会到了其学习曲线的陡峭。许多函数式编程的入门书籍，往往在概念的介绍上过于晦涩，或者在实战案例上过于缺乏。而《Cats with Scala》这个书名，却给我一种耳目一新的感觉。我猜想，这本书或许会用一种更加轻松、更加具象的方式来介绍Scala的函数式编程。我非常期待它能将Cats这个在Scala函数式编程领域举足轻重的库，与实际的应用场景紧密结合。书中是否会通过一些生动有趣的比喻，来解释诸如Functor、Monad、Applicative等抽象概念？比如，猫咪在玩耍时，可能会有各种随机的动作和反应，这是否可以类比于函数式编程中处理不确定性或者并发操作？我希望书中能够提供丰富且具有指导意义的代码示例，这些示例能够清晰地展示Cats库的强大功能，并且能够在我实际开发中得到应用。我希望这本书能够帮助我理解函数式编程的精髓，让我能够写出更具表现力、更易于维护、更少bug的代码。这本书能否真正成为我掌握Scala函数式编程的得力助手，是我最关注的。

我最近在寻找一本能够系统性地讲解Scala函数式编程的书籍，而《Cats with Scala》这个名字立刻吸引了我。我对函数式编程的兴趣由来已久，尤其是在看到一些项目代码中大量运用像Functor、Monad、Applicative等概念时，我深切感受到掌握这些工具的重要性。然而，市面上很多函数式编程的资料，要么过于理论化，要么例子不够贴合实际。这本书的标题，尤其是“Cats”这个词，给我一种它可能不仅仅是一本枯燥的技术手册，而更像是一本引导性的读物，能够将复杂的概念以一种更易于理解的方式呈现出来。我设想，书中或许会从Cats这个强大的Scala函数式编程库入手，通过一系列精心设计的示例，逐步揭示函数式编程的核心抽象。我希望它能详细讲解Cats是如何帮助开发者编写更健壮、更可维护的代码的，比如如何利用其提供的类型类（Type Class）来编写通用的、可组合的逻辑。更重要的是，我希望书中能够提供一些实际的应用场景，让我看到函数式编程在解决真实世界问题时的强大威力。例如，如何在处理并发和异步操作时，利用Cats来写出清晰、无副作用的代码？如何使用Cats来构建声明式的、易于测试的数据处理管道？这本书如果能在我阅读的过程中，不断地“激活”我对函数式编程的理解，让我能够举一反三，将所学知识应用到我自己的开发实践中，那将是对我最大的帮助。我非常期待它能够成为我学习Scala函数式编程道路上的得力助手，帮助我跨越那些曾经让我困惑的障碍。

《Cats with Scala》这个书名，如同一个充满神秘色彩的邀请函，瞬间勾起了我的阅读兴趣。我一直对函数式编程领域抱有浓厚的兴趣，尤其是在Scala这门语言中，它所带来的优雅和强大，让我着迷。然而，通往函数式编程的道路上，总有一些抽象的概念，比如Monad、Applicative Functor等，常常让我感到困惑。这本书的标题，将“Cats”这个词与“Scala”结合，让我感觉它或许能提供一种新颖的学习方式，将那些抽象的概念变得更容易理解和消化。我猜想，这本书可能会用一些生动形象的比喻，来阐释函数式编程的核心思想。例如，猫咪在不同的场景下，可能展现出不同的行为模式，这些模式是否可以映射到函数式编程中的各种抽象？我非常期待书中能够提供大量可运行、可学习的代码示例，这些示例能够直观地展示Cats库在实际项目中的应用。我希望这本书能够引导我理解函数式编程的思维方式，让我能够写出更具声明性、更易于组合、更易于测试的代码。这本书能否帮助我突破函数式编程的瓶颈，并且在我未来的开发工作中，提供持久的价值，是我非常期待的。

聚焦 higher kinded type & algebraic data type，具体到工程实践，就是怎么做拆解并行化，怎么 F[G[_]] => G[F[_]]，etc...（这本比红书有两大优势：实用 & 写作技巧高超深入浅出

神书 比小红书更循序渐进

神书 比小红书更循序渐进

聚焦 higher kinded type & algebraic data type，具体到工程实践，就是怎么做拆解并行化，怎么 F[G[_]] => G[F[_]]，etc...（这本比红书有两大优势：实用 & 写作技巧高超深入浅出

聚焦 higher kinded type & algebraic data type，具体到工程实践，就是怎么做拆解并行化，怎么 F[G[_]] => G[F[_]]，etc...（这本比红书有两大优势：实用 & 写作技巧高超深入浅出