code: def in_(self, haystack):
          
          from taipan.collections import dicts
  
          ensure_string(haystack)
          if not is_mapping(self._replacements):
              raise ReplacementError("string replacements not provided")
  
          # handle special cases
          if not self._replacements:
              return haystack
          if len(self._replacements) == 1:
              return haystack.replace(*dicts.peekitem(self._replacements))
  
          # construct a regex matching any of the needles in the order
          # of descending length (to prevent issues if they contain each other)
          or_ = haystack.__class__('|')
          regex = join(or_, imap(
              re.escape, sorted(self._replacements, key=len, reverse=True)))
  
          # do the substituion, looking up the replacement for every match
          do_replace = lambda match: self._replacements[match.group()]
          return re.sub(regex, do_replace, haystack)
docs: Perform replacement in given string.
  
          :param haystack: String to perform replacements in
  
          :return: ``haystack`` after the replacements
  
          :raise TypeError: If ``haystack`` if not a string
          :raise ReplacementError: If no replacement(s) have been provided yet