22 個單集

LambdaCast is a podcast about functional programming for working developers. Our focus is to describe concepts using clear everyday language without watering anything down. If you've ever been curious about FP but were turned off by the jargon or unfamiliar concepts, this is the place to be.

Thoughts, comments, critique? Send them to contact@lambdacast.com

Music is "Lively Lumpsucker" by Kevin MacLeod (incompetech.com)
Licensed under Creative Commons: By Attribution 3.0 License

Icon is a modification of "Communicator" by Juan Pablo Bravo (https://thenounproject.com/term/communicator/47500/)
Licensed under Creative Commons: By Attribution 3.0 License

LambdaCast LambdaCast

    • 科技

LambdaCast is a podcast about functional programming for working developers. Our focus is to describe concepts using clear everyday language without watering anything down. If you've ever been curious about FP but were turned off by the jargon or unfamiliar concepts, this is the place to be.

Thoughts, comments, critique? Send them to contact@lambdacast.com

Music is "Lively Lumpsucker" by Kevin MacLeod (incompetech.com)
Licensed under Creative Commons: By Attribution 3.0 License

Icon is a modification of "Communicator" by Juan Pablo Bravo (https://thenounproject.com/term/communicator/47500/)
Licensed under Creative Commons: By Attribution 3.0 License

    22: Structuring Data

    22: Structuring Data

    This time we discuss the way data tends to be structured in functional languages and some of the similarities with databases and REST.

    Episode 22 patrons:
    Jason Sooter
    Jamie Rolfs
    Christian Hamburger
    Daniel Svensson
    Di Wen
    Iulian Bojinca
    Jonathan Fishbein
    Nathan Sculli
    Nels Wadycki
    Paul Naranja
    Peter Tillemans
    Thomas Varney
    Tyler Harper
    weila wei
    Dawn (שחר)


    Show Notes:
    CPPCast: http://cppcast.com/

    John Soo - Sharing in Haskell
    https://wiki.haskell.org/Sharing
    https://stackoverflow.com/questions/1105765/generating-fibonacci-numbers-in-haskell

    Alejandro’s link to Phantom Types article: https://www.objc.io/blog/2014/12/29/functional-snippet-13-phantom-types/

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

    Intro/Outro music is "Lively Lumpsucker" by Kevin MacLeod (incompetech.com)
    Licensed under Creative Commons: By Attribution 3.0 License

    • 44 分鐘
    21: Type Parameters

    21: Type Parameters

    You may have seen generics in C#, Java, or Swift but there are a lot of very useful patterns using generics that rarely get used in an OO context. In this episode, we explore Type Parameters (aka generics) from a functional perspective and how using them can improve the structure of your applications.

    Episode 21 patrons:
    Scott Smith
    Joel McCracken
    Hakon Rossebo
    Seth Utecht
    Christophe Pereira da Conceicao
    E. Mulder

    Show Notes:
    Add a type parameter video: https://www.youtube.com/watch?v=BHjIl81HgfE
    Matt Parson's follow-up post: http://www.parsonsmatt.org/2017/04/08/maybe_use_a_type_parameter.html
    Stephen’s Twitter: https://twitter.com/S11001001
    Type Parameter example in Scala: https://typelevel.org/blog/2015/09/21/change-values.html

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

    • 1 小時 14 分鐘
    20: Laziness

    20: Laziness

    Lazy evaluation is not normally something you hear programmers discussing but there is a lot of power available if you know how to use it. This episode we'll examine the differences between lazy and strict evaluation and look at use cases for laziness.

    Episode 20 patrons:
    Marcus Nielsen
    Steven Loe
    Ted Yavuzkurt
    Michael Meyers
    Szymon Beczkowski
    Parl Naranja
    Paul Brabban
    Jason Sooter

    Show Notes:
    Memoization: https://codeburst.io/functional-memoization-in-javascript-adec62508bd0
    Using IEnumerable in C# to generate an infinite sequence: https://brianreiter.org/2011/01/14/ienumerable-is-lazy-and-thats-cool/

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

    • 57 分鐘
    19: Starting A Project Functionally

    19: Starting A Project Functionally

    Logan walks us through what his experience has been starting a JavaScript project in a functional style and using the best FP tools he can get in the JavaScript ecosystem.

    Episode 19 patrons:
    Nathan Sculli
    Lee Beck
    David Joyner
    Nihohit
    Charles Winebrinner

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

    • 1 小時
    18: Monads

    18: Monads

    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 >= (\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

    • 1 小時 24 分鐘
    17: Applicative Functors

    17: Applicative 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

    • 58 分鐘

熱門科技 Podcast

聽眾訂閱的還有