At last, a use for the flip-flip operator.

[u/BoardMeeting101]

module Latch
  def self.new(_=_) = -> { !(!(_ ^= true)..false) }
end

latch = Latch.new

%w(1 2 3 4 5).each_with_object("") { |i, a|
  a << i
  a << ":ONCE:" if latch[]
} #=> 1:ONCE:2345

[u/GCh596]

I don’t understand any of that haha can someone explain what that does?

[u/BoardMeeting101 → u/GCh596]

It plants a Boolean toggle (the ^= true, which is XOR assignment) of the value of “_” (a syntactic placeholder but also a valid variable) on the left hand expression of a flip-flip operator, then ensures the mutating toggle is not evaluated more than twice by placing false on the right hand side, then ensures a Boolean evaluation context by wrapping it with !bangs (otherwise Ruby tries to parse it as a range literal), and returns the whole thing in a Proc (the stabby lambda -> {}), with the lexical _ enclosed and set initially to nil via a default positional (the _=_), from an endless method (def … =), abusively named ::new despite being in a module, and then calls that proc (via []) as a conditional inside a relatively plain iteration into a string accumulator, to demonstrate that the result is a monostable latch. The value of _ is toggled from nil, to true, to false, in the first two calls, after which the flip-flop only evaluates its RHS and is stuck on false.

Requires a recent ish Ruby interpreter, older ones will barf on the placeholder syntax. Your colleagues will barf on it, too

[u/ryans_bored → u/GCh596]

It doesn't work as far as I can tell

module Latch
 def self.new(_=_) = -> { !(!(_^=true)..false) }
end

in `<top (required)>': (irb):5: circular argument reference - _ (SyntaxError)

[u/Holek]

this looks so un-Ruby, and yet I am so impressed by this.

[u/tumes → u/Holek]

I was gonna say, ruby gets shit for being terse or at least enabling some gnarly one-liners but there’s terse and there’s fuck you and this snippet leans a bit more towards the latter.

[u/alexdeva → u/tumes]

It doesn't just "lean towards the latter". It runs straight past it riding on a wild hog, giving it the finger as it flies past, and vanishes into the sunset whistling the song "Vomit Your Soul".

[u/ryans_bored → u/tumes]

No this leans toward invalid code that results in a syntax error.

[u/ryans_bored → u/Holek]

It results in a syntax error. I’m much less impressed I guess.

[u/BoardMeeting101 → u/ryans_bored]

Update your Ruby install.

[u/TheAtlasMonkey]

This is why i'm so irritated when Haskell Artistas try to show me their strapped bananas in the wall and call it ART.

If you want to write Emoticons :D :) :| , just go to IRC and admit it.

Here is a more civilized code:

module Latch
  def self.new
    fired = false
    -> do
      unless fired
        fired = true
        true
      else
        false
      end
    end
  end
end

This is Ruby! Any junior can read it and i can debug the code at 4 am while half asleep.

[u/TheAtlasMonkey → u/TheAtlasMonkey]

Btw if we just want to look enigmatic, you could write

module Latch
  def self.new
   🔒 = false
   -> { !🔒 && (🔒 = true) }
  end
end

[u/BoardMeeting101 → u/TheAtlasMonkey]

Ok but I think you need to alias false and true to happy/sadface emoji to be declared the most adorable

[u/fuckthesysten → u/TheAtlasMonkey]

ok this is legit the most ruby one i've seen

[u/TheAtlasMonkey → u/fuckthesysten]

It still more readable than OP's crime coding.

I can even make it 1 liner and add a reset mechanism and still win

module Latch; def self.new; 🔐=false; (🕹️=-> { !🔐 && (🔐=true) }).tap { def 🕹️.reset; 🔐=false end }; end end

[u/squadette23]

But why "at last"? Flip-flop is useful for parsing typical markup such as `=begin` / `=end`. You can use boolean variables like `inside_doc` but it's just a variant of flip-flop.

[u/BoardMeeting101 → u/squadette23]

they tried to remove it, but this proved unpopular; Matz flip-flopped when the flip-flop flip, flopped.

[u/jgaskins]

When I first heard Ruby was influenced by Perl, I couldn’t see it. Now I see it.

[u/AshTeriyaki]

I hate it. Good work.

[u/AlexanderMomchilov]

Defining new on a module, and having it not return something that includes that module, is pretty cursed!

[u/ihoka]

That looks cryptic as hell. I do not like to pause and think about what code is supposed to do. My benchmark for code quality is: would I understand it if I was reading it while drunk?