def stresser(self, stress_rule='FSR'):
        """
        Args:

            :param stress_rule: Stress Rule, valid options:

                'FSR': French Stress Rule, stress falls on the ultima, unless
                 it contains schwa (ends with e), in which case the penult is
                stressed

                'GSR': Germanic Stress Rule, stress falls on the first syllable
                of the stemm. Note that the accuracy of the function directly
                depends on that of the stemmer.

                'LSR': Latin Stress Rule, stress falls on the penult if its
                heavy, else, if it has more than two syllables on the
                antepenult, else on the ultima.

        Returns:

            list: A list containing the separate syllable, where the stressed
            syllable is prefixed by ' . Monosyllabic words are left unchanged,
            since stress indicates relative emphasis.

        Examples:

            >>> Word('beren').stresser(stress_rule = "FSR")
            ['ber', "'en"]

            >>> Word('prendre').stresser(stress_rule = "FSR")
            ["'pren", 'dre']

            >>> Word('yisterday').stresser(stress_rule = "GSR")
            ['yi', 'ster', "'day"]

            >>> Word('day').stresser(stress_rule = "GSR")
            ['day']

            >>> Word('mervelus').stresser(stress_rule = "LSR")
            ["'mer", 'vel', 'us']

            >>> Word('verbum').stresser(stress_rule = "LSR")
            ['ver', "'bum"]
        """

        # Syllabify word
        if not self.syllabified:
            self.syllabify()

        # Check whether word is monosyllabic
        if len(self.syllabified) == 1:
            return self.syllabified

        if stress_rule == 'FSR':
            # Check whether ultima ends in e
            if self.syllabified[-1][-1] == 'e':
                return self.syllabified[:-2] + ['\'{0}'.format(self.syllabified[-2])] + self.syllabified[-1:]

            else:
                return self.syllabified[:-1] + ['\'{0}'.format(self.syllabified[-1])]

        elif stress_rule == 'GSR':
            # The word striped of suffixes
            st_word = affix_stemmer([self.word], strip_suf=False)
            affix = self.word[:len(self.word) - len(st_word)]

            # Syllabify stripped word and affix

            syl_word = Word(st_word).syllabify()

            # Add stress
            syl_word = ['\'{0}'.format(syl_word[0])] + syl_word[1:]

            if affix:
                affix = Word(affix).syllabify()
                syl_word = affix + syl_word

            return syl_word

        elif stress_rule == 'LSR':
            # Check whether penult is heavy (contains more than one mora)
            if sum(map(lambda x: x in SHORT_VOWELS, self.syllabified[-1])) > 1:
                return self.syllabified[:-2] + ['\'{0}'.format(self.syllabified[-2])] + self.syllabified[-1:]

            elif len(self.syllabified) > 2:
                return self.syllabified[:-3] + ['\'{0}'.format(self.syllabified[-3])] + self.syllabified[-2:]

            else:
                return self.syllabified[:-1] + ['\'{0}'.format(self.syllabified[-1])]