My problem with Ruby is not so much the syntax. I kinda like this one-line-function feature, and I enjoyed it when using in C#.

My problem is the fact Ruby practitioners have a tendency ABUSE the usage of one-line-methods with LOTS of side-effects.

So it's not like Haskell one-line-methods.

Things that could be a function with 5 or 6 lines can become a class with as many methods. And instead of local variables, you now have to use instance variables (class fields).

For example, this is common in lots of codebases:

    class UserCreator
      def initialize(email)
        @email = email
      end
      
      def create_user
        create_user_object
        assign_admin_role
        assign_invite_permission
        call_invite_template
      end
      
      private
      
      attr_reader :email, :user
      
      def create_user_object
        @user = User.create(email)
      end
      
      def assign_admin_role
        user.roles << find_admin_role
      end
      
      def assign_invite_permission
        user.permissions << find_invite_permission
      end
      
      def call_invite_template
        find_invite_template.call(user: user)
      end
      
      def find_admin_role
        Roles.find_by(name: 'admin')
      end
      
      def find_invite_permission
        Permissions.find_by(name: 'invite')
      end
      
      def find_invite_template
        Templates.find_by(name: 'invite')
      end
    end

Sorry but this is not readable nor reasonable.

I encountered this in about 4 companies so far. Only one Ruby company I worked didn't do it. That was the company that actually had a very maintanable backend.