protocol ViewModelType {
    associatedtype Input
    associatedtype Output

    func transform(input: Input) -> Output
}

class MyViewModel: ViewModelType {
  struct Input { } 
  struct Output { }

  func transform(input: Input) { return Output() } 
}

func transform(input: Input) -> Output {
    let count = BehaviorRelay(value: 0)
    
    input.viewDidAppear
        .flatMapLatest { [unowned self] () -> Observable<BaseModel<RetrospectCount>> in
            return self.requestEnabledRetrospectCount().asObservable()
        }
        .subscribe(onNext: {
            count.accept($0.data.count)
        })
        .disposed(by: bag)

        return Output(retrospectCount: count)
}

// 완료함 뷰컨
func bindViewModel() {
    // MARK: - 리팩토링 코드
    let input = CompletionViewModel.Input(viewDidAppear: viewDidAppearTrigger)
    let output = viewModel.transform(input: input)
    
    // 1. 회고 작성가능 갯수 카운트 레이블 바인딩
    
    output.retrospectCount
        .map { count -> NSAttributedString in
            let stringValue = "총 \(count)개의 목표 회고를 작성할 수 있어요!"
            let attributedString: NSMutableAttributedString = NSMutableAttributedString(string: stringValue)
            attributedString.setColorForText(textForAttribute: "총 \(count)개의 목표 회고", withColor: .pointPurple)
            return attributedString
        }
        .bind(to: alertBox.label.rx.attributedText)
        .disposed(by: disposeBag)

protocol APIService {
    func request<T: Codable> (_ request: APIRouter) -> Observable<Result<T, APIError>>
    func requestSingle<T: Codable> (_ request: APIRouter) -> Single<T>
}

func requestSingle<T: Codable>(_ request: APIRouter) -> Single<T> {
        return Single<T>.create { observer -> Disposable in
                let request = API.session.request(request, interceptor: APIInterceptor()).responseDecodable { (response: DataResponse<T, AFError>) in
                    guard let statusCode = response.response?.statusCode else {
                        observer(.failure(APIError.unknown))
                        return
                    }

                    guard (200 ... 399).contains(statusCode) else {
                        observer(.failure(APIError.http(status: statusCode)))
                        return
                    }

                    guard let decoded = response.data?.decode(T.self) else {
                        observer(.failure(APIError.decode))
                        return
                    }

                    observer(.success(decoded))
                    return
                }

                return Disposables.create {
                    request.cancel()
                }
            }
    }

protocol ServicesGoalList {
  func requestAllGoalsWithSignle(lastGoalId: Int, goalStatusParameter: GoalStatusParameter) -> Single<BaseModel<GoalResponse>>
}