Mean Monoid

Mean.swift

infix operator ☹: AdditionPrecedence

struct Mean: ExpressibleByFloatLiteral, ExpressibleByIntegerLiteral {
    private let total: Float
    private let count: Int

    private init(total: Float, count: Int) {
        self.total = total
        self.count = count
    }
    
    public var averageValue: Float {
        return total / Float(count)
    }
    
    public init(floatLiteral value: Float) {
        self.total = value
        self.count = 1
    }
    
    public init(integerLiteral value: Int) {
        self.init(floatLiteral: Float(value))
    }
    
    // Associative operation
    public static func ☹(lhs: Mean, rhs: Mean) -> Mean {
        return Mean(
            total: lhs.total + rhs.total,
            count: lhs.count + rhs.count
        )
    }
    
    // Identity element
    public static var identity = Mean(total: 0, count: 0)
}

print((1 ☹ 2 ☹ 3 ☹ 4).averageValue)                 // -> 2.5
print((Mean.identity).averageValue)                 // -> nan
print((1 ☹ Mean.identity ☹ 2 ☹ 3 ☹ 4).averageValue) // -> 2.5

// Monoids are useful for incremental computation
var result: Mean = .identity
for x in [1, 2, 3, 4] {
    result = result ☹ Mean(x)
}
print(result.averageValue) // -> 2.5

// We can even do half of the computation on another machine
// and then combine both results later!