   Wraps result of throwing code and allows to map embedded value
 */
 public enum Result<V> {
-  /// Resulted in Error
+  /// Resulted in error
   case error(Error)
-  /// Successfully aquired a Value
+  /// Successfully aquired a value
   case value(V)
   
   // MARK: Initialization

    }
    ```
  */
  public init(unsafe: () throws -> V) {
    do {
      self = .value(try unsafe())
    } catch (let error) {

}

// MARK: Map
precedencegroup MapOperator {
    associativity: left
    higherThan: ComparisonPrecedence
    lowerThan: CastingPrecedence
}

infix operator <^>: MapOperator

/**
  If there's no error, perform function with value and return wrapped result
*/
public func <^> <V, U>(_ transform: (V) -> U, result: Result<V>) -> Result<U> {
  return result.map(transform)
}

/**
 Performs transformation over value of Result.
 */
public func <^> <V>(_ transform: (V) -> Void, result: Result<V>) {
  result.forEach(transform)
}

// MARK: Apply
infix operator <*>: MapOperator

/**
  Apply function wrapped in Result to Result-vrapped value
*/
public func <*> <V, U>(_ transform: Result<(V) -> U>, result: Result<V>) -> Result<U> {
  return result.apply(transform)
}

// MARK: Flat map
precedencegroup LeftFlatMapOperator {
    associativity: left
    higherThan: TernaryPrecedence
    lowerThan: NilCoalescingPrecedence
}

infix operator >>-: LeftFlatMapOperator

/**
  If there's no error, perform function that may yield Result with value and return wrapped result
  Left associative
*/
public func >>- <V, U>(_ result: Result<V>,  transform: (V) -> Result<U>) -> Result<U> {
  return result.flatMap(transform)
}

precedencegroup RightFlatMapOperator {
    associativity: right
    higherThan: TernaryPrecedence
    lowerThan: NilCoalescingPrecedence
}

infix operator -<<: RightFlatMapOperator

/**
  If there's no error, perform function that may yield Result with value and return wrapped result
  Right associative
*/
public func -<< <V, U>(_ transform: (V) -> Result<U>, result: Result<V>) -> Result<U> {
  return result.flatMap(transform)
}
