# File lib/linguistics/en.rb, line 1490
    def conjunction( obj, args={} )
        config = ConjunctionDefaults.merge( args )
        phrases = []

        # Transform items in the obj to phrases
        if block_given?
            phrases = obj.collect {|item| yield(item) }.compact
        else
            phrases = obj.collect {|item| item.to_s }
        end

        # No need for a conjunction if there's only one thing
        return a(phrases[0]) if phrases.length < 2

        # Set up a Proc to derive a collector key from a phrase depending on the
        # configuration
        keyfunc =
            if config[:casefold]
                proc {|key| key.downcase.strip}
            else
                proc {|key| key.strip}
            end

        # Count and delete phrases that hash the same when the keyfunc munges
        # them into the same thing if we're combining (:combine => true).
        collector = {}
        if config[:combine]

            phrases.each_index do |i|
                # Stop when reaching the end of a truncated list
                break if phrases[i].nil?

                # Make the key using the configured key function
                phrase = keyfunc[ phrases[i] ]

                # If the collector already has this key, increment its count,
                # eliminate the duplicate from the phrase list, and redo the loop.
                if collector.key?( phrase )
                    collector[ phrase ] += 1
                    phrases.delete_at( i )
                    redo
                end

                collector[ phrase ] = 1
            end
        else
            # If we're not combining, just make everything have a count of 1.
            phrases.uniq.each {|key| collector[ keyfunc[key] ] = 1}
        end

        # If sort-by-quantity is turned on, sort the phrases first by how many
        # there are (most-first), and then by the order they were specified in.
        if config[:quantsort] && config[:combine]
            origorder = {}
            phrases.each_with_index {|phrase,i| origorder[ keyfunc[phrase] ] ||= i }
            phrases.sort! {|a,b|
                (collector[ keyfunc[b] ] <=> collector[ keyfunc[a] ]).nonzero? ||
                (origorder[ keyfunc[a] ] <=> origorder[ keyfunc[b] ])
            }
        end

        # Set up a filtering function that adds either an indefinite article, an
        # indefinite quantifier, or a definite quantifier to each phrase
        # depending on the configuration and the count of phrases in the
        # collector.
        filter =
            if config[:generalize]
                proc {|phrase, count| quantify(phrase, count) }
            else
                proc {|phrase, count|
                if count > 1
                    "%s %s" % [
                        # :TODO: Make this threshold settable
                        count < 10 ? count.en.numwords : count.to_s,
                        plural(phrase, count)
                    ]
                else
                    a( phrase )
                end
            }
            end

        # Now use the configured filter to turn each phrase into its final
        # form. Hmmm... square-bracket Lisp?
        phrases.collect! {|phrase| filter[phrase, collector[ keyfunc[phrase] ]] }

        # Prepend the conjunctive to the last element unless it's empty or
        # there's only one element
        phrases[-1].insert( 0, config[:conjunctive] + " " ) unless
            config[:conjunctive].strip.empty? or
            phrases.length < 2

        # Concatenate the last two elements if there's no penultimate separator,
        # and pick a separator based on how many phrases there are and whether
        # or not there's already an instance of it in the phrases.
        phrase_count = phrases.length
        phrases[-2] << " " << phrases.pop unless config[:penultimate]
        sep = config[:separator]
        if phrase_count <= 2
            sep = ' '
        elsif phrases.find {|str| str.include?(config[:separator]) }
            sep = config[:altsep]
        end

        return phrases.join( sep )
    end