# File lib/facets/core/kernel/__DIR__.rb, line 7
  def __DIR__
    (/^(.+)?:\d+/ =~ caller[0]) ? File.dirname($1) : nil
  end

# File lib/facets/core/kernel/as.rb, line 22
  def __as__( klass=nil, &blk )
    selfclass = Kernel.instance_method(:class).bind(self).call
    klass ||= selfclass.superclass
    if selfclass.ancestors.include?(klass)
      Functor.new do |meth, *args|  # &blk|
        klass.instance_method(meth).bind(self).call(*args) # ,&blk)
      end
    else
      raise ArgumentError, "#{klass} is not an ancestor"
    end
  end

# File lib/facets/core/kernel/__self__.rb, line 24
  def __self__
    @__self__ ||= Functor.new do |meth, *args|  # &blk|
      Object.instance_method(meth).bind(self).call(*args) # ,&blk)
    end
  end

# File lib/facets/core/kernel/assign_from.rb, line 27
  def assign_from(obj, *fields)
    force = false
    case fields.last when true, false, nil
      force = fields.pop
    end

    unless fields.empty?
      fields.each do |k|
        var = k.to_s
        var = var.slice(0,1) == '@' ? var : "@#{var}"
        if obj.instance_variables.include?(var)
          self.instance_variable_set( var, obj.instance_variable_get(var) )
        end
      end
    else
      if force
        fields = obj.instance_variables
      else
        fields = instance_variables | obj.instance_variables
      end
      fields.each do |var|
        instance_variable_set( var, obj.instance_variable_get(var) )
      end
    end

    return self
  end

# File lib/facets/core/kernel/assign_with.rb, line 32
  def assign_with(*args)
    harg = args.last.is_a?(Hash) ? args.pop : {}

    unless args.empty?
      # if not assoc array, eg. [ [], [], ... ]
      # preserves order of opertation
      unless args[0].is_a?(Array)
        i = 0; a = []
        while i < args.size
          a << [ args[i], args[i+1] ]
          i += 2
        end
        args = a
      end
    end

    args.each do |k,v|
      instance_assign( k, v )
    end

    harg.each do |k,v|
      instance_assign( k, v )
    end

    return self
  end

# File lib/facets/core/kernel/autoreload.rb, line 19
  def autoreload( *args )

    check_interval=10
    include_features = true
    files = nil

    args.each do |arg|
      case arg
      when Numeric
        check_interval = arg
      when String
        files = Dir.glob( arg )
      when Array
        files = arg
      when TrueClass, FalseClass
        include_features = arg
      end
    end

    file_mtime = {}

    Thread.new(Time.now) do |start_time|
      loop do
        sleep check_interval

        if include_features
          feature_files = $LOADED_FEATURES.collect { |feature|
            $LOAD_PATH.each { |lp| file = File.join(lp, feature) }
          }.flatten

          feature_files.each { |file|
            if File.exists?(file) and (mtime = File.stat(file).mtime) > (file_mtime[file] || start_time)
              $autoreload_dirty = true
              file_mtime[file] = mtime
              STDERR.puts "File '#{ file }' reloaded"
              begin
                load(file)
              rescue Exception => e
                STDERR.puts e.inspect
              end
            end
          }
        end

        if files
          files.each do |file|
            if File.exists?(file) and (mtime = File.stat(file).mtime) > (file_mtime[file] || start_time)
              $autoreload_dirty = true
              file_mtime[file] = mtime
              STDERR.puts "File '#{ file }' changed"
            end
          end
        end

      end
    end

  end

# File lib/facets/core/kernel/autoreload.rb, line 82
  def autoreload_files( *args )
    autoreload( *args, false )
  end

# File lib/facets/core/kernel/bool.rb, line 36
  def bool?
    (true == self or false == self)
  end

# File lib/facets/core/kernel/bug.rb, line 14
  def bug!( message = 'must not happen' )
    raise ScriptBug, "\n[SCRIPT BUG] " + message
  end

# File lib/facets/core/kernel/cache.rb, line 10
  def cache m = nil
    if m
      (Module === self ? self : (class << self; self; end)).module_eval "alias_method '__\#{ m }__', '\#{ m }'\ndef \#{ m }(*__a__,&__b__)\nc = cache['\#{ m }']\nk = [__a__,__b__]\nif c.has_key? k\nc[k]\nelse\nc[k] = __\#{ m }__(*__a__,&__b__)\nend\nend\n"
    end
    @cache ||= Hash::new{|h,k| h[k]={}}
  end

