patnakajima.com: Snippets

Manic Meta Madness

Pat Nakajima — Thu, 17 Jul 2008 20:53:34 +0000

class Object
  # Search an object's metaclass when the method doesn't exist.
  def method_missing(m, *args); metaclass.send(m, *args) end
  def metaclass; class << self; self end end
  def meta_eval(&b); metaclass.instance_eval(&b) end
  def meta_depth(i, start=0)
    return -1 if (self === Object)
    return start if i === self
    meta_depth(i.superclass, start + 1)
  end
end

class Dude
  def greet; puts "Hello from the instance\n\n"; end
end

d = Dude.new

d.greet # => Hello from the instance

Dude.class_eval { remove_method :greet }

d.instance_eval do
  puts "Meta depth: #{meta_depth(d)}" # => Meta depth: 0
  def greet; puts "Hello from the metaclass\n\n"; end
end

d.greet # => Hello from the metaclass

d.instance_eval do
  meta_eval do
    puts "Meta depth: #{meta_depth(d)}" # => Meta depth: 1
    remove_method(:greet)
    def greet; puts "Hello from the metaclass' metaclass\n\n"; end
  end
end

d.greet # => Hello from the metaclass' metaclass

d.instance_eval do
  meta_eval do
    meta_eval do
      puts "Meta depth: #{meta_depth(d)}" # => Meta depth: 2
      remove_method(:greet)
      def greet
        puts "Hello from the metaclass' metaclass' metaclass\n\n"
      end
    end
  end
end

d.greet # => Hello from the metaclass' metaclass' metaclass

d.instance_eval do
  meta_eval do
    meta_eval do
      meta_eval do
        puts "Meta depth: #{meta_depth(d)}" # => Meta depth: 2
        remove_method(:greet)
        def greet
          puts "Hello from the metaclass' metaclass' metaclass' metaclass"
        end
      end
    end
  end
end

d.greet # => Hello from the metaclass' metaclass' metaclass' metaclass

Scheme Spirit

Pat Nakajima — Thu, 17 Jul 2008 05:02:52 +0000

(define (accumulate proc initial sequence)
  (cond
    ((null? sequence) initial)
    ((proc 
      (car sequence)
      (accumulate proc initial (cdr sequence))))))

(define (map proc sequence)
  (accumulate 
    (lambda (x y) (cons (proc x) y)) 
    '()
    sequence))

(define (filter predicate sequence)
  (cond
    ((null? sequence) '())
    ((predicate (car sequence)) 
      (cons (car sequence)
        (filter predicate (cdr sequence))))
    (else
      (filter predicate (cdr sequence)))))

methodize_keys! with recursion

Pat Nakajima — Mon, 02 Jun 2008 16:41:29 +0000

class Object
  def try(m, *a, &b); respond_to?(m) ? send(m, *a, &b) : nil; end
  def metaclass; class << self; self; end; end
  def meta_eval &b; metaclass.instance_eval &b; end
  def meta_def name, &b; meta_eval { define_method name, &b }; end
end

module Enumerable
  def methodize_keys!    
    case self
    when Hash
      each do |key, value|
        meta_def(key) { self[key] }
        value.try(:methodize_keys!)
      end
    when Array
      each { |n| n.try(:methodize_keys!) }
    end
  end
end

ruby-snippet

Pat Nakajima — Thu, 22 May 2008 01:16:56 +0000

# Create getter methods for every key-value in a hash. Example:

=begin # Example:

some_hash = {
  :name => 'Pat',
  :age => 21,
  :tired? => true
}

puts some_hash.respond_to?(:name) # => false
puts some_hash.respond_to?(:age) # => false
puts some_hash.respond_to?(:tired?) # => false

some_hash.methodize_keys!

puts some_hash.name # => Pat
puts some_hash.age # => 21
puts some_hash.tired? # => true

# This is what my way has over the method_missing approach:
puts some_hash.respond_to?(:name) # => true
puts some_hash.respond_to?(:age) # => true
puts some_hash.respond_to?(:tired?) # => true
  
=end

# First we need an easy way to grab an object's metaclass.
#
# gotta love why:
# whytheluckystiff.net/articles/seeingMetaclassesClearly.html
class Object
  def metaclass; class << self; self; end; end
  def meta_eval &blk; metaclass.instance_eval &blk; end
end

# Then comes the easy part. There are probably a thousand other
# ways to do this, but I like this one.
class Hash
  def methodize_keys!
    each do |key, value|
      meta_eval { define_method(key) { return self[key] } }
    end    
  end
end

javascript-snippet

Pat Nakajima — Wed, 21 May 2008 04:09:39 +0000

// In Javascript
var Greeter = function(name) {
  name = name || 'World';
  alert("Hello, " + name + '!');
};

new Greeter; // => "Hello, World!

ruby-snippet

Pat Nakajima — Wed, 21 May 2008 03:52:39 +0000

# In Ruby...
class Greeter
  def initialize(name='World')
    puts "Hello, #{name}!"
  end
end

Greeter.new # => Hello, World!