-
Notifications
You must be signed in to change notification settings - Fork 9
/
Result+Operators.swift
66 lines (50 loc) · 2.12 KB
/
Result+Operators.swift
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
//
// Created by Gordon Fontenot (https://github.com/gfontenot) on 22.01.15.
// From https://github.com/thoughtbot/Runes/blob/a2d22e2a761d4284deb30318930bd7ab3382c47f/Source/Result.swift
//
import Result
import Runes
/**
map a function over a result
- If the value is .Failure, the function will not be evaluated and this will return the failure
- If the value is .Success, the function will be applied to the unwrapped value
:param: f A transformation function from type T to type U
:param: a A value of type Result<T, E>
:returns: A value of type Result<U, E>
*/
public func <^><T, U, E>(f: T -> U, a: Result<T, E>) -> Result<U, E> {
return a.map(f)
}
/**
apply a function from a result to a result
- If the function is .Failure, the function will not be evaluated and this will return the error from the function result
- If the value is .Failure, the function will not be evaluated and this will return the error from the passed result value
- If both the value and the function are .Success, the unwrapped function will be applied to the unwrapped value
:param: f A result containing a transformation function from type T to type U
:param: a A value of type Result<T, E>
:returns: A value of type Result<U, E>
*/
public func <*><T, U, E>(f: Result<(T -> U), E>, a: Result<T, E>) -> Result<U, E> {
return a.apply(f)
}
/**
Wrap a value in a minimal context of .Success
:param: a A value of type T
:returns: The provided value wrapped in .Success
*/
public func pure<T, E>(a: T) -> Result<T, E> {
return .success(a)
}
extension Result {
/**
apply a function from a result to self
- If the function is .Failure, the function will not be evaluated and this will return the error from the function result
- If self is .Failure, the function will not be evaluated and this will return the error from self
- If both self and the function are .Success, the unwrapped function will be applied to self
:param: f A result containing a transformation function from type T to type U
:returns: A value of type Result<U, E>
*/
func apply<U>(f: Result<(T -> U), Error>) -> Result<U, Error> {
return f >>- { $0 <^> self }
}
}