ruby method for atom? in scheme

Question

I'm trying to do the exercises in "The Little Schemer" using Ruby. I'd like to know the equivalent method of atom? in Scheme for Ruby.

atom? is a method that returns true if the argument passed in is an atom and returns false otherwise. From what I understand, an atom can be a string of characters or a number. It can't be a list.

Answer 1

By convention, sequence-like objects respond to the 'to_a' (to array) method. A possible atom implementation could be:

   class Object
     def atom?
       not respond_to? :to_a
     end
   end

   42.atom? #=> true
   {foo: 'bar'}.atom? #=> false

Answer 2

I guess the closest equivalent to atoms that Ruby has are the literals - Fixnum, booleans, symbols, and nil. This effectively comes down to an implementation detail, but those objects are represented directly by a value on the stack rather than as a C pointer. So, #atom? might look like this:

class Object
  def atom?
    case self
    when Fixnum, TrueClass, FalseClass, NilClass, Symbol
      true
    else
      false
    end
  end
end

Answer 3

Atoms in Scheme, as defined by The Little Schemer:

(define atom?
  (lambda (x)
    (and (not (pair? x)) (not (null? x)))))

So atoms in Scheme are everything except lists (things created with the 'cons' operator) and null. In Scheme, that ends up being symbols, numbers, methods, and probably a few more things I'm forgetting. Ruby's a lot more complicated.

So for the purposes of doing is the exercises in The Little Schemer, an atom in Ruby is a FixNum, a Symbol, a TrueValue, or a FalseValue. Or a method. And then for lists, you're going to need to define cons, car, and cdr methods for Ruby's array type. I might actually say that anything that's not an Array and is not nil is an atom. This discussion gets subjective at some point.

And then you're probably going to need to do a good bit more hacking to get everything to behave the same. Quite honestly, while I love The Little Schemer, it really does have some things that are fairly Lisp-specific, and while I can see adapting it to another functional language like Haskell without too much trouble, I think it's going to be more trouble than it's worth to get it to work in a language like Ruby.