def delete_previous_or_merge_lines(self):
        """Delete char before cursor or merge lines.

        If we use it when there is a character before
        the cursor, the character is deleted.

        If there's no character before the cursor, then
        we cause the current line to merge with the line
        above the cursor (if there's one), as if eliminating
        a line separator from the text. If there's no line
        above the current one, then nothing is done.
        """
        ### if there is a character before the cursor
        ### (when cursor is currently in a column higher
        ### than 0), we delete such character

        if self.col > 0:

            ### delete the character behind the current column
            del self.lines[self.row][self.col - 1]

            ### reposition the characters in the line one
            ### beside the other, so they end up occupying
            ### the space left by the removed character
            self.lines[self.row].reposition_chars()

            ### go one character to the left, to compensate
            ### for the removed one
            self.go_left_ins()

            ### since some change took place, we execute the
            ### edition routine
            self.edition_routine()

        ### since we're about to evaluate the "elif" block
        ### below, we know the condition in the previous
        ### "if" block is False, which means there is no
        ### character before the cursor;
        ###
        ### so, if on top of that fact, there is a line
        ### above the current one (that is, the cursor is not
        ### at the first row), we merge the current line into
        ### the previous one;
        ###
        ### additionally, note that the steps taken below
        ### to position the cursor could be simplified by
        ### using a combination of existing navigation_ins()
        ### partial method implementations; however, we
        ### intentionally didn't do so because even though
        ### the outcome would be the same, some of the
        ### substeps taken would cancel each other out;
        ### setting things up manually as we did avoids
        ### extra unnecessary work

        elif self.row > 0:

            ### backup the index of the current row,
            ### the one to be removed
            index_to_remove = self.row

            ### update the row and, depending on the
            ### index of the visible row, either the
            ### index of the top visible line or the
            ### visible row itself

            ## decrement row
            self.row += -1

            ## if we're at the top visible row (index 0),
            ## then make it so the index of the top visible
            ## row in decremented
            if self.visible_row == 0:
                self.top_visible_line_index += -1

            ## otherwise decrement the visible row index
            else:
                self.visible_row += -1

            ### update the cursor column so it sits after
            ### the last character in the current line
            self.col = len(self.lines[self.row])

            ### pop and reference the removed line
            removed_line = self.lines.pop(index_to_remove)

            ### reference the current line
            current_line = self.lines[self.row]

            ### now merge the removed line into the current
            ### one and reposition the characters, so all
            ### new characters from the merged line are
            ### positioned beside the existing ones

            current_line.extend(removed_line)
            current_line.reposition_chars()

            ### since some change took place, we execute the
            ### edition routine;
            ###
            ### it is important to execute this before
            ### updating the visible lines, in order to
            ### prevent syntax highlighting to be applied
            ### to the visible lines, in case the syntax
            ### highlighting is enabled
            self.edition_routine()

            ### update the visible lines, since:
            ###
            ### 1) we just removed a line which was visible,
            ### 2) and we might also have updated the index
            ###    of the top visible line in the previous
            ###    "if block"
            ###
            ### this way, other lines (if there is any),
            ### are shifted upwards to occupy the position
            ### of the one we removed
            self.update_visible_lines()

            ### now we reposition the cursor without
            ### actually changing its row and column,
            ### just for the side-effect of causing the
            ### cursor to be properly positioned at its
            ### current row and column
            self.reposition_ins()

            ### finally, we also check the need to update
            ### the editing area
            self.check_editing_area()

        ### the only other possible scenario is that in
        ### which there's no character before the cursor
        ### and also no line before the current one;
        ### in such case, the cursor is at the very
        ### beginning of the text, and no actual change
        ### takes place, so we just pass
        else:
            pass
Delete char before cursor or merge lines.

        If we use it when there is a character before
        the cursor, the character is deleted.

        If there's no character before the cursor, then
        we cause the current line to merge with the line
        above the cursor (if there's one), as if eliminating
        a line separator from the text. If there's no line
        above the current one, then nothing is done.
        
nodezator/textman/editor/cursor/modes/insert.py