# File lib/facets/core/kernel/call_stack.rb, line 23
  def call_stack( level = 1 )
    call_str_array = pp_call_stack(level)
    stack = []
    call_str_array.each{ |call_str|
      file, lineno, method = call_str.split(':')
      if method =~ /in `(.*)'/ then
        method = $1.intern()
      end
      stack << [file, lineno.to_i, method]
    }
    stack
  end

# File lib/facets/core/kernel/complete.rb, line 3
  def complete
    loop { break unless yield }
  end

# File lib/facets/core/kernel/constant.rb, line 17
  def constant(const)
    const = const.to_s.dup
    base = const.sub!(/^::/, '') ? Object : ( self.kind_of?(Module) ? self : self.class )
    const.split(/::/).inject(base){ |mod, name| mod.const_get(name) }
  end

# File lib/facets/core/kernel/copy.rb, line 9
  def copy
    Marshal::load(Marshal::dump(self))
  end

# File lib/facets/core/kernel/deep_copy.rb, line 9
  def deep_copy
    Marshal::load(Marshal::dump(self))
  end

# File lib/facets/core/kernel/demo.rb, line 23
  def demo(out=$stdout,&block)
    out << sprintf("%-25s#=>  %s\n", expr = block.call, eval(expr, block.binding).inspect)
  end

# File lib/facets/core/kernel/eigenclass.rb, line 14
  def eigenclass
    (class << self; self; end)
  end

# File lib/facets/core/kernel/bool.rb, line 25
  def false?
    (false == self)
  end

# File lib/facets/core/kernel/generate_method_name.rb, line 10
  def generate_method_name( name='a' )
    s = name.to_s
    while self.respond_to?( "_#{s}_" )
      s = s.succ
    end
    return "_#{s}_".to_sym
  end

# File lib/facets/core/kernel/get_by_id.rb, line 6
  def get_by_id( id )
    ObjectSpace._id2ref( id )
  end

# File lib/facets/core/kernel/in.rb, line 9
  def in?(other)
    other.include?(self)
  end

# File lib/facets/core/kernel/instance_assign.rb, line 7
  def instance_assign( name, value )
    k = name.to_s
    v = value
    /^([@$]{0,2})/ =~ k
    case $1
    when '$', '@@'
      instance_eval %Q{ #{k} = v }
    when '@'
      instance_variable_set( k, v )
    else
      return __send__( "#{k}=", v ) if respond_to?("#{k}=")
      # No accessor? What to do? Assume instance var, or error? ...
      self.instance_variable_set( "@#{k}", v )
    end
    return value
  end

# File lib/facets/core/kernel/instvar.rb, line 5
  def instvar( sym )
    instance_variable_get( "@#{sym}" )
  end

# File lib/facets/core/kernel/instvar.rb, line 9
  def instvar!( sym, val )
    instance_variable_set( "@#{sym}", val )
  end

# File lib/facets/core/kernel/maybe.rb, line 10
  def maybe(chance = 0.5, &block)
    if block then
      yield if rand < chance
    else
      rand < chance
    end
  end

# File lib/facets/core/kernel/method.rb, line 39
  def method!(s)
    ( @__methods__ ||= {} )[s] ||= method(s)
  end

# File lib/facets/core/kernel/methods.rb, line 26
  def methods(*args)
    args = [ :public, :local, :ancestors ] if args.empty?
    m = self.class.instance_methods( *args )
    m |= singleton_methods if args.include?( :singleton ) or args.include?( :all )
    m
  end

# File lib/facets/core/kernel/nack.rb, line 9
    def nack; NackClass.new ; end

# File lib/facets/core/kernel/new.rb, line 10
  def new
    self.clone
  end

# File lib/facets/core/kernel/object_hexid.rb, line 9
  def object_hexid
    return "0x" << ('%.x' % (2*self.__id__))[1..-1]
  end

# File lib/facets/core/kernel/op_esc.rb, line 33
  def op_esc( str )
    str.gsub(OPERATORS_REGEXP){ OPERATORS_ESC_TABLE[$1] }
  end

# File lib/facets/core/kernel/own.rb, line 7
  def own(&blk)
    (class << self; self; end).module_eval( &blk ) if blk
    return (class << self; self; end)
  end

# File lib/facets/core/kernel/p.rb, line 7
  def p( x )
    puts x.inspect
    x
  end

# File lib/facets/core/kernel/pp_exception.rb, line 13
  def pp_exception(ex)
    return %{#{ex.message}\n  #{ex.backtrace.join("\n  ")}\n  LOGGED FROM: #{caller[0]}}
  end

# File lib/facets/core/kernel/quaclass.rb, line 11
  def quaclass( &block )
    (class << self; self; end).module_eval(&block) if block
    (class << self; self; end)
  end

# File lib/facets/core/kernel/resc.rb, line 5
  def resc(x)
    Regexp.escape(x)
  end

# File lib/facets/core/kernel/respond.rb, line 9
  def respond(sym, *args)
    return nil if not respond_to?(sym, *args)
    send(sym, *args)
  end

# File lib/facets/core/kernel/returning.rb, line 18
  def returning(value)
    yield
    value
  end

# File lib/facets/core/kernel/send_as.rb, line 6
  def send_as(klass, meth, *args, &blk)
    selfclass = Kernel.instance_method(:class).bind(self).call
    raise ArgumentError if ! selfclass.ancestors.include?(klass)
    klass.instance_method(meth).bind(self).call(*args, &blk)
  end

# File lib/facets/core/kernel/set_from.rb, line 22
  def set_from(obj, *fields)
    unless fields.empty?
      fields.each do |k|
        send( "#{k}=", obj.send("#{k}") )  #if self.respond_to?("#{k}=") && obj.respond_to?("#{k}")
      end
    else
      setters = methods.collect { |m| m =~ /=$/ }
      setters.each do |setter|
        getter = setter.chomp('=')
        if obj.respond_to?(getter)
          send( setter, obj.send(getter) )
          fields < getter
        end
      end
    end
    fields
  end

# File lib/facets/core/kernel/set_with.rb, line 19
  def set_with(*args)
    harg = args.last.is_a?(Hash) ? args.pop : {}

    unless args.empty?
      # if not assoc array, eg. [ [], [], ... ]
      # preserves order of opertation
      unless args[0].is_a?(Array)
        i = 0; a = []
        while i < args.size
          a << [ args[i], args[i+1] ]
          i += 2
        end
        args = a
      end
    end

    args.each do |k,v|
      self.send( "#{k}=", v ) #if respond_to?("#{k}=")
    end

    harg.each do |k,v|
      self.send( "#{k}=", v ) #if respond_to?("#{k}=")
    end

  end

# File lib/facets/core/kernel/silently.rb, line 6
  def silently #:yield:
    old_verbose, $VERBOSE = $VERBOSE, nil
    begin
      yield
    ensure
      $VERBOSE = old_verbose
    end
  end

# File lib/facets/core/kernel/singleton.rb, line 9
  def singleton
    (class << self; self; end)
  end

# File lib/facets/core/kernel/singleton_class.rb, line 9
  def singleton_class
    (class << self; self; end)
  end

# File lib/facets/core/kernel/supermethod.rb, line 6
  def supermethod(klass, meth)
    unless self.class.ancestors.include?(klass)
      raise ArgumentError
    end
    klass.instance_method(meth).bind(self)
  end

# File lib/facets/core/kernel/bool.rb, line 14
  def true?
    (true == self)
  end

# File lib/facets/core/kernel/uri.rb, line 9
  def unuri( s )
    URI.unescape( s )
  end

# File lib/facets/core/kernel/uri.rb, line 5
  def uri( s, w=%r{[^a-zA-Z_0-9./-]} )
    URI.escape( s, w )
  end

# File lib/facets/core/kernel/warn_with_line.rb, line 13
  def warn_with_line(msg="", fulltrace=nil)
    trace = caller(1)
    where = trace[0].sub(/:in.*/,'')
    STDERR.puts "#{where}: Warning: #{msg}"
    STDERR.puts trace.map { |t| "\tfrom #{t}" } if fulltrace
  end

# File lib/facets/core/kernel/__method__.rb, line 14
  def __method__
    /\`([^\']+)\'/.match(caller(1).first)[1].to_sym
  end

# File lib/facets/core/kernel/called.rb, line 14
  def called
    /\`([^\']+)\'/.match(caller(1).first)[1].to_sym
  end

# File lib/facets/core/kernel/require_all.rb, line 11
  def require_all( pat )
    $LOAD_PATH.each do |path|
      fs = Dir[File.join(path,pat)]
      unless fs.empty?
        fs.each { |f|
          Kernel.require( f ) unless File.directory?( f )
        }
        break;
      end
    end
  end

# File lib/facets/core/kernel/require_esc.rb, line 13
  def require_esc( fpath )
    fdir, fname = File.split(fpath)
    ename = op_esc( fname )
    case ename[-1,1] ; when '!','=','?' then ename = ename[0...-1] ; end
    epath = File.join( fdir, ename )
    require( epath )
  end

# File lib/facets/core/kernel/require_facet.rb, line 16
  def require_facet( fpath )
    require_esc( "facet/#{fpath}" )
  end

# File lib/facets/core/kernel/require_local.rb, line 10
  def require_local( fname )
    #fdir = File.expand_path( File.dirname( caller[0] ) )
    fdir = File.dirname( caller[0] )
    require( File.join( fdir, fname ) )
  end

# File lib/facets/core/kernel/this.rb, line 7
  def this
    name = /\`([^\']+)\'/.match(caller(1).first)[1]
    return method(name)
  end