     case right(value: R)
     case wrong(value: E)
     
-    init(value: R) {
+    public init(value: R) {
         self = .right(value: value)
     }
     
-    init(wrong: E) {
+    public init(wrong: E) {
         self = .wrong(value: wrong)
     }
     
-    init?(value: R?, error: E?) {
+    public init?(value: R?, error: E?) {
         if let e = error {
             self = .wrong(value: e)
             return

    /// - Parameter work: Block of work with error
    /// - Returns: ALEither<R, E>
    @discardableResult
    func doIfWrong(on queue: DispatchQueue? = nil, work: @escaping  (E) -> Void) -> ALEither<R, E> {
        if case .wrong(let err) = self {
            performWork(onQueue: queue, work: { work(err) })
            

    ///   - predicate: (Right) -> Bool
    ///   - default: Default error
    /// - Returns: ALEither<R, E>
    public func takeIf(predicate: (R) -> Bool, wrong: E) -> ALEither<R, E> {
        switch self {
            case .right(let val): return predicate(val) ? self : .wrong(value: wrong)
            case .wrong: return self
        }
    }
    
    public func flatMap<U>(f: (R) -> ALEither<U, E>) -> ALEither<U, E> {
        switch self {
            case .right(let val): return  f(val)
            case .wrong(let err): return .wrong(value: err)
