From 3e1b42c4f16f4ce340ff9d8a193da68cc6b54dcb Mon Sep 17 00:00:00 2001 From: "Kai(luo) Wang" Date: Thu, 7 Sep 2017 13:55:29 -0400 Subject: [PATCH 01/14] Update faq.md With @alexandru's consent, I adapted some content of a reddit comment of his to this item. --- docs/src/main/tut/faq.md | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/docs/src/main/tut/faq.md b/docs/src/main/tut/faq.md index a2458a9a28..02db2e3501 100644 --- a/docs/src/main/tut/faq.md +++ b/docs/src/main/tut/faq.md @@ -8,7 +8,7 @@ position: 4 # Frequently Asked Questions ## Questions - + * [What is the difference between cats and scalaz](#diff-scalaz) * [What imports do I need?](#what-imports) * [Where is right-biased `Either`?](#either) * [Why is the compiler having trouble with types with more than one type parameter?](#si-2712) @@ -24,6 +24,14 @@ position: 4 * [What does this symbol mean?](#symbol) * [How can I help?](#contributing) +## What is the difference between cats and scalaz? + +The goal for both cats and scalaz are the same: facilitate pure functional programming in scala applications; the underling core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard libary* for FP that powers the scala applications. Cats, on the other hand, aims to help build an [ecosystem](https://typelevel.org/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included), scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. + +Based on this core strategy, cats took a [modular](https://typelevel.org/cats/#modularity) approach and focuses on providing core, binary compatible, [approable](https://typelevel.org/cats/#approachability) and [efficient](https://typelevel.org/cats/#efficiency) abstractions. It also takes great effort in providing a welcoming and supportive [community environment](https://gitter.im/typelevel/cats) and a comprehensive beginner-friendly [documentation](https://typelevel.org/cats/#documentation). + +We believe that both cats and scalaz strategies have its merits and shortcomings, and it's a positive thing for the scala community to have both. + ## What imports do I need? The easiest approach to cats imports is to import everything that's commonly needed: From 5eff4316c4325606fbc3ff639fc1cb1dd8e20e73 Mon Sep 17 00:00:00 2001 From: "Kai(luo) Wang" Date: Thu, 7 Sep 2017 13:58:47 -0400 Subject: [PATCH 02/14] typos --- docs/src/main/tut/faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/main/tut/faq.md b/docs/src/main/tut/faq.md index 02db2e3501..b83023c57d 100644 --- a/docs/src/main/tut/faq.md +++ b/docs/src/main/tut/faq.md @@ -26,7 +26,7 @@ position: 4 ## What is the difference between cats and scalaz? -The goal for both cats and scalaz are the same: facilitate pure functional programming in scala applications; the underling core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard libary* for FP that powers the scala applications. Cats, on the other hand, aims to help build an [ecosystem](https://typelevel.org/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included), scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. +The goal for both cats and scalaz are the same: facilitate pure functional programming in scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the scala applications. Cats, on the other hand, aims to help build an [ecosystem](https://typelevel.org/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included), scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. Based on this core strategy, cats took a [modular](https://typelevel.org/cats/#modularity) approach and focuses on providing core, binary compatible, [approable](https://typelevel.org/cats/#approachability) and [efficient](https://typelevel.org/cats/#efficiency) abstractions. It also takes great effort in providing a welcoming and supportive [community environment](https://gitter.im/typelevel/cats) and a comprehensive beginner-friendly [documentation](https://typelevel.org/cats/#documentation). From ae0ca8482e6e8d8e63579e3c3374f70a30278ac3 Mon Sep 17 00:00:00 2001 From: "Kai(luo) Wang" Date: Thu, 7 Sep 2017 14:02:02 -0400 Subject: [PATCH 03/14] typo --- docs/src/main/tut/faq.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/src/main/tut/faq.md b/docs/src/main/tut/faq.md index b83023c57d..e83f0eccc1 100644 --- a/docs/src/main/tut/faq.md +++ b/docs/src/main/tut/faq.md @@ -26,11 +26,11 @@ position: 4 ## What is the difference between cats and scalaz? -The goal for both cats and scalaz are the same: facilitate pure functional programming in scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the scala applications. Cats, on the other hand, aims to help build an [ecosystem](https://typelevel.org/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included), scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. +The goal for both Cats and [Scalaz](https://github.com/scalaz/scalaz) are the same: facilitate pure functional programming in Scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the Scala applications. Cats, on the other hand, aims to help build an [ecosystem](https://typelevel.org/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included) that Scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. -Based on this core strategy, cats took a [modular](https://typelevel.org/cats/#modularity) approach and focuses on providing core, binary compatible, [approable](https://typelevel.org/cats/#approachability) and [efficient](https://typelevel.org/cats/#efficiency) abstractions. It also takes great effort in providing a welcoming and supportive [community environment](https://gitter.im/typelevel/cats) and a comprehensive beginner-friendly [documentation](https://typelevel.org/cats/#documentation). +Based on this core strategy, Cats took a [modular](https://typelevel.org/cats/#modularity) approach and focuses on providing core, binary compatible, [approable](https://typelevel.org/cats/#approachability) and [efficient](https://typelevel.org/cats/#efficiency) abstractions. It also takes great effort in providing a welcoming and supportive [community environment](https://gitter.im/typelevel/cats) and a comprehensive beginner-friendly [documentation](https://typelevel.org/cats/#documentation). -We believe that both cats and scalaz strategies have its merits and shortcomings, and it's a positive thing for the scala community to have both. +We believe that both Cats and Scalaz strategies have its merits and shortcomings, and it's a positive thing for the scala community to have both. ## What imports do I need? From 9255b220bb073f98935d23f40b55f35c2fa77370 Mon Sep 17 00:00:00 2001 From: "Kai(luo) Wang" Date: Thu, 7 Sep 2017 15:31:46 -0400 Subject: [PATCH 04/14] typo --- docs/src/main/tut/faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/main/tut/faq.md b/docs/src/main/tut/faq.md index e83f0eccc1..242079e4b0 100644 --- a/docs/src/main/tut/faq.md +++ b/docs/src/main/tut/faq.md @@ -28,7 +28,7 @@ position: 4 The goal for both Cats and [Scalaz](https://github.com/scalaz/scalaz) are the same: facilitate pure functional programming in Scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the Scala applications. Cats, on the other hand, aims to help build an [ecosystem](https://typelevel.org/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included) that Scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. -Based on this core strategy, Cats took a [modular](https://typelevel.org/cats/#modularity) approach and focuses on providing core, binary compatible, [approable](https://typelevel.org/cats/#approachability) and [efficient](https://typelevel.org/cats/#efficiency) abstractions. It also takes great effort in providing a welcoming and supportive [community environment](https://gitter.im/typelevel/cats) and a comprehensive beginner-friendly [documentation](https://typelevel.org/cats/#documentation). +Based on this core strategy, Cats took a [modular](https://typelevel.org/cats/#modularity) approach and focuses on providing core, binary compatible, [approachable](https://typelevel.org/cats/#approachability) and [efficient](https://typelevel.org/cats/#efficiency) abstractions. It also takes great effort in providing a welcoming and supportive [community environment](https://gitter.im/typelevel/cats) and a comprehensive beginner-friendly [documentation](https://typelevel.org/cats/#documentation). We believe that both Cats and Scalaz strategies have its merits and shortcomings, and it's a positive thing for the scala community to have both. From aee5a6da3371e1b5140bb369ab5683991a3a295b Mon Sep 17 00:00:00 2001 From: "Kai(luo) Wang" Date: Thu, 7 Sep 2017 15:47:20 -0400 Subject: [PATCH 05/14] Update faq.md --- docs/src/main/tut/faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/main/tut/faq.md b/docs/src/main/tut/faq.md index 242079e4b0..0ca4973ec9 100644 --- a/docs/src/main/tut/faq.md +++ b/docs/src/main/tut/faq.md @@ -28,7 +28,7 @@ position: 4 The goal for both Cats and [Scalaz](https://github.com/scalaz/scalaz) are the same: facilitate pure functional programming in Scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the Scala applications. Cats, on the other hand, aims to help build an [ecosystem](https://typelevel.org/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included) that Scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. -Based on this core strategy, Cats took a [modular](https://typelevel.org/cats/#modularity) approach and focuses on providing core, binary compatible, [approachable](https://typelevel.org/cats/#approachability) and [efficient](https://typelevel.org/cats/#efficiency) abstractions. It also takes great effort in providing a welcoming and supportive [community environment](https://gitter.im/typelevel/cats) and a comprehensive beginner-friendly [documentation](https://typelevel.org/cats/#documentation). +Based on this core strategy, Cats took a [modular](https://typelevel.org/cats/#modularity) approach and focuses on providing core, [binary compatible](https://typelevel.org/cats/#a-namebinary-compatibility-and-versioning), [approachable](https://typelevel.org/cats/#approachability) and [efficient](https://typelevel.org/cats/#efficiency) abstractions. It also takes great effort in providing a welcoming and supportive [community environment](https://gitter.im/typelevel/cats) and a comprehensive beginner-friendly [documentation](https://typelevel.org/cats/#documentation). We believe that both Cats and Scalaz strategies have its merits and shortcomings, and it's a positive thing for the scala community to have both. From cc98cc2121ccf4bec3607fccf7008d55a4cfbd27 Mon Sep 17 00:00:00 2001 From: "Kai(luo) Wang" Date: Thu, 7 Sep 2017 15:49:34 -0400 Subject: [PATCH 06/14] Update faq.md --- docs/src/main/tut/faq.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/src/main/tut/faq.md b/docs/src/main/tut/faq.md index 0ca4973ec9..48d1ec6667 100644 --- a/docs/src/main/tut/faq.md +++ b/docs/src/main/tut/faq.md @@ -26,9 +26,9 @@ position: 4 ## What is the difference between cats and scalaz? -The goal for both Cats and [Scalaz](https://github.com/scalaz/scalaz) are the same: facilitate pure functional programming in Scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the Scala applications. Cats, on the other hand, aims to help build an [ecosystem](https://typelevel.org/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included) that Scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. +The goal for both Cats and [Scalaz](https://github.com/scalaz/scalaz) are the same: facilitate pure functional programming in Scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the Scala applications. Cats, on the other hand, aims to help build an [ecosystem](/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included) that Scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. -Based on this core strategy, Cats took a [modular](https://typelevel.org/cats/#modularity) approach and focuses on providing core, [binary compatible](https://typelevel.org/cats/#a-namebinary-compatibility-and-versioning), [approachable](https://typelevel.org/cats/#approachability) and [efficient](https://typelevel.org/cats/#efficiency) abstractions. It also takes great effort in providing a welcoming and supportive [community environment](https://gitter.im/typelevel/cats) and a comprehensive beginner-friendly [documentation](https://typelevel.org/cats/#documentation). +Based on this core strategy, Cats took a [modular](/cats/#modularity) approach and focuses on providing core, [binary compatible](/cats/#a-namebinary-compatibility-and-versioning), [approachable](/cats/#approachability) and [efficient](/cats/#efficiency) abstractions. It also takes great effort in providing a welcoming and supportive [community environment](https://gitter.im/typelevel/cats) and a comprehensive beginner-friendly [documentation](/cats/#documentation). We believe that both Cats and Scalaz strategies have its merits and shortcomings, and it's a positive thing for the scala community to have both. From d8d665671cb92956379ded6b5eb7f046fbcfb722 Mon Sep 17 00:00:00 2001 From: "Kai(luo) Wang" Date: Fri, 8 Sep 2017 10:39:48 -0400 Subject: [PATCH 07/14] Update faq.md --- docs/src/main/tut/faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/main/tut/faq.md b/docs/src/main/tut/faq.md index 48d1ec6667..4d9fa6ea18 100644 --- a/docs/src/main/tut/faq.md +++ b/docs/src/main/tut/faq.md @@ -30,7 +30,7 @@ The goal for both Cats and [Scalaz](https://github.com/scalaz/scalaz) are the sa Based on this core strategy, Cats took a [modular](/cats/#modularity) approach and focuses on providing core, [binary compatible](/cats/#a-namebinary-compatibility-and-versioning), [approachable](/cats/#approachability) and [efficient](/cats/#efficiency) abstractions. It also takes great effort in providing a welcoming and supportive [community environment](https://gitter.im/typelevel/cats) and a comprehensive beginner-friendly [documentation](/cats/#documentation). -We believe that both Cats and Scalaz strategies have its merits and shortcomings, and it's a positive thing for the scala community to have both. +We believe that both Cats and Scalaz strategies have their merits and shortcomings, and it's a positive thing for the scala community to have both. ## What imports do I need? From 929c95b9b2256094004f3d35dabcdc4782afda41 Mon Sep 17 00:00:00 2001 From: "Kai(luo) Wang" Date: Fri, 8 Sep 2017 12:45:16 -0400 Subject: [PATCH 08/14] feedback --- docs/src/main/tut/faq.md | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/docs/src/main/tut/faq.md b/docs/src/main/tut/faq.md index 4d9fa6ea18..a3693e8ece 100644 --- a/docs/src/main/tut/faq.md +++ b/docs/src/main/tut/faq.md @@ -8,8 +8,8 @@ position: 4 # Frequently Asked Questions ## Questions - * [What is the difference between cats and scalaz](#diff-scalaz) * [What imports do I need?](#what-imports) + * [What is the difference between cats and scalaz](#diff-scalaz) * [Where is right-biased `Either`?](#either) * [Why is the compiler having trouble with types with more than one type parameter?](#si-2712) * [Why can't the compiler find implicit instances for Future?](#future-instances) @@ -24,14 +24,6 @@ position: 4 * [What does this symbol mean?](#symbol) * [How can I help?](#contributing) -## What is the difference between cats and scalaz? - -The goal for both Cats and [Scalaz](https://github.com/scalaz/scalaz) are the same: facilitate pure functional programming in Scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the Scala applications. Cats, on the other hand, aims to help build an [ecosystem](/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included) that Scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. - -Based on this core strategy, Cats took a [modular](/cats/#modularity) approach and focuses on providing core, [binary compatible](/cats/#a-namebinary-compatibility-and-versioning), [approachable](/cats/#approachability) and [efficient](/cats/#efficiency) abstractions. It also takes great effort in providing a welcoming and supportive [community environment](https://gitter.im/typelevel/cats) and a comprehensive beginner-friendly [documentation](/cats/#documentation). - -We believe that both Cats and Scalaz strategies have their merits and shortcomings, and it's a positive thing for the scala community to have both. - ## What imports do I need? The easiest approach to cats imports is to import everything that's commonly needed: @@ -44,6 +36,15 @@ import cats.implicits._ This should be all that you need, but if you'd like to learn more about the details of imports than you can check out the [import guide](typeclasses/imports.html). +## What is the difference between cats and scalaz? + +The goal for both Cats and [Scalaz](https://github.com/scalaz/scalaz) are the same: facilitate pure functional programming in Scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the Scala applications. Cats, on the other hand, aims to help build an [ecosystem](/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included) that Scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. + +Based on this core strategy, Cats took a [modular](/cats/#modularity) approach and focuses on providing core, [binary compatible](/cats/#a-namebinary-compatibility-and-versioning), [approachable](/cats/#approachability) and [efficient](/cats/#efficiency) abstractions. It provides a welcoming and supportive [community](https://gitter.im/typelevel/cats) governed +by the [typelevel code of conduct](https://typelevel.org/conduct). It also takes great effort in supplying a comprehensive and beginner-friendly [documentation](/cats/#documentation). + +We believe that both Cats and Scalaz strategies have their merits and shortcomings, and it's a positive thing for the scala community to have both. + ## Where is right-biased Either? Up through Cats 0.7.x we had `cats.data.Xor`, which was effectively `scala.util.Either`, but right-biased by default and with a bunch of useful combinators around it. In Scala 2.12.x `Either` From 9d83e026809f8f1b33c347f26ea818216633eb07 Mon Sep 17 00:00:00 2001 From: "Kai(luo) Wang" Date: Fri, 8 Sep 2017 12:46:53 -0400 Subject: [PATCH 09/14] Update faq.md --- docs/src/main/tut/faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/main/tut/faq.md b/docs/src/main/tut/faq.md index a3693e8ece..267af0ee26 100644 --- a/docs/src/main/tut/faq.md +++ b/docs/src/main/tut/faq.md @@ -40,7 +40,7 @@ This should be all that you need, but if you'd like to learn more about the deta The goal for both Cats and [Scalaz](https://github.com/scalaz/scalaz) are the same: facilitate pure functional programming in Scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the Scala applications. Cats, on the other hand, aims to help build an [ecosystem](/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included) that Scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. -Based on this core strategy, Cats took a [modular](/cats/#modularity) approach and focuses on providing core, [binary compatible](/cats/#a-namebinary-compatibility-and-versioning), [approachable](/cats/#approachability) and [efficient](/cats/#efficiency) abstractions. It provides a welcoming and supportive [community](https://gitter.im/typelevel/cats) governed +Based on this core strategy, Cats took a [modular](/cats/#modularity) approach and focuses on providing core, [binary compatible](/cats/#a-namebinary-compatibility-and-versioning), [approachable](/cats/#approachability) and [efficient](/cats/#efficiency) abstractions. It provides a welcoming and supportive environment for the [user community](https://gitter.im/typelevel/cats) governed by the [typelevel code of conduct](https://typelevel.org/conduct). It also takes great effort in supplying a comprehensive and beginner-friendly [documentation](/cats/#documentation). We believe that both Cats and Scalaz strategies have their merits and shortcomings, and it's a positive thing for the scala community to have both. From a64d2f41e26ac90a60e7609fdee251ead547d499 Mon Sep 17 00:00:00 2001 From: "Kai(luo) Wang" Date: Fri, 8 Sep 2017 13:09:32 -0400 Subject: [PATCH 10/14] Update faq.md --- docs/src/main/tut/faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/main/tut/faq.md b/docs/src/main/tut/faq.md index 267af0ee26..afb99be3bb 100644 --- a/docs/src/main/tut/faq.md +++ b/docs/src/main/tut/faq.md @@ -36,7 +36,7 @@ import cats.implicits._ This should be all that you need, but if you'd like to learn more about the details of imports than you can check out the [import guide](typeclasses/imports.html). -## What is the difference between cats and scalaz? +## What is the difference between Cats and Scalaz? The goal for both Cats and [Scalaz](https://github.com/scalaz/scalaz) are the same: facilitate pure functional programming in Scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the Scala applications. Cats, on the other hand, aims to help build an [ecosystem](/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included) that Scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. From 24c43d117c0c29c9ee611514cb974be8e0fcab82 Mon Sep 17 00:00:00 2001 From: "Kai(luo) Wang" Date: Fri, 8 Sep 2017 13:10:24 -0400 Subject: [PATCH 11/14] Update faq.md --- docs/src/main/tut/faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/main/tut/faq.md b/docs/src/main/tut/faq.md index afb99be3bb..1395b592c9 100644 --- a/docs/src/main/tut/faq.md +++ b/docs/src/main/tut/faq.md @@ -38,7 +38,7 @@ This should be all that you need, but if you'd like to learn more about the deta ## What is the difference between Cats and Scalaz? -The goal for both Cats and [Scalaz](https://github.com/scalaz/scalaz) are the same: facilitate pure functional programming in Scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the Scala applications. Cats, on the other hand, aims to help build an [ecosystem](/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included) that Scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. +Cats and [Scalaz](https://github.com/scalaz/scalaz) has the same goal: facilitate pure functional programming in Scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the Scala applications. Cats, on the other hand, aims to help build an [ecosystem](/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included) that Scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. Based on this core strategy, Cats took a [modular](/cats/#modularity) approach and focuses on providing core, [binary compatible](/cats/#a-namebinary-compatibility-and-versioning), [approachable](/cats/#approachability) and [efficient](/cats/#efficiency) abstractions. It provides a welcoming and supportive environment for the [user community](https://gitter.im/typelevel/cats) governed by the [typelevel code of conduct](https://typelevel.org/conduct). It also takes great effort in supplying a comprehensive and beginner-friendly [documentation](/cats/#documentation). From 24268e6eb5b4044ead28e8cbe5b5583ac3b4129e Mon Sep 17 00:00:00 2001 From: "Kai(luo) Wang" Date: Fri, 8 Sep 2017 13:30:19 -0400 Subject: [PATCH 12/14] Update faq.md --- docs/src/main/tut/faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/main/tut/faq.md b/docs/src/main/tut/faq.md index 1395b592c9..d660ffd317 100644 --- a/docs/src/main/tut/faq.md +++ b/docs/src/main/tut/faq.md @@ -38,7 +38,7 @@ This should be all that you need, but if you'd like to learn more about the deta ## What is the difference between Cats and Scalaz? -Cats and [Scalaz](https://github.com/scalaz/scalaz) has the same goal: facilitate pure functional programming in Scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the Scala applications. Cats, on the other hand, aims to help build an [ecosystem](/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included) that Scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. +Cats and [Scalaz](https://github.com/scalaz/scalaz) have the same goal: facilitate pure functional programming in Scala applications; the underlying core strategy is different. Scalaz took the approach of trying to provide a single batteries-included *standard library* for FP that powers the Scala applications. Cats, on the other hand, aims to help build an [ecosystem](/cats/#ecosystem) of pure FP libraries by providing a solid and stable foundation. These libaries can have their own styles and personalities, competing with each other, while at the same time playing nice. It is through this ecosystem of FP libraries (cats included) that Scala applications can be powered with "FP awesome-ness" and beyond by picking whatever best fit their needs. Based on this core strategy, Cats took a [modular](/cats/#modularity) approach and focuses on providing core, [binary compatible](/cats/#a-namebinary-compatibility-and-versioning), [approachable](/cats/#approachability) and [efficient](/cats/#efficiency) abstractions. It provides a welcoming and supportive environment for the [user community](https://gitter.im/typelevel/cats) governed by the [typelevel code of conduct](https://typelevel.org/conduct). It also takes great effort in supplying a comprehensive and beginner-friendly [documentation](/cats/#documentation). From fdb4e7f7db7e0e4db8f54f0acc5b9264fec529e6 Mon Sep 17 00:00:00 2001 From: "Kai(luo) Wang" Date: Fri, 8 Sep 2017 14:27:33 -0400 Subject: [PATCH 13/14] Update faq.md --- docs/src/main/tut/faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/main/tut/faq.md b/docs/src/main/tut/faq.md index d660ffd317..00aea6cc7a 100644 --- a/docs/src/main/tut/faq.md +++ b/docs/src/main/tut/faq.md @@ -43,7 +43,7 @@ Cats and [Scalaz](https://github.com/scalaz/scalaz) have the same goal: facilita Based on this core strategy, Cats took a [modular](/cats/#modularity) approach and focuses on providing core, [binary compatible](/cats/#a-namebinary-compatibility-and-versioning), [approachable](/cats/#approachability) and [efficient](/cats/#efficiency) abstractions. It provides a welcoming and supportive environment for the [user community](https://gitter.im/typelevel/cats) governed by the [typelevel code of conduct](https://typelevel.org/conduct). It also takes great effort in supplying a comprehensive and beginner-friendly [documentation](/cats/#documentation). -We believe that both Cats and Scalaz strategies have their merits and shortcomings, and it's a positive thing for the scala community to have both. +We believe that the Cats and Scalaz strategies have their merits and shortcomings, and it's a positive thing for the scala community to have both. ## Where is right-biased Either? Up through Cats 0.7.x we had `cats.data.Xor`, which was effectively `scala.util.Either`, but right-biased by default and with From c2a1e2726ca7c4d580350d63a5b7c202a17c8cc0 Mon Sep 17 00:00:00 2001 From: "Kai(luo) Wang" Date: Tue, 12 Sep 2017 12:38:58 -0400 Subject: [PATCH 14/14] Update faq.md --- docs/src/main/tut/faq.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/src/main/tut/faq.md b/docs/src/main/tut/faq.md index 00aea6cc7a..1cae1cb5df 100644 --- a/docs/src/main/tut/faq.md +++ b/docs/src/main/tut/faq.md @@ -42,8 +42,7 @@ Cats and [Scalaz](https://github.com/scalaz/scalaz) have the same goal: facilita Based on this core strategy, Cats took a [modular](/cats/#modularity) approach and focuses on providing core, [binary compatible](/cats/#a-namebinary-compatibility-and-versioning), [approachable](/cats/#approachability) and [efficient](/cats/#efficiency) abstractions. It provides a welcoming and supportive environment for the [user community](https://gitter.im/typelevel/cats) governed by the [typelevel code of conduct](https://typelevel.org/conduct). It also takes great effort in supplying a comprehensive and beginner-friendly [documentation](/cats/#documentation). - -We believe that the Cats and Scalaz strategies have their merits and shortcomings, and it's a positive thing for the scala community to have both. + ## Where is right-biased Either? Up through Cats 0.7.x we had `cats.data.Xor`, which was effectively `scala.util.Either`, but right-biased by default and with