• Gork@lemm.ee
      link
      fedilink
      arrow-up
      3
      ·
      1 年前

      I never really understood the point of Lambda calculus. Why have an anonymous function? I thought it was good practice to meticulously segment code into functions and subroutines and call them as needed, rather than have some psuedo-function embedded somewhere.

      • rabirabirara@programming.dev
        link
        fedilink
        arrow-up
        4
        ·
        1 年前

        I think you’re confusing lambdas with lambda calculus. Lambda calculus is more than just anonymous functions.

        To put it extremely simply, let’s just say functional programming (the implementation of lambda calculus) is code with functions as data and without shared mutable state (or side effects).

        The first one increases expressiveness tremendously, the second one increases safety and optimization. Of course, you don’t need to write anonymous functions in a functional language if you don’t want to.

        As for why those “pseudo-functions” are useful, you’re probably thinking of closures, which capture state from the context they are defined in. That is pretty useful. But it’s not the whole reason lambda calculus exists.

      • linuxduck@nerdly.dev
        link
        fedilink
        arrow-up
        2
        ·
        1 年前

        I suppose it has to do with being stateless.

        I just loved learning about lambda calculus.

        I think the idea is to remove complexity by never dealing with state, so you just have one long reduction till you get to the final state…

        But someone who’s more into lambdas etc should speak about this and not me (a weirdo)

      • Zangoose@lemmy.one
        link
        fedilink
        arrow-up
        2
        ·
        1 年前

        See the other comments about lambdas vs. lambda calculus, but lambdas are supposed to be for incredibly simple tasks that don’t need a full function definition, things that could be done in a line or two, like simple comparisons or calling another function. This is most useful for abstractions like list filtering, mapping, folding/reducing, etc. where you usually don’t need a very advanced function call.

        I was always taught in classes that if your lambda needs more than just the return statement, it should probably be its own function.