Re: wondering about #tap (was: Re: Thoughts about Array#compact!, Array#flatten!, Array#reject!, String#strip!, String#capitalize!, String#gsub!, etc.)

On Nov 16, 2007 6:05 PM, David A. Black <[e-mail]> wrote:
> Hi --
>
> On Sat, 17 Nov 2007, Nikolai Weibull wrote:
>
>
> > On Nov 16, 2007 12:40 PM, David A. Black <[e-mail]> wrote:
> >
> >> It's interesting that almost every example of #tap ends up saying that
> >> it's probably better not to use it, for one reason or another (usually
> >> readability; sometimes the dangers of mixing bang and non-bang
> >> methods).
> >>
> >> It makes me wonder whether the main effect of #tap is going to be a
> >> lot of warnings that it isn't a best practice. Or are there examples
> >> that *don't* look worse than the alternatives?
> >
> > def cleverly_return_an_array_after_building_it
> >  Array.new.tap do |ary|
> >    [1, 2, 3].each do |i|
> >      ary << i
> >    end
> >  end
> > end
> >
> > instead of
> >
> > def return_an_array_in_an_unclever_fashion_after_building_it
> >  ary = []
> >  [1, 2, 3].each do |i|
> >    ary << i
> >  end
> >  ary
> > end
> >
> > (Yeah, that's a horrible example, but you the point is valid.
>
> But my point is that *all* examples seem to be horrible, so a horrible
> example isn't a counter-illustration :_) After a while, one starts to
> wonder whether maybe #tap is just ugly and non-conducive to elegant
> code.

OK.  What follows is the scanner.rb file from my ruby-lisp library.
Substitute "returning v" with "v.tap".

I think this pattern makes the code a lot simpler than if I had
written it without returning or #tap.

# contents: Scanner that lexes and parses format strings into directives.
#
# Copyright (c) 2005 Nikolai Weibull <[e-mail]>

require 'stringio'
require 'forwardable'
require 'injector'

require 'lisp/format/directives'
require 'lisp/format/parameters'
require 'lisp/format/modifiers'

class Lisp::Format::Scanner
  extend Forwardable
  extend Injector

  needs 'lisp/format/error'

  DirectiveChar = ?~

  def initialize(format)
    @format, @stack = StringIO.new(format), []
  end

  def rest
    returning([]){ |ds| while d = scan: ds << d end }
  end

  def with(directive)
    @stack.push directive
    while d = scan: yield d end
    raise Error.new(directive.pos, 'no corresponding end bracket
found') unless d
  ensure
    @stack.pop
  end

  def between(left, right)
    right = Lisp::Format::Directives[right]
    returning [] do |directives|
      with(left) do |directive|
        directives << directive
        break if directive.is_a? right
      end
    end
  end

  def while
    returning "" do |str|
      until @format.eof?
        if not yield c = @format.getc
          @format.ungetc(c)
          break
        end
        str << c
      end
    end
  end

  def processing?(directive)
    @stack.last.is_a?(directive) ? @stack.last : nil
  end

  def_delegator :@format, :ungetc

private

  def scan
    return nil if @format.eof?
    if (c = @format.getc) == DirectiveChar
      params = parse_params
      modifiers = parse_modifiers
      directive = parse_directive
      directive.new(params, modifiers, @format.pos, self)
    else
      returning Lisp::Format::Directives::Pseudo::Literal.new(c.chr)
do |literal|
        literal << c.chr while c = @format.getc and c != DirectiveChar
        @format.ungetc(c) if c == DirectiveChar
      end
    end
  end

  def parse_params
    returning Lisp::Format::Parameters::List.new do |params|
      until @format.eof?
        break unless param = Lisp::Format::Parameters::Parameter.parse(@format)
        params << param
        unless @format.eof?
          if (c = @format.getc) != ?,
            @format.ungetc(c)
            break
          end
        end
      end
    end
  end

  def parse_modifiers
    returning Lisp::Format::Modifiers[false, false] do |ms|
      none = ms
      until @format.eof?
        break unless m = Lisp::Format::Modifiers.parse(@format)
        raise error('duplicate modifier '~C'', c) if ms & m != none
        ms |= m
      end
    end
  end

  def parse_directive
    if @format.eof?
      raise error('format string ended before directive was found')
    elsif not Lisp::Format::Directives.include?(c = @format.getc.chr.upcase[0])
      raise error('unkown directive '~~~C'', c)
    else
      Lisp::Format::Directives[c]
    end
  end

  def error(format, *args)
    Error.new(@format.pos, format, *args)
  end
end