eed3si9n
eed3si9n.com · Personal blog · on HN since 2012
Eugene Yokota (eed3si9n), a Scala developer and sbt contributor, writes Scala tutorials on Scalaz and Cats, plus career reflections.
What HN saysHN commenters recommend his Herding Cats and Learning Scalaz tutorial series as resources for learning functional programming in Scala.
22HN people shared it
13linked it in comments
13stories submitted
177story points
5 months agolast shared
2012people per year2026
Most-shared posts
- 1Herding Cats with Scala4 people · 2 points · first shared 2015 · discussion on HN
- 2Learning Scalaz3 people · 49 points · first shared 2015 · 3 comments on HN
- 3Scalaz cheat sheet2 people · 1 points · first shared 2014 · discussion on HN
- 4Either2 people · first shared 2016
- 52 Years at Twitter1 people · 107 points · first shared 2022 · 137 comments on HN
- 6Six years at Lightbend1 people · 8 points · first shared 2020 · 1 comments on HN
- 7Tetrix in Scala1 people · 2 points · first shared 2013 · discussion on HN
- 8Scopt 4: command line options parsing in scala1 people · 2 points · first shared 2018 · discussion on HN
- 9Scala: Revisiting Implicits Without Import Tax1 people · 1 points · first shared 2012 · discussion on HN
- 10Sbt 2.0.01 people · 1 points · first shared 2026 · discussion on HN
- 11Console games in Scala1 people · 1 points · first shared 2018 · discussion on HN
- 12Sbt 1.4.11 people · 1 points · first shared 2020 · discussion on HN
- 13Shutting Down the Goldmine1 people · 1 points · first shared 2026 · discussion on HN
- 14Sbt and the Miners of the Wild West1 people · 1 points · first shared 2026 · 1 comments on HN
- 15Tagged type1 people · first shared 2014
What HN people wrote when they linked it
Milner08 · 2021-05-14
The thing with Scala is it depends on the pattern you want to use. I am a big advocate of it, and the function pattern being used fully with something like Cats or ZIO. However I would not suggest starting there.
I would start by playing about with the syntax and writing standard OOP code, as its probably what you're most familiar with.
When you want to dive into the power of FP then I recommend http://eed3si9n.com/herding-cats/. Its basically a companion to the Haskell book 'Learn you a haskell' (http://learnyouahaskell.com/) that takes the theory coming up in that book and translates it to Scala. I found it the most direct explanation of the different types and theories (Monads, Functors, Applicative, etc).
lmm · 2016-09-30
I'd suggest http://eed3si9n.com/herding-cats/ . Though a lot of the time I find it's best to wait until you have a concrete use case, otherwise the concept is too abstract to make sense.
runT1ME · 2016-02-20
https://github.com/scalaz/scalaz
Monad Transformers for one. Traverse/Sequence are another super common (amazing) pattern that requires abstracting over types.
http://eed3si9n.com/learning-scalaz-day12
is a nice tutorial series on it.
AdieuToLogic · 2015-11-10
Travis Brown has written up some great articles on advanced Scala topics and this one does not disappoint. Well done and worth the read.
Some may find the Shapeless feature overview[1] a good read as well. And for people interested in history, I found Mr. Sabin's announcement of Shapeless[2] to be both interesting and valuable for its links related to higher-kinded programming topics.
I also found "learning Scalaz"[3] a very good read, with the page discussing Isomorphisms[4] relevant to Mr. Brown's article.
1 - https://github.com/milessabin/shapeless/wiki/Feature-overview%3A-shape…
2 - http://milessabin.com/blog/2011/12/19/shapeless-preview/
3 - http://eed3si9n.com/learning-scalaz/
4 - http://eed3si9n.com/learning-scalaz/Isomorphisms.html
krenoten · 2015-02-12
There is an awesome book called "Functional Programming in Scala" that has a lot of great questions to work along to, and is great for somebody interested in both Haskell and Scala but doesn't assume prior experience with things like combinators and monads. If you are pretty far down the Haskell route and want to learn about one of the more advanced type-level libraries, You may want to jump into http://eed3si9n.com/learning-scalaz/ and use https://twitter.github.io/scala_school/ as a quick reference or intro. If you have the time and desire, a lot of people swear by a cover-to-cover reading of Odersky's "Programming in Scala".
adriaanm · 2012-01-09
I think it would be great if we could replace implicits by:
1) a simple mechanism for "enrichment" (aka. retro-active extension, virtual classes)
2) functional type-level computation (as opposed to the mini-prolog engine that is implicit search + type inference).
Reducing complexity is complicated, unfortunately. We [have been|are] thinking about both of these alternative features, though.
---
ps: The following part of the article is inaccurate: "Turns out that Scala will search up to one level up the type hierarchy for a matching shape for the implicit."
Check out the "implicits without the import tax" part of http://eed3si9n.com/implicit-parameter-precedence-again. The implicit scope includes all the superclasses (and their companion objects) of all the parts of the type of the implicit value that's being resolved.
pas · 2018-07-13
Thanks for the detailed response and concrete examples!
Reading signatures is one thing (and zip is "easy"), but without examples it doesn't really help in most of the cases. Because even if I know the concept, I don't know when it comes handy. (For example I just looked at Forall ( https://static.javadoc.io/org.scalaz/scalaz_2.12/7.2.24/scalaz/Forall.… ... Forall is an endofunctor in an endofunctor category ... ah yes!), and then there are tools that come with labels (DList's doc page: nice for append heavy workloads, eg. logging; yes, great, what's Forall good for? What's Strong? Why Alpha exists? What's =>: ? That's not even documented :( It cannot be searched for https://github.com/scalaz/scalaz/search?utf8=%E2%9C%93&q=%3D%3E%3A… ... It's not on the cheatsheet http://eed3si9n.com/scalaz-cheat-sheet .. .I mean it's on it, but it is only used, not defined. etc.)
That's not a type reading thing. That's the bad documentation, and the learner-unfriendly naming convention.
ackfoobar · 2022-02-17
Scala has overloading, currying not-by-default, optional and named parameters. Some similar stuff exist*, but they interfere with those Scala features, which I value more.
* https://eed3si9n.com/learning-scalaz/Applicative.html
I know the Haskell operators, but the Idris syntax are new to me.
BTW * has to be escaped with a \.
sideeffffect · 2020-09-03
If I understood John's motivation from the video, it's that this enables the Flatten structure to be inspectable, because the innards are not hidden behind an opaque closure (A => F[B]), as is the case in regular Monad.
Btw, this is a problem that the "Selective applicative functor" too aims to alleviate.
You can read more about the inspectability problem (and Selective) at http://eed3si9n.com/selective-functor-in-sbt
The context there is sbt, which is a build tool, but I'm sure the inspectability plays role in many other areas. Note, how he contrasts "Applicative composition" and "Monadic composition".
AheadOfTime295 · 2020-04-11
idobai · 2016-06-30
> So you're not supposed to tell people where errors occur in Scala?
You're supposed to use the types `Option` and `Either` or if you're into scalaz then \/ (http://eed3si9n.com/learning-scalaz/Either.html) and Validation (http://eed3si9n.com/learning-scalaz/Validation.html). Throwing exceptions is a childish way to handle errors in FP.
donjigweed · 2015-11-15
The cool kids are quickly abandoning scalaz for cats [1], in fact the exodus may already essentially be complete, as evidenced by the author's subsequent work [2]. I guess that's what happens when your project just attracts too many _ssholes.
[1] https://github.com/non/cats
[2] http://eed3si9n.com/herding-cats/
yummyfajitas · 2014-01-14
If we want to call any of the methods on the wrapped type we have to call directly to the wrapped type violating Demeter.
You can also use tagged types:
http://eed3si9n.com/learning-scalaz/Tagged+type.html
But most of the methods will untag the type. I.e., ("foo" @@ ValidJsonString).substring(3,7) will be a String, not a String @@ ValidJsonString.