class HoareFunction<I, R, Either<Self.PredicateFailure, E>, E: Error>: Function<I, R, E> {
    enum PredicateFailure: Error {
        case preconditionException(failedPred: ((I) -> Bool)?, failureReason: String)
        case postconditionException(failedPred: ((R) -> Bool)?, failureReason: String)
    }
    private var preconditions: Array<(fn: (I) -> Bool, msg: String)>
    private var postconditions: Array<(fn: (R) -> Bool, msg: String)>

    init(
        preconditions: [(fn: (I) -> Bool, msg: String)], 
        postconditions: [(fn: (R) -> Bool, msg: String)],
        errorType: E.Type,
        function: @escaping (I) throws -> R
    ){
        super.init(errorType: errorType, function)
        self.preconditions = preconditions
        self.postconditions = postconditions
    }

    override func invoke(_ arg: I) -> Result<R, E> {
        do {
            if preconditions.allSatisfy({$0.fn(arg)==true}) {
                let ret = try fn(arg)
                if postconditions.allSatisfy({$0.fn(ret)==true}) {
                    return .success(ret)
                } else {
                    return .failure(.a(
                        PredicateFailure.postconditionException(
                            failedPred: nil,
                            failureReason: """
                            Stuff happened in postconditions
                            """
                        )
                    ))
                }
            } else {
                return .failure(.a(
                    PredicateFailure.preconditionException(
                        failedPred: nil,
                        failureReason: """
                        Stuff happened in preconditions
                        """
                    )
                ))
            }
        } catch let error {
            return .failure(.b(error))
        }
    }
}