<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def generate_multiline_list( self, items, # type: typing.List[typing.Text] before='', # type: typing.Text after='', # type: typing.Text delim=('(', ')'), # type: DelimTuple compact=True, # type: bool sep=',', # type: typing.Text skip_last_sep=False # type: bool ):
 """ Given a list of items, emits one item per line. This is convenient for function prototypes and invocations, as well as for instantiating arrays, sets, and maps in some languages. TODO(kelkabany):
 A backend that uses tabs cannot be used with this if compact is false. Args: items (list[str]):
 Should contain the items to generate a list of. before (str):
 The string to come before the list of items. after (str):
 The string to follow the list of items. delim (str, str):
 The first element is added immediately following `before`. The second element is added prior to `after`. compact (bool):
 In compact mode, the enclosing parentheses are on the same lines as the first and last list item. sep (str):
 The string that follows each list item when compact is true. If compact is false, the separator is omitted for the last item. skip_last_sep (bool):
 When compact is false, whether the last line should have a trailing separator. Ignored when compact is true. """

        assert len(delim) == 2 and isinstance(delim[0], six.text_type) and \
            isinstance(delim[1], six.text_type), 'delim must be a tuple of two unicode strings.'

        if len(items) == 0:
            self.emit(before + delim[0] + delim[1] + after)
            return
        if len(items) == 1:
            self.emit(before + delim[0] + items[0] + delim[1] + after)
            return

        if compact:
            self.emit(before + delim[0] + items[0] + sep)
            def emit_list(items):
                items = items[1:]
                for (i, item) in enumerate(items):
                    if i == len(items) - 1:
                        self.emit(item + delim[1] + after)
                    else:
                        self.emit(item + sep)
            if before or delim[0]:
                with self.indent(len(before) + len(delim[0])):
                    emit_list(items)
            else:
                emit_list(items)
        else:
            if before or delim[0]:
                self.emit(before + delim[0])
            with self.indent():
                for (i, item) in enumerate(items):
                    if i == len(items) - 1 and skip_last_sep:
                        self.emit(item)
                    else:
                        self.emit(item + sep)
            if delim[1] or after:
                self.emit(delim[1] + after)
            elif delim[1]:
                self.emit(delim[1])