 
 
 func max<T : NumericType>(numbers: T...) -> T {
-    return numbers.max { $0 > $1 }
+    return numbers.max { $0 > $1 }!
 }
 
 func min<T : NumericType>(numbers: T...) -> T {
-    return numbers.max { $0 < $1 }
-}
-
+    return numbers.max { $0 < $1 }!
+}
+
+// prefix operator ! {}
+prefix func ! <T: EnhancedIntegerType>(value: T) throws -> T {
+    let fac = value.faculty
+    if fac > UInt64(T.max) { throw NumberError.TooBigForType("0x\(fac.hex), \(fac.dec) is too large to fit into \(T.self)") }
+    return T(fac)
+}

    static var max : Float { return FLT_MAX }
    static var min : Float { return FLT_MIN }
    public func successor() -> Float {
        return nextafterf(self, self + 1)
    }
}


    var isInfinite: Bool { return false }
    var isNaN: Bool { return false }
    var isSignaling: Bool { return false }
    var nextPowerOf2: Int {
        let c = ceil(log2(Double(self)))
        return Int(pow(2.0, c))
    }
    var faculty : UInt64 {
        let one = UInt64(1)
        if self <= Self(1) { return one }
        let value = UInt64(self)
        return value * (value - one).faculty
    }
}

protocol EnhancedFloatingPointType : NumericType {}
extension EnhancedFloatingPointType {
    var inaccuracy : Self {
        let this : Self = self
        let succ : Self = self.successor()
        print("\(this) -> \(succ)")
        return succ - this
    }
}

extension Int    : EnhancedIntegerType {}
extension Int8   : EnhancedIntegerType {}
