@Swift 的FunctionalProtocols？

Question

我的问题

我正在寻找 Swift 中 Java @FunctionalInterface 的等价物。

Swift 的标题为

Protocol-Oriented Programming Language

，并以其语法糖而闻名。所以我希望任何人都有想法来实现我正在寻找的东西。 我想要这个的原因是在 Swift 中创建协议的

swifty

即时实现，它的行为应该像普通的协议一致数据类型一样。这应该能够用一个闭包来初始化，该闭包代表协议中声明的唯一一个方法。目前 Java 方式比 Swift 更

swifty

。

我也读过这篇文章：

• 如何像Java接口一样在swift中使用闭包

Swift 5.9 给我们带来了

macros

，我希望这可以成为一种方法，但我目前对此并不熟悉。

我的问题

• 有谁知道如何将其实现为 Swift 宏或类似的东西吗？

这是 Swift 目前的方法

protocol ArgumentChecker {
  func check(arguments: [String]) -> Bool
}

struct ClosureArgumentChecker: ArgumentChecker { /// What I want to hide
  let closure: ([String]) -> Bool

  func check(arguments: [String]) -> Bool {
    return closure(arguments)
  }
}

let checker: ArgumentChecker = ClosureArgumentChecker(closure: { arguments in
  return arguments.isEmpty
})

func main() {
  if !(checker is ArgumentChecker) {
    return
  }

  print("checker is an instance of ArgumentChecker")
  let result = checker.check(arguments: CommandLine.arguments)
  print("Result from checker: \(result)")
}

main()

这是一个有效的 Java 等价物

@FunctionalInterface
public interface ArgumentChecker {
    boolean check(final String[] args);

    ArgumentChecker checker = (final String[] arguments) -> arguments.length == 0;

    static void main(final String[] args) {
        if(!(checker instanceof ArgumentChecker)) {
            return;
        }

        System.out.println("checker is an instance of ArgumentChecker");
        final boolean result = checker.check(args);
        System.out.println("Result from checker: " + result);

    }
}

这是我的例外/想法它应该是什么样子

import Foundation

protocol ArgumentChecker {
    func check(args: [String]) -> Bool
} 

@functionalProtocol
let checker: ArgumentChecker = { (args: [String]) -> Bool in
    args.isEmpty
}


func main() {
    guard !(checker is ArgumentChecker) else {
        print("checker is not an ArgumentChecker")
        return
    }
        
    print("checker is an ArgumentChecker")

    let args = ["Hello", "World"]
    let result = checker.check(args)
    print("Result: \(result)")
}

感谢您的回复。

Answer 1

这才是我真正想要的。此时感谢@Sweeper。

/// verbose why
protocol ArgumentChecker {
  var action: ([String]) -> Bool { get }
}

struct ClosureArgumentChecker: ArgumentChecker {
  let action = { (args: [String]) -> Bool in
      return args.isEmpty
  }
}

/// short why
let onTheFlyChecker = { (args: [String]) -> Bool in
    return args.isEmpty
}

func executeClosure(closure: ([String]) -> Bool) -> Bool {
    let input = CommandLine.arguments
    return closure(input)
}

func main() {
    /// verbose why
    let checker = ClosureArgumentChecker()
    let result = executeClosure(closure: checker.action)
    print("Result from checker: \(result)")
    
    /// short why
    let result2 = executeClosure(closure: onTheFlyChecker)
    print("Result from onTheFlyChecker: \(result2)")
  
    /// Or this why
    let result3 = executeClosure { (args: [String]) -> Bool in
        return args.isEmpty
    }
    print("Result from onTheFlyChecker: \(result3)")
}

main()