Made with KolourPaint and screenshots from Kate (with the GitHub theme).

  • @sph@lemmy.world
    link
    fedilink
    1
    edit-2
    15 hours ago

    Go’s syntax is vastly superior once you have more complicated signatures, then the left-to-right truly matters. For example a variable that contains a pointer to a function that takes a function and an int and returns another function (like a decorator).

    In C the order becomes very hard to understand and you really have to read the thing several times to understand the type of fp:

    int (*(*fp)(int (*)(int, int), int))(int, int)

    In Go, you can just read from left to right and you can easily understand what f’s type is:

    f func(func(int,int) int, int) func(int, int) int

    It’s just much more readable.

    See: https://go.dev/blog/declaration-syntax

      • @ThirdConsul@lemmy.ml
        link
        fedilink
        12 hours ago

        Wait until you learn about transducers (Are they in Go? If not natively, someone definitely ported them) and the abominations fp people code with them.

      • @sph@lemmy.world
        link
        fedilink
        2
        edit-2
        3 hours ago

        This obviously just illustrates a point, but callbacks and decorators are not uncommon. And iterators are exactly like that:

        type (
        	Seq[V any]     func(yield func(V) bool)
        	Seq2[K, V any] func(yield func(K, V) bool)
        )
        

        Which is very readable.

        • @phlegmy@sh.itjust.works
          link
          fedilink
          13 hours ago

          Callbacks and decorators are fine, but callbacks/decorators to a function which itself takes a function pointer and returns another function pointer are crazy.

          I’ve thankfully never had to use recursive callbacks or decorators, but it seems like it could very quickly become difficult to keep track of.