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
|
public struct Key: Hashable {
static var index = 0
public let id: Int
init() {
self.id = Self.index
Self.index += 1
}
}
public struct Variable<Value> {
public let key = Key()
}
public struct Bindings {
private var storage: [Key : Any] = [:]
public init<each T>(
_ value: repeat (Variable<each T>, each T)
) {
_ = (repeat storage[(each value).0.key] = (each value).1)
}
}
public protocol Expression<Result> {
associatedtype Result
func evaluate(_ bindings: Bindings) throws -> Result
}
public struct True: Expression {
public init() {}
public func evaluate(_ bindings: Bindings) throws -> Bool {
true
}
}
public struct Predicate<each Input> {
var variables: (repeat Variable<each Input>)
var expression: any Expression<Bool>
public init<Expr>(
builder: (repeat Variable<each Input>) -> Expr
) where Expr: Expression<Bool> {
self.variables = (repeat Variable<each Input>())
self.expression = builder(repeat each self.variables)
}
public func evaluate(
_ input: repeat each Input
) throws -> Bool {
return try expression.evaluate(
.init(repeat (each self.variables, each input))
)
}
}
extension Sequence {
public func filter(_ predicate: Predicate<Element>) throws -> [Element] {
try self.filter {
try predicate.evaluate($0)
}
}
}
|
