Result.swift

//===--- Result.swift -----------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
// RUN: %target-run-stdlib-swift
// REQUIRES: executable_test

publicenumResult<Value>{
case Success(Value)
case Error(Error)

init(success x:Value){
self=.Success(x)
}

init(error:Error){
self=.Error(error)
}

func map<U>(_ transform:(Value)->U)->Result<U>{
switchself{
case.Success(let x):return.Success(transform(x))
case.Error(let e):return.Error(e)
}
}

func flatMap<U>(_ transform:(Value)->Result<U>)->Result<U>{
switchself{
case.Success(let x):returntransform(x)
case.Error(let e):return.Error(e)
}
}

func get()throws->Value{
switchself{
case.Success(let x):return x
case.Error(let e):throw e
}
}

varsuccess:Value?{
switchself{
case.Success(let x):return x
case.Error:returnnil
}
}

varerror:Error?{
switchself{
case.Success:returnnil
case.Error(let x):return x
}
}
}

publicfunc??<T>(
 result:Result<T>, defaultValue:@autoclosure()->T
)->T{
switch result {
case.Success(let x):return x
case.Error:returndefaultValue()
}
}

// We aren't actually proposing this overload; we think there should
// be a compiler warning that catches the promotion that you probably
// don't want.
publicfunc??<T>(
 result:Result<T>?, defaultValue:@autoclosure()->T
)->T{
fatalError("We should warn about Result<T> being promoted to Result<T>?")
}

/// Translate the execution of a throwing closure into a Result
func catchResult<Success>(
 invoking body:()throws->Success
)->Result<Success>{
do{
returntry.Success(body())
}
catch{
return.Error(error)
}
}

// A couple of error types
enumNasty:Error{
case Bad, Awful, Terrible
}

enumIcky:Error{
case Sad, Bad, Poor
}

// Some Results to work with
letthree=Result(success:3)
letfour=Result(success:4)
letnasty=Result<Int>(error:Nasty.Bad)
leticky=Result<String>(error:Icky.Sad)

print(three)
print(nasty)
print(icky)

print(three ??4)
print(nasty ??4)

print(three.map{String($0)})
print(nasty.map{String($0)})


print(three.flatMap{.Success(String($0))})
print(nasty.flatMap{.Success(String($0))})

print(three.flatMap{ _ in icky })
print(nasty.flatMap{ _ in icky })

tryprint(three.get())
do{
tryprint(nasty.get())
}
catch{
print(error)
}

func mayFail(_ fail:Bool)throws->Int{
if fail {throwIcky.Poor }
return0
}

print(catchResult{trymayFail(true)})
print(catchResult{trymayFail(false)})

print(catchResult{1}.flatMap{ _ inResult(success:4)}.flatMap{ _ inResult<String>(error:Icky.Poor)})
print(catchResult{1}.map{ _ in three }.flatMap{$0})

letresults=[three, nasty, four]
print(results.flatMap{ $0.success })
print(results.flatMap{ $0.error })
print(results.contains{ $0.success !=nil})

// Mistaken usage; causes Result<T> to be promoted to Result<T>?
// print(three ?? nasty)