Swift 함수 커링 사용하기

func add(_ value1: Int, _ value2: Int) -> Int {
return value1 + value2
}
add(2,3)

func curriedAdd(_ value1: Int) -> ( (Int) -> Int ) {
return { value2 in
}
}

return { value2 in
}
}
let add2 = curriedAdd(2)
add2(3)

return { value2 in
}
}
add2(3)
curriedAdd(2)(3)

add2(3)
curriedAdd(2)(3)
func curriedAdd(_ value1: Int) -> (Int) -> Int {
return { value2 in
}
}

"aaa/bbb/ccc/ddd".components(separatedBy: "/")
"aaa*bbb*ccc*ddd".components(separatedBy: "*")

func stringDevider(_ seperater: String) -> (String) -> [String] {
return { (string: String) -> [String] in
return string.components(separatedBy: seperater)
}
}
let stringDevideBySlash = stringDevider("/")
let stringDevideByAsterisk = stringDevider("*")
stringDevideBySlash("aaa/bbb/ccc/ddd")
stringDevideByAsterisk("aaa*bbb*ccc*ddd")

class SomeClass {
func someFunction() {
}
}

class SomeClass {
}
}
let someinstance = SomeClass()
someinstance.someFunction()

class SomeClass {
}
}
let someinstance = SomeClass()
someinstance.someFunction()
SomeClass.someFunction(someinstance)()

func regexTest(pattern: String) -> (String) -> Bool

{
let expression: NSRegularExpression? =
try? NSRegularExpression(pattern: pattern,
options: .caseInsensitive)
return { (input: String) -> Bool in
guard let expression = expression else { return false }
let inputRange = NSMakeRange(0, input.characters.count)
let matches = expression.matches(in: input,
options: [],
range: inputRange)
return matches.count > 0
}
}

{
options: [],
range: inputRange)
}
}
regexTest(pattern: "main")("int main()")

{
options: [],
range: inputRange)
}
}
regexTest(pattern: "main")("int main()")
let hasMainIn = regexTest(pattern: "main")
hasMainIn("int main()")

class Regex {
var internalExpression: NSRegularExpression?
init(_ pattern: String) {
self.internalExpression =
try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
}
func test(_ input: String) -> Bool {
guard let matchesCount = self.internalExpression?
.matches(in: input, options: [], range:inputRange)
.count else { return false }
return matchesCount > 0
}
}

class Regex {
}
}
}
let regex = Regex("main")
regex.test("int main()")
Regex("main").test("int main()")

class Regex {
}
}
}
let regex = Regex("main")
regex.test("int main()")
Regex("main").test("int main()")
let hasMainIn = Regex("main").test
hasMainIn("int main()")

struct Friend {
var name: String
var id: Int
}

struct Friend {
var name: String
var id: Int
}
let friends = [Friend(name:" ", id: 1),
Friend(name:" ", id: 2),
Friend(name:" ", id: 5)]

struct Friend {
var name: String
var id: Int
}
let friends = [Friend(name:" ", id: 1),
Friend(name:" ", id: 5)]
func inviteFriend(ID: Int) -> Void

let actionsheet = UIAlertController(title: " ", message: " ",
preferredStyle: .actionSheet)

let actionsheet = UIAlertController(title: " ", message: " ",
preferredStyle: .actionSheet)
UIAlertAction(title: String?, style: UIAlertActionStyle, handler:
((UIAlertAction) -> Void)?)

func actionHandler(friendID: Int) -> (UIAlertAction) -> () {
return { [weak self] action -> Void in
self?.inviteFriend(ID: friendID)
}
}
friends.forEach{ (friend: Friend) in
actionsheet.addAction(UIAlertAction(title: friend.name,
style: UIAlertActionStyle.default,
handler: actionHandler(friendID:
friend.id)))
}
actionsheet.addAction(UIAlertAction(title: " ", style: .cancel, handler: nil))

class ViewController: UIViewController {
@IBOutlet var yellowBox: UIView!
}

class ViewController: UIViewController {
@IBOutlet var yellowBox: UIView!
}
extension ViewController {
@IBAction func leftButtonTapped(_ sender: Any) {
UIView.animate(withDuration: 0.5, animations: {
var frame = self.yellowBox.frame
frame.origin.x = frame.origin.x - 100
self.yellowBox.frame = frame
}, completion: nil)
}
@IBAction func rightButtonTapped(_ sender: Any) {
frame.origin.x = frame.origin.x + 100
}, completion: nil)
}
@IBAction func upButtonTapped(_ sender: Any) {
frame.origin.y = frame.origin.y - 100

}, completion: nil)
}
}, completion: nil)
}
}, completion: nil)
}
@IBAction func downButtonTapped(_ sender: Any) {
frame.origin.y = frame.origin.y + 100
}, completion: nil)
}
}

enum AnimationDirection {
case up
case down
case left
case right
}
func moveBox(to: AnimationDirection) -> () -> Void {
return {
switch to {
case .left:
case .right:
case .down:
case .up:
}
}
}

case .down:
case .up:
}
}
}
UIView.animate(withDuration: 0.5,
animations: moveBox(to: .left),
completion: nil)
}
animations: moveBox(to: .right),
completion: nil)
}
animations: moveBox(to: .up),
completion: nil)
}
@IBAction func downButtonTapped(_ sender: Any) {
animations: moveBox(to: .down),
completion: nil)
}
}

viewController.api = { (pageID: Int) -> Observable<[Post]> in
// alamofire api Observable Return
}

viewController.api = { (pageID: Int) -> Observable<[Post]> in
// alamofire api Observable Return
}
func searchAPI(searchText: String) -> (Int) -> Observable<[Post]>
self.api = searchAPI(searchText: "search keywords")

func curry<A, B, C>(f: @escaping (A, B) -> C) -> ((A) -> ((B) -> C)) {
return { x in { y in f(x, y) }}
}
func fiveTimeCurry<A, B, C, D, E>(_ a: A) -> (B) -> (C) -> (D) -> E {
}

g(f(x))
let result = bind(add2, 3) // result => 5

g(f(x))
let result = bind(add2, 3) // result => 5
infix operator >>=: MultiplicationPrecedence
func >>=<A, B>(a: A, f: (A) -> B) -> B

Swift 함수 커링 사용하기

More Related Content

Swift 함수 커링 사용하기