λ · 🔊 ≟ The Greatest Hits

This time we tackle the thorny issue of how you get anything done when you're not allowed to change anything. If the idea of immutability seems strange or even impossible, then we've got you covered.

5: Immutability

To write a program is to deal with uncertainty. Sometimes it feels like there's nothing we can count on and null (or undefined) is as pervasive as any other construct in our languages. However this does not have to be! LambdaCast dives into the thorny problem of null, and more broadly the potential for values not to exist and offers up some alternatives.

Aaron's "and then" reference: https://www.youtube.com/watch?v=CkdyU_eUm1U

LambdaCast

6: Null And Friends

Oh category theory, bastion of strange and wonderful terminology, (some might say terrible and inaccessible). Love it or hate it, you're likely to run into some terms from category theory if you spend enough time in FP land. In this episode we'll tackle some of the terms that make up the 'ism family of terms, morphism, endomorphism, isomorphism, homomorphism, and catamorphism.

Denotational design talk: https://www.youtube.com/watch?v=bmKYiUOEo2A

8: Morphisms

Abstraction takes on a different meaning amongst functional programmers. This episode we dig into how parametric polymorphism is an essential tool in developing well behaved abstractions that transcend simply being a solution to your individual problem.

John Degoes polymorphism post
http://degoes.net/articles/insufficiently-polymorphic

When x, y, and z are great variable names
http://blog.ploeh.dk/2015/08/17/when-x-y-and-z-are-great-variable-names/

9: Polymorphism And Abstraction

Partial application and currying are a feature that is often mysterious to the uninitiated. Why do functional programmers care about such a seemingly useless thing? Partial application is an important part of the "FP toolkit" and we'll why and provide use cases for the importance of having partial application.

Simple made easy - https://www.infoq.com/presentations/Simple-Made-Easy
Scott Wlaschin https://fsharpforfunandprofit.com/fppatterns/ 
https://vimeo.com/113588389  - OO Patterns to FP Patterns talk

Lodash/fp - https://github.com/lodash/lodash/wiki/FP-Guide
Ramda - http://ramdajs.com/

10: Partial Application

Into the icy maw of category theory starting with Monoids! In reality we find out it's not actually all that scary and there are some really fantastic things that we gain by understanding these basic categorical concepts.

We now have a twitter account! Follow us at https://twitter.com/lambdacast
We also now have a patron account if you're looking to support the show: https://www.patreon.com/lambdacast

Show Notes:

Haskell Diagrams library
http://projects.haskell.org/diagrams/doc/quickstart.html
https://vimeo.com/84104226

Chris Wilson pointed out that Haskell's Typeclassopedia has a nice chart of the relationship between Haskell's implementation of many categorical structures: https://wiki.haskell.org/wikiupload/d/df/Typeclassopedia-diagram.png

12: Monoids

Algebraic Data Types (ADTs) are one of the most distinguishing features of statically typed functional languages. Come learn why they exist, how you can use them, and how they change your design. 

Join the FP community at http://fpchat.com
Support us on Patreon at http://www.patreon.com/lambdacast
Follow us on Twitter: http://twitter.com/lambdacast

Show Notes:

Denotational Design with the example of a Poker game
https://fsharpforfunandprofit.com/ddd/

13: ADTs

The kind of type system a functional language uses has a large impact on the way you use that language. In this episode we discuss the tradeoffs involved in using a static or dynamic language.

Our patreon sponsors this month:

Javier Troconis
Andrew Newman
Derek Morr
Olov Johansson

Show Notes:

Philip Wadler Talk: https://www.infoq.com/presentations/category-theory-propositions-principle

Denotational Design 

Scott Wlaschin Poker Implementation
https://exit.sc/?url=https%3A%2F%2Ffsharpforfunandprofit.com%2Fddd%2F

Conal Elliot presentation on Denotational Design
https://www.youtube.com/watch?v=bmKYiUOEo2A

Our recomendation for a DDD book
https://www.amazon.com/Patterns-Principles-Practices-Domain-Driven-Design/dp/1118714709

14: Dynamic and Static Languages

Going deeper down the category theory rabbit hole, we explore one of the most common and useful abstractions in the functional programming world. You're likely already familiar with Functors but just didn't know it yet.

Episode 16 patrons:
Chris Krycho
Tyler Harper
George Webster

Show Notes:

Functor
    map :: (a -> b) -> f a -> f b
Bifunctor
    bimap :: (a -> b) -> (c -> d) -> f a c -> f b d
Profunctor
    dimap :: (a -> b) -> (c -> d) -> f b c -> f a d

Phil Freeman's talk on Profunctors: https://www.youtube.com/watch?v=OJtGECfksds

16: Functors

Building on the power of functors we examine a few scenarios where a normal Functor is problematic. Fortunately, there is a closely related structure known as an Applicative Functor that can provide the capabilities to solve a broader range of problems.

Episode 17 patrons:

Chad Wooley
David Keathley
Andre Carvalho

Show Notes:

Coconut programming language: http://coconut-lang.org/

Hack nights instead of presentations: http://tech.noredink.com/post/142283641812/designing-meetups-to-build-better-communities

class Functor f => Applicative f where
  pure :: Applicative f => a -> f a
  ap :: Applicative f => f (a -> b) -> f a -> f b

Example of applicative usage:

pure (+) <*> Just 3 <*> Just 2 -- this results in Just 5
(+) <$> Just 3 <*> Just 2 -- this is the same as above
liftA2 (+) (Just 3) (Just 2) -- alternate form using lift instead of infix operators

17: Applicative Functors

Monads, the promised land of functional programming. Or at least with all the hype they'd better be! Come join the cast as we demystify this overhyped structure that has become an indispensable part of many functional programmer's toolkits.

Episode 18 patrons:
Pluton
Tim Buckley
Huge shout out to Marcus Nielsen

Show Notes:
bind :: m a -> (a -> m b) -> m b

Example of do syntax vs using bind aka >>=:
main = do
foo <- doMonadyThing
foo2 <- doOtherMonadyThing foo
pure (whatever foo foo2)

main = doMonadyThing
>>= (\foo -> doOtherMonadyThing foo 
>>= (\foo2 -> pure (whatever foo foo2))
)

Extracting a value from a Maybe

extract :: Just Int -> Int
extract foo = case foo of
Just num -> num
Nothing -> 0

Railroad oriented programming talk by Scott Wlaschin
fsharpforfunandprofit.com/rop/

FP Chat Slack Community: https://fpchat-invite.herokuapp.com

λ · 🔊 ≟ The Greatest Hits

tomswift