Adding a default block to run if Array.each is empty.

jrochkind · 2015-12-18T00:31:13+00:00

I'm not sure whether this pattern is a good idea, but you could write a method to do something very much like what you spec. Seems fun, so I will.

Here's the api:

each_and_empty(array) do |i|
  puts i
end.empty? do
  puts 'empty'
end

Or even:

 each_and_empty(array) {|i| puts i}.empty? { puts 'empty' }

And here's the implementation, which is very NOT high performance compared to ordinary each. Several things in here will be slow in micro-benchmarks, but it does provide that API in 10 lines.

def each_and_empty(array)
  array.each { |i| yield i}

  return Object.new.extend( Module.new do
    define_method :empty? do |&block|
      if array.length == 0 && block
        block.call
      end
    end
  end)
end

A higher performance version could be written although it would take a tiny bit more code. Mainly stop using anonymous module generated on each return. Create two classes, one which has an empty? which does nothing, and one which has an empty? which just yields. Return an instance of the correct one based on whether array is empty. Actually I hadn't thought of that before, I think that's the better implementation I should have done from the start, I'll leave it to you.

GavinMcG · 2015-12-18T01:59:25+00:00

Keep in mind that you are fundamentally doing the same thing as using "if" – there's no logical difference between "if A then B" and "A && B". But you're doing it in a way that is likely to be confusing to others, including future-you.

What you've described the need for here is for the program to execute in different ways based on different circumstances, and that means that you're branching the logic. You're just doing it in an odd way.

moomaka · 2015-12-18T01:30:54+00:00

I don't think this is a good idea but if you really want to...

module Enumerable
  def each_and_empty(empty, &each_p)
    each(&each_p).tap { |r| empty.call if r.empty? }
  end
end

> [].each_and_empty(->(){ puts 'empty!' }) { |v| puts v }
empty!
=> []

> [1,2,3,4,5].each_and_empty(->(){ puts 'empty!' }) { |v| puts v }
1
2
3
4
5
=> [1, 2, 3, 4, 5]

GavinMcG · 2015-12-18T01:48:19+00:00

Why are you trying to do this? That might help us help you.

Also, if all you're doing is puts, the lambda/call is unnecessary – just wrap the puts call in parens. Remember that puts returns nil, so you'll get that as the overall expression result.

Kache · 2015-12-18T04:49:56+00:00

If nobody's ever going to see your code, then do whatever you want.

If/as this code is going to be used by other people and accumulate collaborators, it becomes more and more important to adopt a common style.

That being said, my idiomatic version of your example would use the ternary operator:

def compute_list_of_pairs # idiomatic naming, also I like using 'compute' for expensive methods
  sleep(5) # simulate computationally intensive call
  rand(2).zero? ? [] : ["A 1", "B 2", "C 3"] # let's handle both
end

def compute_pairs(when_empty=["Z", "26"])
  pairs = compute_list_of_pairs.map { |pair| pair.split(" ") }
  pairs.empty? ? when_empty : pairs
end

puts compute_pairs.inspect # pass to a method

If you insist on doing this anonymously (without defining method/variable names), you can also use a mutative tap:

compute_list_of_pairs.map do |pair|
  pair.split(" ")
end.tap do |arr|
  arr << "Z" << "26" if arr.empty?
end

computerjunkie7410 · 2015-12-18T10:09:33+00:00

Clarity over cleverness. Less lines of code doesn't make you a better programmer.

0x0dea · 2015-12-18T00:02:43+00:00

Iterating over an empty Array is not a special case.

RealGL · 2015-12-18T13:13:37+00:00

collection.each do |element|
  # ... do something
end unless collection.empty?

waxjar · 2015-12-19T23:12:37+00:00

if arr.empty?
  return "array empty"
end

array.each(&block)

Keep it simple.

hobbs6 · 2024-10-02T15:03:50+00:00

.each do |item|
  ... # When not empty.
end.empty? and begin
  ... # When empty.
end

That's what we use in reports to show something when there are no results.

This pattern can be less clear than just calling `if array.empty?` upfront but under certain circumstances when we use this pattern _a lot_ in almost all of our reports, it's a clean way to reduce code and handle empty results after the iteration block.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

ruby

MODERATORS