# necessary, provided there is a way of generating the instruction
	# with DOUBLE in the first place.

	# First, extract the type signature that we're trying to generate.
	if {![regexp {^([^()]+)\(([\w, ]+)\)$} $signature -> name types]} {
	    return 0
	}
	set types [split $types ","]
	set num [llength $types]

	# Get the type signatures we could go to
	set methods [info class methods [self class]]

	# Search the space of possible conversions for ones that are legal,
	# and compute the cost of each.
	set mapped {}
	foreach targetinfo $methods {
	    if {![regexp {^([^()]+)\(([\w, ]+)\)$} $target -> tname ttypes]} {
		continue
	    }
	    if {$name ne $tname} {
		continue
	    }
	    set ttypes [split $ttypes ","]
	    if {[llength $types] != [llength $ttypes]} {
		continue
	    }




	    set thiscost 0
	    set legal true
	    set cvts [lmap st $types tt $ttypes {
		if {$st eq $tt} {
		    # No-conversion is always legal and always very cheap
		    set c $DefaultTypeConversion
		} else {
		    # Look up if we have a conversion
		    set typepair [list $st $tt]
		    if {![dict exists $TypeConversions $typepair]} {
			set legal false
			# Continue the outer loop
			break
		    }
		    set c [dict get $TypeConversions $typepair]
		}
		# The cost of a conversion is just its length. That is WRONG,
		# but approximates the real cost.
		incr thiscost [string length $c]
		string cat $c
	    }]
	    if {$legal} {
		lappend mapped $thiscost $target $cvts

	    }
	}

	set tock [clock microseconds]
	::puts [format "Identified %d typecast candidates in %.6f s" \
		    [expr {[llength $mapped] / 3}] \
		    [expr {1.0e-6 * ($tock - $tick)}]]