> On 31 Mar 2017, at 04:21, David Sweeris <[email protected]> wrote: > > > > > Sent from my iPhone > On Mar 30, 2017, at 14:56, David Hart via swift-evolution > <[email protected]> wrote: > >> Hello swift-evolution, >> >> I’m working on a proposal for arbitrary precision integer and float literal >> protocols to complement ExpressibleByIntegerLiteral and >> ExpressibleByFloatLiteral. I’m looking for feedback and help in verifying >> the logic - I have doubts about endianness. >> >> Fire away! >> >> https://github.com/hartbit/swift-evolution/blob/arbitrary-precision-integer-float-protocol/proposals/XXXX-arbitrary-precision-integer-float-literal-protocols.md >> >> Arbitrary precision integer and float literal procotols >> Proposal: SE-XXXX >> Authors: David Hart >> Review Manager: TBD >> Status: TBD >> Introduction >> >> We propose a pair of protocols extending ExpressibleByIntegerLiteral and >> ExpressibleByFloatLiteral to allow initializing conforming types with >> arbitrary precision integer and floating-point literals. >> >> Motivation >> >> The current protocols ExpressibleByIntegerLiteral and >> ExpressibleByFloatLiteral are simple and work well but don't support >> arbitrary precision literal values. Replacing those protocols is a non-goal >> as they provide a simple interface for work well for most cases. Therefore, >> to support initializing big integer and big float types with literal values, >> we need new protocols. >> >> Proposed solution >> >> We propose: >> >> renaming FloatingPointSign into Sign, >> introducing a ExpressibleByArbitraryPrecisionIntegerLiteral protocol that >> extends ExpressibleByIntegerLiteral and provides a new arbitrary precision >> initializer, >> introducing a ExpressibleByArbitraryPrecisionFloatLiteral protocol that >> extends ExpressibleByFloatLiteral and provides a new arbitrary precision >> initializer. >> Here is the corresponding code: >> >> /// The sign of a number. >> public enum Sign : Int { >> >> /// The sign for a positive value. >> case plus >> >> /// The sign for a negative value. >> case minus >> } >> >> /// A type that can be initialized with an arbitrary precision integer >> literal. >> public protocol ExpressibleByArbitraryPrecisionIntegerLiteral: >> ExpressibleByIntegerLiteral { >> >> /// Creates an instance initialized with the sign and memory value of the >> /// arbitrary precision integer literal. >> /// >> /// Do not call this initializer directly. Instead, initialize a >> variable or >> /// constant using an arbitrary precision integer literal. For example: >> /// >> /// let x = 123_456_789_123_456_789_123_456_789 >> /// >> /// In this example, the assignment to the `x` constant calls this >> integer >> /// literal initializer behind the scenes with `sign` as `.plus` and >> /// `buffer` as the memory [0x0000000000661EFD, 0xF2E3B19F7C045F15]. >> /// >> /// - Parameters: >> /// sign: The sign of the integer value. >> /// buffer: The memory value of the integer. >> init(sign: Sign, buffer: UnsafeBufferPointer<UInt64>) >> } >> >> /// A type that can be initialized with an arbitrary precision float literal. >> public protocol ExpressibleByArbitraryPrecisionFloatLiteral: >> ExpressibleByFloatLiteral { >> >> /// Creates an instance initialized with the sign, exponent and >> /// significand of the arbitrary precision float literal. >> /// >> /// Do not call this initializer directly. Instead, initialize a >> variable or >> /// constant using an arbitrary precision integer literal. For example: >> /// >> /// let x = 123_456_789_123_456.789_123_456_789 >> /// >> /// In this example, the assignment to the `x` constant calls this float >> /// literal initializer behind the scenes with `sign` as `.plus`, >> `exponent` >> /// as the memory [0x0000000000661EFD, 0xF2E3B19F7C045F15] and >> `significand` >> /// with value [0x000000000000000C]. >> /// >> /// - Parameters: >> /// sign: The sign of the integer value. >> /// exponent: The memory value of the exponent. >> /// significand: The memory value of the significand. >> init( >> sign: Sign, >> exponent: UnsafeBufferPointer<UInt64>, >> significand: UnsafeBufferPointer<UInt64>) >> } >> >> >> >> _______________________________________________ >> swift-evolution mailing list >> [email protected] >> https://lists.swift.org/mailman/listinfo/swift-evolution > > IIRC, some branches of math don't consider 0 to be positive or negative, so I > might add a `zero` case in `Sign`.
That will never happen: the literal value 0 on a type conforming to one of those protocols will call the super-protocol's initializer because it is representable with all built-in types. > Also, I'm not sure new protocols are actually necessary. I think I remember > hearing somewhere that LLVM supports integer literals up to something like > 400 bits? If so, we'd merely need a type that exposes those bytes to set the > relevant types `IntegerLiteralType` associated type. I am clueless in this regard so please let me know if you find more information. > - Dave Sweeris
_______________________________________________ swift-evolution mailing list [email protected] https://lists.swift.org/mailman/listinfo/swift-evolution
