I actually don't like this change for the reason you pointed out: it's hard to see whats private and whats not.

I think that it's not a big deal to put private before each def, I just don't find it that common of a thing to do. I like the way that method declarations are self-contained in that you can reason about one by itself. This is a minor thing, but it breaks that for avoiding such a small bit of extra typing and I definitely don't think it's worth it.

I agree with @RX14 on this, we can really easilly miss this little keyword.

I've a (false?) good another idea, why not having a block syntax to have an indentation like:

class Foo
  def foo # public by default
  end

  private # everything that follows is private
    def bar
    end
  end

end

But this adds another indentation.

Yeah, we could do that with:

private begin
  def bar
  end
end

but the indentation it creates is ugly... I think Ruby's been fine in the last 25 years with that, and many wanted it for a long time.

We can still have private def for single private/protected methods? Then I'm fine with this.

Let's not copy Ruby this time.
When writing Ruby, I always miss the Crystal way of defining private methods. It's explicit and also impossible to miss the private keyword no matter how big the file is.

@sdogruyol That's not just Ruby, C#/C++ or Java does the same for instance.

Ruby lets you pass a symbol to those keywords so you can do private :foo, and since all method definition return a symbol, doing private def foo; end in ruby is allowed. So, crystal already copies ruby in that sense.

I actually didn't even notice this wasn't possible in crystal since I've enjoyed being more explicit. If your only basis is that this makes it more DRY, and less typing, an alternative could also be elixir style. Using something likedefp foo, but that feels more like an alias, and we don't use alias in crystal.

I guess it might not be good after all.

@asterite maybe let's vote on that?

I've another bad idea (sorry again).
For now for methods we have:

def foo
  raise "error"
rescue
  puts "rescued"
ensure
  puts "ensured"
end

The idea is to also apply this concept to classes, by just removing one indentation to the original implementation:

class Foo
  def is_public
  end
protected
  def is_protected
  end
private
  def is_private
  end
end

It's clearer because this forces to group similarly scoped methods together, and the key word in on the same line as class, not the one of defs.

Just keep it as it is: private def and protected def. There is nothing bad about that.