Extensible metagolfer

golf.rb

"
double: <<>
parity swap: ::^~<~^
"

class Transformation
    def initialize(sym, inv)
        @sym = sym
        @inv = inv
    end
    
    attr_reader :sym, :inv
    
    def [](other)
        @inv[other]
    end
end

class Golfer
    def initialize(trans, cons = {})
        @trans = trans
        @pool = cons
    end
    
    attr_reader :pool, :trans
    
    def step
        @pool.clone.each { |c, key|
            @trans.each { |t|
                r = t[c]
                unless @pool.has_key? r
                    k = key + t.sym
                    @pool[r] = k
                end
            }
        }
    end
    
    def [](n)
        step until @pool.has_key? n
        @pool[n]
    end
end

# ~ is a self-inverse
bit_neg = Transformation.new "~", -> x { ~x }

bit_shft_left = Transformation.new ">", -> x { x / 2 }
bit_shft_right = Transformation.new "<", -> x { x * 2 }

g = Golfer.new(
    [bit_neg, bit_shft_left, bit_shft_right],
    { 0 => "" }
)

n = 0
while true
    puts "#{n} -> #{g[n]}"
    n += 1
end