Should ruby go the haml route and uses significant whitespaces?

Before I start, let me get something straight: I’m not saying it would be a good or bad idea… I’m just asking the question.
I must say that my first experience with a significant whitespace language was a disaster. The first time I had to use Python was on a server via ssh. I was in a hurry and wanted to monkey patch some buggy script I had installed. So without thinking too much I opened the script with a text editor called nano. The problem is that a TAB in nano produces between 173 and 177 white spaces. Realizing this I decided to refrain from indenting one line or two because it was too ugly and unreadable. Then python told me that I could not do this… and at the time I remember thinking it was unacceptable that a script start to malfunction just because of a few missing whitespaces. Anyway, I spent some long minutes trying to fix a few indentation issues (in nano! I still didn’t realize it was the source of the problem) and it was very tedious. Had I try debugging the python script on my local computer with gedit for example, things would surely have turned out differently.
Then Haml came… and I stayed away
This unpleasant experience I had with Python had a rather negative side effect: It made me completely ignore Haml for a long time, which is sad because it is such a great alternative to erb.
But now I use Haml, and I really like it. Not having to “close my tags” is more satisfying than I thought it would be. I always delight when I realize I was about to write a “- end” tag to close a “- @items.each” loop or something like that. I don’t have to! Less typing, less noise, cleaner, prettier, I love this! Wouldn’t be nice if we could do away with the “end” keyword in ruby as well?
Just to give us an idea, here is how an actual class from the Haml gem would look like if it was written in Significant Whitespace ruby:

class ParseNode <, :line, :value, :parent, :children)
  def initialize(*args)
    self.children ||= []
  def inspect
    text = &quot;(#{type} #{value.inspect}&quot;
    children.each {|c| text &lt;&lt; &quot;\n&quot; &lt;&lt; c.inspect.gsub(/^/, &quot;  &quot;)}
    text + &quot;)&quot;

Great, it sill looks like ruby. We just removed some noise to make it even more readable.
Let's convert a longer method, still from the Haml gem, to see how it would look like:

def parse_new_attributes(line)
  line = line.dup
  scanner =
  last_line = @index
  attributes = {}
  loop do
    name, value = parse_new_attribute(scanner)
    break if name.nil?
    if name == false
      text = (Haml::Shared.balance(line, ?(, ?)) || [line]).first
      raise;Invalid attribute list: #{text.inspect}.&quot;, last_line - 1)
    attributes[name] = value
    if scanner.eos?
      line &lt;&lt; &quot; &quot; &lt;&lt; @next_line.text
      last_line += 1
  static_attributes = {}
  dynamic_attributes = &quot;{&quot;
  attributes.each do |name, (type, val)|
    if type == :static
      static_attributes[name] = val
      dynamic_attributes &lt;&lt; inspect_obj(name) &lt;&lt; &quot; =&gt; &quot; &lt;&lt; val &lt;&lt; &quot;,&quot;
  dynamic_attributes &lt;&lt; &quot;}&quot;
  dynamic_attributes = nil if dynamic_attributes == &quot;{}&quot;
  return [static_attributes, dynamic_attributes],, last_line

Well, not bad at all... the only problem is that the loop is quite long and I had to double-check to know if the "static_attributes" statement was part of the loop or right after. This kind of double checking could get on my nerves fast.
I'm still undecided. I dislike end tags but they can clear things up sometimes. Anyway, I guess we probably never see this implemented in ruby. What's your thoughts on significant whitespace languages?