Functional Programming Patterns for Mere Mortals - Daniel Chambers

แชร์
ฝัง
  • เผยแพร่เมื่อ 23 พ.ย. 2024

ความคิดเห็น • 18

  • @szabo369peter
    @szabo369peter 5 ปีที่แล้ว +12

    Very nice! Having functor, applicative, and monad side-by-side (being able to observe the similarities and the differences) made the different parts just click into their respective places. Thanks!

  • @chuckadams7134
    @chuckadams7134 6 ปีที่แล้ว +5

    I'm perpetually a Haskell beginner, but I did get over monads a while ago. Still, it was nice to see the relationship between map, apply, and bind spelled out so clearly. A slightly longer aside on how we got to "flatMap" (how bind works out to map+join) wouldn't have gone amiss, but I understand you only have so much time in one presentation. Great presentation, taught me a little F# in the bargain :)

  • @kahnfatman
    @kahnfatman 2 ปีที่แล้ว

    Thank you! You have beautifully explained Functor, Applicative and Monad the way developers can understand. BEAUTIFUL!

  • @hansschenker
    @hansschenker 3 ปีที่แล้ว +1

    Deep dive functional with very practical samples - a seldom seen combination - thank's a lot for this presentation - Daniel Chambers!!

  • @parthapal8380
    @parthapal8380 7 ปีที่แล้ว +7

    Excellent explanation of functional patterns !

  • @TheDarkOne629
    @TheDarkOne629 3 ปีที่แล้ว

    Finally I understand >>= !!! :D
    Thank you so much, mr. Chambers

  • @Kamiru96
    @Kamiru96 6 ปีที่แล้ว +4

    that witcher wallpaper at 32:42 :>

  • @ShotterManable
    @ShotterManable 3 ปีที่แล้ว

    Is the 4:49 function add right highlighted?
    I though it stands for two parameters : Int and Int (Int -> Int) and returns Int (last -> Int) . I'm newbie to haskell so I might be wrong

    • @nap247
      @nap247 3 ปีที่แล้ว +1

      yes, the highlight is right
      add :: Int -> Int -> Int
      add x y = x + y
      sure, the most intuitive way to interpret this, is that add takes two numbers as arguments and returns their sum, but functions can be transformed to take only one argument and return a function with one less argument than the original, this is called currying, and I think in Haskell all functions are actually curryed.
      add :: Int -> (Int -> Int)
      add x = \y -> x + y
      in this case add only takes the first number to be added (this is called partial function application), and returns an (unnamed/lambda) function which will take an Int (the second number to be added) and return the sum.
      let us call the curryed function with the number 1 (partial application), and name the returned function increment:
      increment = add 1
      now when we call increment with whatever integer, it will add one to it (increment = lambda y -> 1 + y)

  • @jvcmarc
    @jvcmarc 5 ปีที่แล้ว +5

    so... this is all just Railway Oriented Programming?

  • @simonpeggboard4004
    @simonpeggboard4004 2 ปีที่แล้ว

    "I don't answer Questions' :)

  • @SelvaavleS
    @SelvaavleS 7 ปีที่แล้ว +1

    awesome !!!

  • @edgeeffect
    @edgeeffect 2 ปีที่แล้ว

    JavaScript is only an OO, Imperitive language if you're doing it wrong. ;)

  • @EmberMage8192
    @EmberMage8192 2 ปีที่แล้ว +3

    Way too dry and abstract talk, feels like an algebra class on derivatives for the first time. I, myself know functional programming more or less, but it was hard to follow. This is definitely not for mere mortals.

  • @aichpvee
    @aichpvee 3 ปีที่แล้ว +1

    If I had a dollar for every time someone giving one of these talks apologized for using Haskell, a language that obviously no one in the audience will be familiar with...