 
 postfix operator * {}
 
+/**
+ Wraps an `Unwrappable` to prevent it from being unwrapped.
+
+ - Parameter unwrappable: the given unwrappable.
+ - Returns: a `WrappedUnwrappable` containing the given `Unwrappable`.
+ */
 public postfix func *(unwrappable: Unwrappable) -> WrappedUnwrappable {
     return WrappedUnwrappable(unwrappable: unwrappable)
 }
 
 public extension String {
+
+    /// Create an instance containing the unwrappable's representation.
     init(stringInterpolationSegment expr: Unwrappable) {
         if let unwrapped = expr.unwrap() {
             self.init(stringInterpolationSegment: unwrapped)

    return (unwrapped1 as Wordable) ~ (unwrapped2 as Intable)
}

public func /(singularForm: String, pluralForm: String) -> Word {
    return Word(singularForm: singularForm, pluralForm: pluralForm)
}


extension Optional: Intable {}


/// Anything that can present a word.
public protocol Wordable {

    /// The singular form of the word.
    var singularForm: String { get }

    /// The plural form of the word.
    var pluralForm: String { get }
}

/// An implementation of the `Wordable` protocol.
public struct Word: Wordable {

    /// The singular form of the word.
    public var singularForm: String

    /// The plural form of the word.
    public var pluralForm: String
}

/// `Pluralizer` makes the plural form of a word from its singular form.
public protocol Pluralizer {

    /**
     Returns the plural form of the given word.

     - Parameter word: the given word, in singular form.
     - Returns: the plural form.
     */
    static func apply(word: String) -> String
}

/// `SimplePluralizer` appends an "s" to a word to make its plural form.
public class SimplePluralizer: Pluralizer {

    /**
     Returns the plural form of the given word by appending an "s".

     - Parameter word: the given word, in singular form.
     - Returns: the plural form.
     */
    public class func apply(word: String) -> String {
        return word.characters.count == 0 ? "" : word + "s"
    }
}

/// `PluralizerType` holds the type of a pluralizer used for pluralization. The type must conforms to the `Pluralizer` protocol.
public var PluralizerType: Pluralizer.Type = SimplePluralizer.self

extension String: Wordable {

    /// Holds the singular form of the word.
    public var singularForm: String {
        get {
            return self
        }
    }

    /// Holds the plural form of the word.
    public var pluralForm: String {
        return PluralizerType.apply(self)
    }
