• Solrac@lemmy.world
    link
    fedilink
    arrow-up
    72
    ·
    5 个月前

    Finally, someone understands that Allman is not that great, and that Kernighan & Ritchie is the way to go. Also, Haskell, my guy, you good? Lisp, are you ok? Do I need to call your parents?

    • gerryflap@feddit.nl
      link
      fedilink
      arrow-up
      9
      ·
      5 个月前

      I’ve written Haskell quite a bit, and I don’t fully understand why this is called Haskell style. Haskell code looks nothing like this, the syntax is completely different. For Haskell’s syntax I think it works fine, because I never noticed something weird. But this code in “Haskell style” looks absolutely insane

      • t_veor@sopuli.xyz
        link
        fedilink
        arrow-up
        11
        ·
        5 个月前

        It’s sometimes called comma-leading style where you move all the special characters to the front of the line and it is exceedingly common in Haskell, possibly due to how Haskell treats significant whitespace. You’ve surely seen list definitions that look like this:

        someList =
          [ 1
          , 2
          , 3
          ] 
        

        or a data definition like this:

        data Color
          = Red
          | Green
          | Blue
          | RGB Int Int Int
          deriving (Show, Eq)
        

        or a list of module exports like this:

        module Foo
          { bar
          , baz
          , quux
          } 
        

        Or in a long function type declaration where the arrows are moved to the start of the line, or a record definition, etc. etc.

  • Gork@lemm.ee
    link
    fedilink
    arrow-up
    63
    ·
    5 个月前

    All of those are heretical. The one True Language is Brainfuck, where the coding syntax for Hello World is

    ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.

  • blindsight@beehaw.org
    link
    fedilink
    arrow-up
    54
    ·
    edit-2
    5 个月前

    idk, Allman is very readable. Easy to scan vertically to find the matching open brace. Not quite as vertically-space efficient as the best way, but it’s not offensive.

    • hardware26@discuss.tchncs.de
      link
      fedilink
      arrow-up
      8
      ·
      5 个月前

      In my first ever programming class textbook was using Allman. Probably for this reason, it is easy for a beginner to match braces. It is a lot loss common industry to my knowledge.

      • blindsight@beehaw.org
        link
        fedilink
        arrow-up
        6
        ·
        5 个月前

        I literally don’t understand. I’ve read your comment several times and I don’t know what you’re talking about. Sorry!

        Did you think I was saying that made Allman better than the best way? Because it’s easy to scan vertically the best way, too. It’s just also easy with Allman, so it’s not offensive.

        • ubergeek77@lemmy.ubergeek77.chat
          link
          fedilink
          arrow-up
          6
          ·
          5 个月前

          I don’t think they were disagreeing with you, I think they were just trying to say:

          You shouldn’t need braces to be vertically aligned if your code is uniformly indented. Then you can easily see what code is paired together just by their indentation level.

          Of course this is not always true if you’ve got a bunch of crazy nested indentation pushing things off to the right.

      • psycho_driver@lemmy.world
        link
        fedilink
        arrow-up
        3
        ·
        5 个月前

        If you use if (blah) { then when you fold your code you still see the { but not the closing } (I suppose some IDEs might be smart enough to do something about this, but when not it looks like your code has an overbite).

        And then you’ve got a mental disorder if you indent your opening and closing brace more than the statement spawning them.

        • JackbyDev@programming.dev
          link
          fedilink
          English
          arrow-up
          4
          ·
          5 个月前

          Yeah, I just don’t see why IDEs couldn’t make them all fold in the same way. It’s trivial. I don’t see it as a valid complaint.

    • kryptonianCodeMonkey@lemmy.world
      link
      fedilink
      arrow-up
      32
      ·
      edit-2
      5 个月前

      All line breaks. Just one tower of code.

      class
      HelloWorld
      {
      public
      static
      void
      main(String[]
      args)
      {
      System.out.println("Hello,
      World!");
      }
      }
      
      • eupraxia@lemmy.blahaj.zone
        link
        fedilink
        English
        arrow-up
        15
        ·
        edit-2
        5 个月前

        as always, c++ lets us do better in breathtakingly elegant fashion:

        #\
        i\
        n\
        c\
        l\
        u\
        d\
        e\
         \ 
        &lt;\
        i\
        o\
        s\
        t\
        r\
        e\
        a\
        m\
        >
        

        finishing out hello world is left as an exercise to the reader, but the advantages and superior performance of this format should be obvious

  • barsoap@lemm.ee
    link
    fedilink
    arrow-up
    23
    ·
    edit-2
    5 个月前

    Noone writes Haskell like that. People generate Haskell like that because layout syntax is a fickle beast to generate and outputting braces means you can make mistakes in layout without breaking things, the way the braces and semicolons are output emphasise how they actually don’t matter, they’re also easy to delete in a text editor.

    Also it matches up with other Haskellisms, e.g. lists:

    let foo = [ bar
              , baz
              , quux
              ]
    

    See how it’s immediately apparent that you didn’t miss a single comma? It’s also trivial to match up opening and closing brackets like that, even in deeply nested situations.

    Not doing that is actually my main pet peeve with Rust’s standard formatting.

        • 7heo@lemmy.ml
          link
          fedilink
          arrow-up
          1
          ·
          edit-2
          5 个月前

          Hear me out: brainfuck, but with parentheses only.

          >    )))
          <    (((
          +    ())
          -    (()
          .    ()(
          ,    )()
          [    )((
          ]    ))(
          

          Hello world example:

          ()))(((()(())))(())(())))))()))))(()
          (()(()(()(()(((((())(((((()(()((((()
          (()(()))()))(()()()))))))))())()()))
          )))()(()(())())()))((()()))))(((((((
          ((((((()(())())())()((()(()(()(()(()
          (()()((((((((()()())))))))))))())()(
          

          Ancient aliens meme with the caption "LIPS!!"

          Python transpiler:

          #!/usr/bin/env python
          """Lipsfuck to brainfuck transpiler"""
          
          from sys import stdin
          
          OPS = {")))": '>', "(((": '<',
                 "())": '+', "(()": '-',
                 "()(": '.', ")()": ',',
                 ")((": '[', "))(": ']'}
          
          
          def main():
              """Obvious main procedure"""
              _d = ''.join(stdin.readlines()).rstrip('\n')
              for _op in [_d[x:x+3] for x in
                          range(0, int(len(_d)), 3)]:
                  print(OPS[_op], end='')
              print()
          
          
          if __name__ == "__main__":
              main()
          
  • AVincentInSpace@pawb.social
    link
    fedilink
    English
    arrow-up
    14
    ·
    edit-2
    5 个月前

    People code like that???

    People indent braces more than the line before and less than the line after?

    Words cannot express my displeasure