A Text value that should be kept whole through applied inflections.

A type-level tag for words.

since 0.3.0.0

Create a word from given Text. The input should consist of only alpha-numeric characters (no white spaces or punctuation) InflectionInvalidWord will be thrown.

since 0.3.0.0

Create an acronym from given Text. The input should consist of only alpha-numeric characters InflectionInvalidAcronym will be thrown. Acronym is different from normal word by that it may not be transformed by inflections (also see unSomeWord).

since 0.3.0.0

Get a Text value from Word.

since 0.3.0.0

An existential wrapper that allows to keep words and acronyms in single list for example. The only thing that receiver of SomeWord can do is to apply unWord on it, of course. This is faciliated by unSomeWord.

since 0.3.0.0

Extract Text from SomeWord and apply given function only if the word inside wasn't an acronym.

since 0.3.0.0

The exceptions that is thrown when parsing of input fails.

since 0.3.0.0

Parse a snake_case string.

>>> bar <- mkAcronym "bar"
>>> parseSnakeCase [bar] "foo_bar_bazz"
Right [Word "foo",Acronym "bar",Word "bazz"]

>>> parseSnakeCase [] "fooBarBazz"
1:4:
unexpected 'B'
expecting '_', end of input, or lowercase letter

Parse a CamelCase string.

>>> bar <- mkAcronym "bar"
>>> parseCamelCase [bar] "FooBarBazz"
Right [Word "Foo",Acronym "Bar",Word "Bazz"]

>>> parseCamelCase [] "foo_bar_bazz"
1:4:
unexpected '_'
expecting end of input, lowercase letter, or uppercase letter

Turn an input word list in into CamelCase.

>>> foo  <- SomeWord <$> mkWord "foo"
>>> bar  <- SomeWord <$> mkAcronym "bar"
>>> bazz <- SomeWord <$> mkWord "bazz"
>>> camelize [foo,bar,bazz]
"FoobarBazz"

Turn an input word list into a CamelCase String.

>>> foo  <- SomeWord <$> mkWord "foo"
>>> bar  <- SomeWord <$> mkAcronym "bar"
>>> bazz <- SomeWord <$> mkWord "bazz"
>>> camelizeCustom False [foo,bar,bazz]
"foobarBazz"

Produce a string with words separated by dashes (hyphens).

>>> foo  <- SomeWord <$> mkWord "foo"
>>> bar  <- SomeWord <$> mkAcronym "bar"
>>> bazz <- SomeWord <$> mkWord "bazz"
>>> dasherize [foo,bar,bazz]
"foo-bar-bazz"

Capitalize the first word and separate words with spaces. Like titleize, this is meant for creating pretty output.

>>> foo  <- SomeWord <$> mkWord "foo"
>>> bar  <- SomeWord <$> mkAcronym "bar"
>>> bazz <- SomeWord <$> mkWord "bazz"
>>> humanize [foo,bar,bazz]
"Foo bar bazz"

Separate given words by underscores.

>>> foo  <- SomeWord <$> mkWord "foo"
>>> bar  <- SomeWord <$> mkAcronym "bar"
>>> bazz <- SomeWord <$> mkWord "bazz"
>>> underscore [foo,bar,bazz]
"foo_bar_bazz"

Capitalize all the Words in the input list.

>>> foo  <- SomeWord <$> mkWord "foo"
>>> bar  <- SomeWord <$> mkAcronym "bar"
>>> bazz <- SomeWord <$> mkWord "bazz"
>>> titleize [foo,bar,bazz]
"Foo bar Bazz"

A HashMap containing mappings from international characters to sequences approximating these characters within the ASCII range.

These default transliterations are stolen from the Ruby i18n library - see https://github.com/svenfuchs/i18n/blob/master/lib/i18n/backend/transliterator.rb#L41:L69.

NOTE: before version 0.3.0.0 this was called defaultMap.

Replace special characters in a string so that it may be used as part of a pretty URL. Uses the defaultTransliterations.

Transliterate Text with a custom transliteration table.

Returns a Text after default approximations for changing Unicode characters to a valid ASCII range are applied. If you want to supplement the default approximations with your own, you should use the transliterateCustom function instead of transliterate.

Returns a Text after default approximations for changing Unicode characters to a valid ASCII range are applied.

Turns a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.

>>> ordinalize 1
"1st"
>>> ordinalize 2
"2nd"
>>> ordinalize 10
"10th"

Returns the suffix that should be added to a number to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.

>>> ordinal 1
"st"
>>> ordinal 2
"nd"
>>> ordinal 10
"th"

Transforms CamelCasedString to snake_cased_string_with_underscores.

toUnderscore = fmap underscore . parseCamelCase []

>>> toUnderscore "FooBarBazz"
"foo_bar_bazz"

Transforms CamelCasedString to snake-cased-string-with-dashes.

toDashed = fmap dasherize . parseCamelCase []

>>> toDashed "FooBarBazz"
"foo-bar-bazz"

Transforms underscored_text to CamelCasedText. If first argument is True then FirstCharacter in result string will be in upper case. If False then firstCharacter will be in lower case.

toCamelCased t = fmap (camelizeCustom t) . parseSnakeCase []

>>> toCamelCased True "foo_bar_bazz"
"FooBarBazz"
>>> toCamelCased False "foo_bar_bazz"
"fooBarBazz"

Lift something of type Either (ParseError Char Dec) a to an instance of MonadThrow. Useful when you want to shortcut on parsing failures and you're in an instance of MonadThrow.

This throws InflectionParsingFailed if given value is inside Left.

since 0.3.0.0