# File lib/wordnet/synset.rb, line 659
                def traverse( type, includeOrigin=true )
                        raise ArgumentError, "Illegal parameter 1: Must be either a String or a Symbol" unless
                                type.kind_of?( String ) || type.kind_of?( Symbol )

                        raise ArgumentError, "Synset doesn't support the #{type.to_s} pointer type." unless
                                self.respond_to?( type )

                        foundSyns = []
                        depth = 0
                        traversalFunc = nil

                        # Build a traversal function which we can call recursively. It'll return
                        # the synsets it traverses.
                        traversalFunc = Proc.new {|syn,newDepth|

                                # Flag to continue traversal
                                haltFlag = false

                                # Call the block if it exists and we're either past the origin or
                                # including it
                                if block_given? && (newDepth > 0 || includeOrigin)
                                        res = yield( syn, newDepth )
                                        haltFlag = true if res.is_a? TrueClass
                                end

                                # Make an array for holding sub-synsets we see
                                subSyns = []
                                subSyns.push( syn ) unless newDepth == 0 && !includeOrigin

                                # Iterate over each synset returned by calling the pointer on the
                                # current syn. For each one, we call ourselves recursively, and
                                # break out of the iterator with a false value if the block has
                                # indicated we should abort by returning a false value.
                                unless haltFlag
                                        syn.send( type ).each {|subSyn|
                                                subSubSyns, haltFlag = traversalFunc.call( subSyn, newDepth + 1 )
                                                subSyns.push( *subSubSyns ) unless subSubSyns.empty?
                                                break if haltFlag
                                        }
                                end

                                # return
                                [ subSyns, haltFlag ]
                        }

                        # Call the iterator
                        traversedSets, haltFlag =  traversalFunc.call( self, depth )
                        
                        # If a block was given, just return whether or not the block was halted.
                        if block_given?
                                return haltFlag

                        # If no block was given, return the traversed synsets
                        else
                                return traversedSets
                        end
                end