[swift-evolution] [Discussion] Arbitrary precision integer and float literal protocols

[Michel Fortin]

I think you forgot to consider hexadecimal floating point literals. Those have a power-of-2 significand (instead of power-of-10). They can't be expressed by the `ExpressibleByArbitraryPrecisionFloatLiteral` protocol you're proposing.

> Le 30 mars 2017 à 17:56, David Hart via swift-evolution <swift-evolution at swift.org> a écrit :
> 
> 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 <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 <https://github.com/hartbit/swift-evolution/blob/arbitrary-precision-integer-float-protocol/proposals/XXXX-arbitrary-precision-integer-float-literal-protocols.md>
> Authors: David Hart <https://github.com/hartbit>
> Review Manager: TBD
> Status: TBD
>  <https://github.com/hartbit/swift-evolution/tree/arbitrary-precision-integer-float-protocol#introduction>Introduction
> 
> We propose a pair of protocols extending ExpressibleByIntegerLiteral and ExpressibleByFloatLiteral to allow initializing conforming types with arbitrary precision integer and floating-point literals.
> 
>  <https://github.com/hartbit/swift-evolution/tree/arbitrary-precision-integer-float-protocol#motivation>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.
> 
>  <https://github.com/hartbit/swift-evolution/tree/arbitrary-precision-integer-float-protocol#proposed-solution>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
> swift-evolution at swift.org
> https://lists.swift.org/mailman/listinfo/swift-evolution



-- 
Michel Fortin
https://michelf.ca

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20170331/be6e148c/attachment.html>