data-textual (empty) → 0.1

raw patch · 6 files changed

+2664/−0 lines, 6 filesdep +QuickCheckdep +basedep +bytestringsetup-changed

Dependencies added: QuickCheck, base, bytestring, data-textual, parsers, tagged, test-framework, test-framework-quickcheck2, text, text-latin1, text-printer

Files

• LICENSE +27/−0
• Setup.hs +2/−0
• data-textual.cabal +57/−0
• src/Data/Textual.hs +649/−0
• src/Data/Textual/Numerals.hs +1641/−0
• tests/Tests.hs +288/−0

@@ -0,0 +1,27 @@+Copyright (c) 2013 Mikhail Vorozhtsov+All rights reserved.++Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met:++- Redistributions of source code must retain the above copyright notice, +  this list of conditions and the following disclaimer.+- Redistributions in binary form must reproduce the above copyright +  notice, this list of conditions and the following disclaimer in the +  documentation and/or other materials provided with the distribution.+- Neither the names of the copyright owners nor the names of the +  contributors may be used to endorse or promote products derived +  from this software without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.+

@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain

@@ -0,0 +1,57 @@+Name: data-textual+Version: 0.1+Category: Data, Text+Stability: experimental+Synopsis: Human-friendly textual representations.+Description:+  This package provides an interface for converting between data and its+  (human-friendly) textual representation.++Homepage: https://github.com/mvv/data-textual+Bug-Reports: https://github.com/mvv/data-textual/issues++Author: Mikhail Vorozhtsov <mikhail.vorozhtsov@gmail.com>+Maintainer: Mikhail Vorozhtsov <mikhail.vorozhtsov@gmail.com>+Copyright: 2013 Mikhail Vorozhtsov <mikhail.vorozhtsov@gmail.com>+License: BSD3+License-File: LICENSE++Cabal-Version: >= 1.10.0+Build-Type: Simple++Source-Repository head+  Type: git+  Location: https://github.com/mvv/data-textual.git++Library+  Default-Language: Haskell2010+  Build-Depends:+    base >= 4 && < 5,+    bytestring >= 0.10,+    text,+    tagged >= 0.2,+    text-latin1 >= 0.2,+    text-printer >= 0.3,+    parsers >= 0.5+  Hs-Source-Dirs: src+  GHC-Options: -Wall+  Exposed-Modules:+    Data.Textual+    Data.Textual.Numerals++Test-Suite tests+  Default-Language: Haskell2010+  Type: exitcode-stdio-1.0+  Build-Depends:+    base                       >= 4 && < 5,+    test-framework             >= 0.5,+    test-framework-quickcheck2 >= 0.2,+    QuickCheck                 >= 2.4,+    text-printer,+    tagged,+    parsers,+    data-textual+  Hs-Source-Dirs: tests+  GHC-Options: -Wall+  Main-Is: Tests.hs+

@@ -0,0 +1,649 @@+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE DeriveFunctor #-}+{-# LANGUAGE DeriveFoldable #-}+{-# LANGUAGE DeriveTraversable #-}+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE FlexibleInstances #-}++-- | Working with human-friendly (as opposed to the compiler-friendly+--   'Show' and 'Read') textual representations.+module Data.Textual+  (+  -- * Printing+    Printable(..)+  , maybePrint+  , toString+  , toText+  , toLazyText+  , toAscii+  , toLazyAscii+  , toUtf8+  , toLazyUtf8+  -- * Parsing+  , Textual(..)+  -- ** Standard types proxies+  , hintType+  , hintType1+  , hintTypeArg+  , aUnit+  , aChar+  , anInteger+  , anInt+  , anInt8+  , anInt16+  , anInt32+  , anInt64+  , aWord+  , aWord8+  , aWord16+  , aWord32+  , aWord64+  , aFloat+  , aDouble+  , aMaybe+  , aMaybeOf+  , aList+  , aListOf+  -- ** Built-in parser+  , Parsed(..)+  , isParsed+  , isMalformed+  , maybeParsed+  , builtInParser+  , parseString+  , parseStringAs+  , parseText+  , parseTextAs+  , parseLazyText+  , parseLazyTextAs+  , parseAscii+  , parseAsciiAs+  , parseLazyAscii+  , parseLazyAsciiAs+  , parseUtf8+  , parseUtf8As+  , parseLazyUtf8+  , parseLazyUtf8As+  , fromString+  , fromStringAs+  , fromText+  , fromTextAs+  , fromLazyText+  , fromLazyTextAs+  , fromAscii+  , fromAsciiAs+  , fromLazyAscii+  , fromLazyAsciiAs+  , fromUtf8+  , fromUtf8As+  , fromLazyUtf8+  , fromLazyUtf8As+  ) where++import Prelude hiding (print)+import Data.Typeable (Typeable)+import Data.Proxy (Proxy(..))+import Data.Foldable (Foldable)+import Data.Traversable (Traversable)+import Data.Monoid (mempty)+import Data.Int+import Data.Word+import Data.List (stripPrefix)+import qualified Data.ByteString as BS+import qualified Data.ByteString.Char8 as BS8+import qualified Data.ByteString.Lazy as BL+import qualified Data.ByteString.Lazy.Char8 as BL8+import qualified Data.Text as TS+import qualified Data.Text.Lazy as TL+import Data.Text.Lazy.Encoding (decodeUtf8)+import Data.Textual.Numerals+import Control.Applicative+import qualified Text.Printer as TP+import qualified Text.Printer.Numerals as TP+import Text.Parser.Combinators (Parsing, (<?>))+import qualified Text.Parser.Combinators as PC+import Text.Parser.Char (CharParsing)+import qualified Text.Parser.Char as PC++-- | The default printer for values of a type.+class Printable α where+  print ∷ TP.Printer p ⇒ α → p++instance Printable Char where+  print = TP.char+  {-# INLINE print #-}++instance Printable String where+  print = TP.string+  {-# INLINE print #-}++instance Printable TS.Text where+  print = TP.text+  {-# INLINE print #-}++instance Printable TL.Text where+  print = TP.lazyText+  {-# INLINE print #-}++instance Printable Integer where+  print = TP.decimal+  {-# INLINE print #-}++instance Printable Int where+  print = TP.decimal+  {-# INLINE print #-}++instance Printable Int8 where+  print = TP.decimal+  {-# INLINE print #-}++instance Printable Int16 where+  print = TP.decimal+  {-# INLINE print #-}++instance Printable Int32 where+  print = TP.decimal+  {-# INLINE print #-}++instance Printable Int64 where+  print = TP.decimal+  {-# INLINE print #-}++instance Printable Word where+  print = TP.nnDecimal+  {-# INLINE print #-}++instance Printable Word8 where+  print = TP.nnDecimal+  {-# INLINE print #-}++instance Printable Word16 where+  print = TP.nnDecimal+  {-# INLINE print #-}++instance Printable Word32 where+  print = TP.nnDecimal+  {-# INLINE print #-}++instance Printable Word64 where+  print = TP.nnDecimal+  {-# INLINE print #-}++instance Printable Float where+  print = TP.string7 . show+  {-# INLINE print #-}++instance Printable Double where+  print = TP.string7 . show+  {-# INLINE print #-}++-- | A shorthand for @'maybe' 'mempty' 'print'@.+maybePrint ∷ (TP.Printer p, Printable α) ⇒ Maybe α → p+maybePrint = maybe mempty print+{-# INLINE maybePrint #-}++-- | A shorthand for @'TP.buildString' . 'print'@.+toString ∷ Printable α ⇒ α → String+toString = TP.buildString . print+{-# INLINE toString #-}++-- | A shorthand for @'TP.buildText' . 'print'@.+toText ∷ Printable α ⇒ α → TS.Text+toText = TP.buildText . print+{-# INLINE toText #-}++-- | A shorthand for @'TP.buildLazyText' . 'print'@.+toLazyText ∷ Printable α ⇒ α → TL.Text+toLazyText = TP.buildLazyText . print+{-# INLINE toLazyText #-}++-- | A shorthand for @'TP.buildAscii' . 'print'@.+toAscii ∷ Printable α ⇒ α → BS.ByteString+toAscii = TP.buildAscii . print+{-# INLINE toAscii #-}++-- | A shorthand for @'TP.buildLazyAscii' . 'print'@.+toLazyAscii ∷ Printable α ⇒ α → BL.ByteString+toLazyAscii = TP.buildLazyAscii . print+{-# INLINE toLazyAscii #-}++-- | A shorthand for @'TP.buildUtf8' . 'print'@.+toUtf8 ∷ Printable α ⇒ α → BS.ByteString+toUtf8 = TP.buildUtf8 . print+{-# INLINE toUtf8 #-}++-- | A shorthand for @'TP.buildLazyUtf8' . 'print'@.+toLazyUtf8 ∷ Printable α ⇒ α → BL.ByteString+toLazyUtf8 = TP.buildLazyUtf8 . print+{-# INLINE toLazyUtf8 #-}++-- | The default parser for values of a type, must satisfy+--   @+--     'fromString' ('toString' /x/) = 'Just' /x/+--   @+class Printable α ⇒ Textual α where+  textual ∷ (Monad μ, CharParsing μ) ⇒ μ α++instance Textual Char where+  textual = PC.anyChar+  {-# INLINE textual #-}++instance Textual Integer where+  textual = number Decimal+  {-# INLINE textual #-}++instance Textual Int where+  textual = bounded Decimal+  {-# INLINE textual #-}++instance Textual Int8 where+  textual = bounded Decimal+  {-# INLINE textual #-}++instance Textual Int16 where+  textual = bounded Decimal+  {-# INLINE textual #-}++instance Textual Int32 where+  textual = bounded Decimal+  {-# INLINE textual #-}++instance Textual Int64 where+  textual = bounded Decimal+  {-# INLINE textual #-}++instance Textual Word where+  textual = nnBounded Decimal+  {-# INLINE textual #-}++instance Textual Word8 where+  textual = nnBounded Decimal+  {-# INLINE textual #-}++instance Textual Word16 where+  textual = nnBounded Decimal+  {-# INLINE textual #-}++instance Textual Word32 where+  textual = nnBounded Decimal+  {-# INLINE textual #-}++instance Textual Word64 where+  textual = nnBounded Decimal+  {-# INLINE textual #-}++-- | Hint the type system about the type of the first argument.+hintType ∷ α → Proxy α → α+hintType a _ = a+{-# INLINE hintType #-}++-- | Hint the type system about the type constructor.+hintType1 ∷ f α → Proxy f → f α+hintType1 f _ = f+{-# INLINE hintType1 #-}++-- | Hint the type system about the type argument. +hintTypeArg ∷ f α → Proxy α → f α+hintTypeArg f _ = f+{-# INLINE hintTypeArg #-}++infixl 1 `hintType`, `hintType1`, `hintTypeArg`++-- | /()/ proxy value.+aUnit ∷ Proxy ()+aUnit = Proxy++-- | 'Char' proxy value.+aChar ∷ Proxy Char+aChar = Proxy++-- | 'Integer' proxy value.+anInteger ∷ Proxy Integer+anInteger = Proxy++-- | 'Int' proxy value.+anInt ∷ Proxy Int+anInt = Proxy++-- | 'Int8' proxy value.+anInt8 ∷ Proxy Int8+anInt8 = Proxy++-- | 'Int16' proxy value.+anInt16 ∷ Proxy Int16+anInt16 = Proxy++-- | 'Int32' proxy value.+anInt32 ∷ Proxy Int32+anInt32 = Proxy++-- | 'Int64' proxy value.+anInt64 ∷ Proxy Int64+anInt64 = Proxy++-- | 'Word' proxy value.+aWord ∷ Proxy Word+aWord = Proxy++-- | 'Word8' proxy value.+aWord8 ∷ Proxy Word8+aWord8 = Proxy++-- | 'Word16' proxy value.+aWord16 ∷ Proxy Word16+aWord16 = Proxy++-- | 'Word32' proxy value.+aWord32 ∷ Proxy Word32+aWord32 = Proxy++-- | 'Word64' proxy value.+aWord64 ∷ Proxy Word64+aWord64 = Proxy++-- | 'Float' proxy value.+aFloat ∷ Proxy Float+aFloat = Proxy++-- | 'Double' proxy value.+aDouble ∷ Proxy Double+aDouble = Proxy++-- | 'Maybe' proxy value.+aMaybe ∷ Proxy Maybe+aMaybe = Proxy++-- | 'Maybe' /α/ proxy value.+aMaybeOf ∷ Proxy α → Proxy (Maybe α)+aMaybeOf _ = Proxy++-- | List proxy value.+aList ∷ Proxy []+aList = Proxy++-- | List of /α/ proxy value.+aListOf ∷ Proxy α → Proxy ([α])+aListOf _ = Proxy++-- | Parsing result.+data Parsed α = Parsed α+              | Malformed [String] String+              deriving (Typeable, Functor, Foldable, Traversable, Eq, Show)++instance Applicative Parsed where+  pure = Parsed+  {-# INLINE pure #-}+  Parsed f       <*> Parsed a       = Parsed (f a)+  Malformed ls e <*> _              = Malformed ls e+  _              <*> Malformed ls e = Malformed ls e+  {-# INLINABLE (<*>) #-}++instance Alternative Parsed where+  empty = Malformed [] "Alternative.empty"+  {-# INLINE empty #-}+  p@(Parsed _) <|> _ = p+  _            <|> p = p+  {-# INLINABLE (<|>) #-}++-- | Map 'Parsed' to 'True' and 'Malformed' to 'False'.+isParsed ∷ Parsed α → Bool+isParsed (Parsed _) = True+isParsed _          = False++-- | Map 'Parsed' to 'False' and 'Malformed' to 'True'.+isMalformed ∷ Parsed α → Bool+isMalformed (Malformed _ _) = True+isMalformed _               = False++-- | Map 'Parsed' values to 'Just' and 'Malformed' to 'Nothing'.+maybeParsed ∷ Parsed α → Maybe α+maybeParsed (Parsed a) = Just a+maybeParsed _          = Nothing+{-# INLINABLE maybeParsed #-}++data Parser α =+  Parser { runParser ∷ ∀ r+                     . [String] → Word → String+                     → ([String] → Word → String → α → Parsed r)+                     → ([String] → Word → String → String → Parsed r)+                     → Parsed r }++instance Functor Parser where+  fmap f p = Parser $ \ls n i c h →+               runParser p ls n i (\ls' n' i' a → c ls' n' i' (f a)) h+  {-# INLINE fmap #-}++instance Applicative Parser where+  pure a = Parser $ \ls n i c _ → c ls n i a+  {-# INLINE pure #-}+  p <*> p' = Parser $ \ls n i c h →+               runParser p ls n i +                 (\ls' n' i' f →+                    runParser p' ls' n' i'+                      (\ls'' n'' i'' a → c ls'' n'' i'' (f a)) h)+                 h+  {-# INLINE (<*>) #-}+  p *> p' = Parser $ \ls n i c h →+              runParser p ls n i (\ls' n' i' _ → runParser p' ls' n' i' c h) h+  {-# INLINE (*>) #-}+  p <* p' = Parser $ \ls n i c h →+              runParser p ls n i+                        (\ls' n' i' a →+                           runParser p' ls' n' i'+                                     (\ls'' n'' i'' _ → c ls'' n'' i'' a) h)+                        h+  {-# INLINE (<*) #-}++instance Alternative Parser where+  empty = PC.unexpected "Alternative.empty"+  {-# INLINE empty #-}+  p <|> p' = Parser $ \ls n i c h →+               runParser p ls n i c $ \ls' n' i' e → +                 if n' == n then runParser p' ls n' i' c h+                            else h ls' n' i' e+  {-# INLINE (<|>) #-}++instance Parsing Parser where+  try p = Parser $ \ls n i c h →+            runParser p ls n i c (\ls' _ _ e → h ls' n i e)+  {-# INLINE try #-}+  p <?> l = Parser $ \ls n i c h →+              runParser p (l : ls) n i (\_ n' i' a → c ls n' i' a) h+  {-# INLINE (<?>) #-}+  skipMany p = Parser $ \ls n i c h →+                 runParser p ls n i+                   (\ls' n' i' _ → runParser (PC.skipMany p) ls' n' i' c h)+                   (\ls' n' i' _ → c ls' n' i' ())+  skipSome p = p *> PC.skipMany p+  {-# INLINE skipSome #-}+  unexpected e = Parser $ \ls n i _ h → h ls n i e+  {-# INLINE unexpected #-}+  eof = Parser $ \ls n i c h → case i of+                   [] → c ls n i ()+                   _  → h ls n i "Parsing.eof"+  {-# INLINABLE eof #-}+  notFollowedBy p = Parser $ \ls n i c h →+                      runParser p ls n i+                                (\_ _ _ _ → h ls n i "Parsing.notFollowedBy")+                                (\_ _ _ _ → c ls n i ())+  {-# INLINE notFollowedBy #-}++instance CharParsing Parser where+  satisfy f = Parser $ \ls n i c h → case i of+                         x : xs | f x → c ls n' xs x+                                          where !n' = n + 1+                         _ → h ls n i "CharParsing.satisfy"+  {-# INLINABLE satisfy #-}+  string s = Parser $ \ls n i c h → case stripPrefix s i of+                        Just i' → c ls n' i' s+                                    where !n' = n + fromIntegral (length s)+                        Nothing → h ls n i "CharParsing.string"+  {-# INLINABLE string #-}++instance Monad Parser where+  return = pure+  {-# INLINE return #-}+  p >>= f = Parser $ \ls n i c h →+              runParser p ls n i+                        (\ls' n' i' a → runParser (f a) ls' n' i' c h) h+  {-# INLINE (>>=) #-}+  (>>) = (*>)+  {-# INLINE (>>) #-}+  fail = PC.unexpected+  {-# INLINE fail #-}++parse ∷ Parser α → String → Parsed α+parse p i = runParser p [] 0 i (\_  _ _ a → Parsed a)+                               (\ls _ _ e → Malformed (reverse ls) e)+{-# INLINE parse #-}++-- | Use the built-in parser to parse a string. Intended for testing only.+builtInParser ∷ (∀ μ . (Monad μ, CharParsing μ) ⇒ μ α) → String → Parsed α+builtInParser p = parse p+{-# INLINE builtInParser #-}++-- | Parse a 'String' to extract the 'Textual' value.+parseString ∷ Textual α ⇒ String → Parsed α+parseString = parse $ textual <* PC.eof+{-# INLINE parseString #-}++-- | Provide a hint for the type system when using 'parseString'.+parseStringAs ∷ Textual α ⇒ Proxy α → String → Parsed α+parseStringAs _ = parseString+{-# INLINE parseStringAs #-}++-- | Parse a 'TS.Text' to extract the 'Textual' value.+parseText ∷ Textual α ⇒ TS.Text → Parsed α+parseText = parseString . TS.unpack+{-# INLINE parseText #-}++-- | Provide a hint for the type system when using 'parseText'.+parseTextAs ∷ Textual α ⇒ Proxy α → TS.Text → Parsed α+parseTextAs _ = parseText+{-# INLINE parseTextAs #-}++-- | Parse a lazy 'TL.Text' to extract the 'Textual' value.+parseLazyText ∷ Textual α ⇒ TL.Text → Parsed α+parseLazyText = parseString . TL.unpack+{-# INLINE parseLazyText #-}++-- | Provide a hint for the type system when using 'parseLazyText'.+parseLazyTextAs ∷ Textual α ⇒ Proxy α → TL.Text → Parsed α+parseLazyTextAs _ = parseLazyText+{-# INLINE parseLazyTextAs #-}++-- | Decode and parse an ASCII 'BS.ByteString' to extract the 'Textual' value.+parseAscii ∷ Textual α ⇒ BS.ByteString → Parsed α+parseAscii = parseString . BS8.unpack+{-# INLINE parseAscii #-}++-- | Provide a hint for the type system when using 'parseAscii'.+parseAsciiAs ∷ Textual α ⇒ Proxy α → BS.ByteString → Parsed α+parseAsciiAs _ = parseAscii+{-# INLINE parseAsciiAs #-}++-- | Decode and parse a lazy ASCII 'BL.ByteString' to extract+--   the 'Textual' value.+parseLazyAscii ∷ Textual α ⇒ BL.ByteString → Parsed α+parseLazyAscii = parseString . BL8.unpack+{-# INLINE parseLazyAscii #-}++-- | Provide a hint for the type system when using 'parseLazyAscii'.+parseLazyAsciiAs ∷ Textual α ⇒ BL.ByteString → Parsed α+parseLazyAsciiAs = parseString . BL8.unpack+{-# INLINE parseLazyAsciiAs #-}++-- | Decode and parse a UTF-8 'BS.ByteString' to extract the 'Textual' value.+parseUtf8 ∷ Textual α ⇒ BS.ByteString → Parsed α+parseUtf8 = parseLazyText . decodeUtf8 . BL.fromStrict+{-# INLINE parseUtf8 #-}++-- | Provide a hint for the type system when using 'parseUtf8'.+parseUtf8As ∷ Textual α ⇒ Proxy α → BS.ByteString → Parsed α+parseUtf8As _ = parseUtf8+{-# INLINE parseUtf8As #-}++-- | Decode and parse a lazy UTF-8 'BL.ByteString' to extract+--   the 'Textual' value.+parseLazyUtf8 ∷ Textual α ⇒ BL.ByteString → Parsed α+parseLazyUtf8 = parseLazyText . decodeUtf8+{-# INLINE parseLazyUtf8 #-}++-- | Provide a hint for the type system when using 'parseLazyUtf8'.+parseLazyUtf8As ∷ Textual α ⇒ Proxy α → BL.ByteString → Parsed α+parseLazyUtf8As _ = parseLazyUtf8+{-# INLINE parseLazyUtf8As #-}++-- | A shorthand for @'maybeParsed' . 'parseString'@+fromString ∷ Textual α ⇒ String → Maybe α+fromString = maybeParsed . parseString+{-# INLINE fromString #-}++-- | Provide a hint for the type system when using 'fromString'.+fromStringAs ∷ Textual α ⇒ Proxy α → String → Maybe α+fromStringAs _ = fromString+{-# INLINE fromStringAs #-}++-- | A shorthand for @'maybeParsed' . 'parseText'@+fromText ∷ Textual α ⇒ TS.Text → Maybe α+fromText = maybeParsed . parseText+{-# INLINE fromText #-}++-- | Provide a hint for the type system when using 'fromText'.+fromTextAs ∷ Textual α ⇒ Proxy α → TS.Text → Maybe α+fromTextAs _ = fromText+{-# INLINE fromTextAs #-}++-- | A shorthand for @'maybeParsed' . 'parseLazyText'@+fromLazyText ∷ Textual α ⇒ TL.Text → Maybe α+fromLazyText = maybeParsed . parseLazyText+{-# INLINE fromLazyText #-}++-- | Provide a hint for the type system when using 'fromLazyText'.+fromLazyTextAs ∷ Textual α ⇒ Proxy α → TL.Text → Maybe α+fromLazyTextAs _ = fromLazyText+{-# INLINE fromLazyTextAs #-}++-- | A shorthand for @'maybeParsed' . 'parseAscii'@+fromAscii ∷ Textual α ⇒ BS.ByteString → Maybe α+fromAscii = maybeParsed . parseAscii+{-# INLINE fromAscii #-}++-- | Provide a hint for the type system when using 'fromAscii'.+fromAsciiAs ∷ Textual α ⇒ Proxy α → BS.ByteString → Maybe α+fromAsciiAs _ = fromAscii+{-# INLINE fromAsciiAs #-}++-- | A shorthand for @'maybeParsed' . 'parseLazyAscii'@+fromLazyAscii ∷ Textual α ⇒ BL.ByteString → Maybe α+fromLazyAscii = maybeParsed . parseLazyAscii+{-# INLINE fromLazyAscii #-}++-- | Provide a hint for the type system when using 'fromLazyAscii'.+fromLazyAsciiAs ∷ Textual α ⇒ Proxy α → BL.ByteString → Maybe α+fromLazyAsciiAs _ = fromLazyAscii+{-# INLINE fromLazyAsciiAs #-}++-- | A shorthand for @'maybeParsed' . 'parseUtf8'@+fromUtf8 ∷ Textual α ⇒ BS.ByteString → Maybe α+fromUtf8 = maybeParsed . parseUtf8+{-# INLINE fromUtf8 #-}++-- | Provide a hint for the type system when using 'fromUtf8'.+fromUtf8As ∷ Textual α ⇒ Proxy α → BS.ByteString → Maybe α+fromUtf8As _ = fromUtf8+{-# INLINE fromUtf8As #-}++-- | A shorthand for @'maybeParsed' . 'parseLazyUtf8'@+fromLazyUtf8 ∷ Textual α ⇒ BL.ByteString → Maybe α+fromLazyUtf8 = maybeParsed . parseLazyUtf8+{-# INLINE fromLazyUtf8 #-}++-- | Provide a hint for the type system when using 'fromLazyUtf8'.+fromLazyUtf8As ∷ Textual α ⇒ Proxy α → BL.ByteString → Maybe α+fromLazyUtf8As _ = fromLazyUtf8+{-# INLINE fromLazyUtf8As #-}+

@@ -0,0 +1,1641 @@+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE ScopedTypeVariables #-}++-- | Parsers for numbers written in positional numeral systems.+module Data.Textual.Numerals+  (+  -- * Positional numeral systems+    PositionalSystem(..)+  , BitSystem(..)+  , Binary(..)+  , Octal(..)+  , Decimal(..)+  , Hexadecimal(..)+  , LowHex(..)+  , UpHex(..)+  -- * Single digits+  , digitIn+  , nzDigitIn+  , binDigit+  , nzBinDigit+  , octDigit+  , nzOctDigit+  , decDigit+  , nzDecDigit+  , hexDigit+  , nzHexDigit+  , lowHexDigit+  , nzLowHexDigit+  , upHexDigit+  , nzUpHexDigit+  -- * Numbers+  , nonNegative+  , nnCompact+  , nnUpTo+  , nncUpTo+  , nnBounded+  , nncBounded+  , nnBits+  , nncBits+  , nnBitsUpTo+  , nncBitsUpTo+  , nnbBits+  , nncbBits+  , nonPositive+  , npCompact+  , npUpTo+  , npcUpTo+  , npBounded+  , npcBounded+  , npBits+  , npcBits+  , npBitsUpTo+  , npcBitsUpTo+  , npbBits+  , npcbBits+  , Sign(..)+  , optMinus+  , optSign+  , number'+  , number+  , compact'+  , compact+  , numberUpTo'+  , numberUpTo+  , compactUpTo'+  , compactUpTo+  , bounded'+  , bounded+  , cBounded'+  , cBounded+  , bits'+  , bits+  , cBits'+  , cBits+  , bitsUpTo'+  , bitsUpTo+  , cBitsUpTo'+  , cBitsUpTo+  , bBits'+  , bBits+  , cbBits'+  , cbBits+  ) where++import Data.Typeable (Typeable)+import Data.Int+import Data.Word+import Data.Bits (Bits(..))+import Control.Applicative+import Text.Printer.Numerals (+         PositionalSystem(..), BitSystem(..),+         Binary(..), Octal(..), Decimal(..), Hexadecimal(..),+         LowHex(..), UpHex(..))+import Text.Parser.Combinators (Parsing, (<?>))+import qualified Text.Parser.Combinators as PC+import Text.Parser.Char (CharParsing)+import qualified Text.Parser.Char as PC++-- | Parse a digit of the specified positional numeral system.+digitIn ∷ (PositionalSystem s, Num α, CharParsing μ) ⇒ s → μ α+digitIn s  =  unsafeFromDigitIn s <$> PC.satisfy (isDigitIn s)+          <?> systemName s ++ " digit"+{-# INLINE digitIn #-}++-- | Parse a non-zero digit of the specified positional numeral system.+nzDigitIn ∷ (PositionalSystem s, Num α, CharParsing μ) ⇒ s → μ α+nzDigitIn s  =  unsafeFromDigitIn s <$> PC.satisfy (isNzDigitIn s)+            <?> "non-zero " ++ systemName s ++ " digit"+{-# INLINE nzDigitIn #-}++-- | Parse a binary digit.+binDigit ∷ (Num α, CharParsing μ) ⇒ μ α+binDigit = digitIn Binary+{-# INLINE binDigit #-}++-- | Parse a non-zero binary digit (/'1'/).+nzBinDigit ∷ (Num α, CharParsing μ) ⇒ μ α+nzBinDigit = nzDigitIn Binary+{-# INLINE nzBinDigit #-}++-- | Parse a decimal digit.+decDigit ∷ (Num α, CharParsing μ) ⇒ μ α+decDigit = digitIn Decimal+{-# INLINE decDigit #-}++-- | Parse a non-zero decimal digit.+nzDecDigit ∷ (Num α, CharParsing μ) ⇒ μ α+nzDecDigit = nzDigitIn Decimal+{-# INLINE nzDecDigit #-}++-- | Parse an octal digit.+octDigit ∷ (Num α, CharParsing μ) ⇒ μ α+octDigit = digitIn Octal+{-# INLINE octDigit #-}++-- | Parse a non-zero octal digit.+nzOctDigit ∷ (Num α, CharParsing μ) ⇒ μ α+nzOctDigit = nzDigitIn Octal+{-# INLINE nzOctDigit #-}++-- | Parse a hexadecimal digit.+hexDigit ∷ (Num α, CharParsing μ) ⇒ μ α+hexDigit = digitIn Hexadecimal+{-# INLINE hexDigit #-}++-- | Parse a non-zero hexadecimal digit.+nzHexDigit ∷ (Num α, CharParsing μ) ⇒ μ α+nzHexDigit = nzDigitIn Hexadecimal+{-# INLINE nzHexDigit #-}++-- | Parse a lower case hexadecimal digit.+lowHexDigit ∷ (Num α, CharParsing μ) ⇒ μ α+lowHexDigit = digitIn LowHex+{-# INLINE lowHexDigit #-}++-- | Parse a non-zero lower case hexadecimal digit.+nzLowHexDigit ∷ (Num α, CharParsing μ) ⇒ μ α+nzLowHexDigit = nzDigitIn LowHex+{-# INLINE nzLowHexDigit #-}++-- | Parse an upper case hexadecimal digit.+upHexDigit ∷ (Num α, CharParsing μ) ⇒ μ α+upHexDigit = digitIn UpHex+{-# INLINE upHexDigit #-}++-- | Parse a non-zero upper case hexadecimal digit.+nzUpHexDigit ∷ (Num α, CharParsing μ) ⇒ μ α+nzUpHexDigit = nzDigitIn UpHex+{-# INLINE nzUpHexDigit #-}++-- | Parse a non-negative number written in the specified positional+--   numeral system.+nonNegative ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ) ⇒ s → μ α+nonNegative s = digit >>= go <?> systemName s ++ " digits"+  where go !r = optional digit >>= \case+                  Just d  → go (r * radix + d)+                  Nothing → return r+        radix = radixIn s+        digit = digitIn s+{-# SPECIALIZE nonNegative ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int #-}+{-# SPECIALIZE nonNegative ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int8 #-}+{-# SPECIALIZE nonNegative ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int16 #-}+{-# SPECIALIZE nonNegative ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int32 #-}+{-# SPECIALIZE nonNegative ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int64 #-}+{-# SPECIALIZE nonNegative ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word #-}+{-# SPECIALIZE nonNegative ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word8 #-}+{-# SPECIALIZE nonNegative ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word16 #-}+{-# SPECIALIZE nonNegative ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word32 #-}+{-# SPECIALIZE nonNegative ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word64 #-}+{-# SPECIALIZE nonNegative ∷ (Num α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE nonNegative ∷ (Num α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE nonNegative ∷ (Num α, Monad μ, CharParsing μ) ⇒ Decimal → μ α #-}+{-# SPECIALIZE nonNegative ∷ (Num α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE nonNegative ∷ (Num α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE nonNegative ∷ (Num α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Parse a non-negative number written in the specified positional+--   numeral system. Leading zeroes are not allowed.+nnCompact ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ) ⇒ s → μ α+nnCompact s = (<?> systemName s ++ " digits") $ digitIn s >>= \case+                0 → optional (PC.satisfy $ isDigitIn s) >>= \case+                      Just _  → PC.unexpected "leading zero"+                      Nothing → return 0+                r → go $ fromIntegral (r ∷ Word)+  where go !r = optional digit >>= \case+                  Just d  → go (r * radix + d)+                  Nothing → return r+        radix = radixIn s+        digit = digitIn s+{-# SPECIALIZE nnCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int #-}+{-# SPECIALIZE nnCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int8 #-}+{-# SPECIALIZE nnCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int16 #-}+{-# SPECIALIZE nnCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int32 #-}+{-# SPECIALIZE nnCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int64 #-}+{-# SPECIALIZE nnCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word #-}+{-# SPECIALIZE nnCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word8 #-}+{-# SPECIALIZE nnCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word16 #-}+{-# SPECIALIZE nnCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word32 #-}+{-# SPECIALIZE nnCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word64 #-}+{-# SPECIALIZE nnCompact ∷ (Num α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE nnCompact ∷ (Num α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE nnCompact ∷ (Num α, Monad μ, CharParsing μ) ⇒ Decimal → μ α #-}+{-# SPECIALIZE nnCompact ∷ (Num α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE nnCompact ∷ (Num α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE nnCompact ∷ (Num α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++moreThan ∷ CharParsing μ ⇒ Int → μ α+moreThan n = PC.unexpected+           $ "more than " ++ show n +++             case n of+               1 → " digit"+               _ → " digits"+{-# INLINE moreThan #-}++-- | Parse a non-negative number written in the specified positional+--   numeral system (up to /n/ digits).+nnUpTo ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ) ⇒ s → Int → μ α+nnUpTo _ n | n <= 0 = empty+nnUpTo s n = digit >>= go (n - 1) <?> systemName s ++ " digits"+  where go 0 !r = optional (PC.satisfy $ isDigitIn s) >>= \case+                    Just _  → moreThan n+                    Nothing → return r+        go l !r = optional digit >>= \case+                    Just d  → go (l - 1) (r * radix + d)+                    Nothing → return r+        radix   = radixIn s+        digit   = digitIn s+{-# SPECIALIZE nnUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int #-}+{-# SPECIALIZE nnUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int8 #-}+{-# SPECIALIZE nnUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int16 #-}+{-# SPECIALIZE nnUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int32 #-}+{-# SPECIALIZE nnUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int64 #-}+{-# SPECIALIZE nnUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word #-}+{-# SPECIALIZE nnUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word8 #-}+{-# SPECIALIZE nnUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word16 #-}+{-# SPECIALIZE nnUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word32 #-}+{-# SPECIALIZE nnUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word64 #-}+{-# SPECIALIZE nnUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Binary → Int → μ α #-}+{-# SPECIALIZE nnUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Octal → Int → μ α #-}+{-# SPECIALIZE nnUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Decimal → Int → μ α #-}+{-# SPECIALIZE nnUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ α #-}+{-# SPECIALIZE nnUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ LowHex → Int → μ α #-}+{-# SPECIALIZE nnUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ UpHex → Int → μ α #-}++-- | Parse a non-negative number written in the specified positional+--   numeral system (up to /n/ digits). Leading zeroes are not allowed.+nncUpTo ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ) ⇒ s → Int → μ α+nncUpTo _ n | n <= 0 = empty+nncUpTo s n = (<?> systemName s ++ " digits") $ digitIn s >>= \case+                0 → optional (PC.satisfy $ isDigitIn s) >>= \case+                      Just _  → PC.unexpected "leading zero"+                      Nothing → return 0+                r → go (n - 1) $ fromIntegral (r ∷ Word)+  where go 0 !r = optional (PC.satisfy $ isDigitIn s) >>= \case+                    Just _  → moreThan n+                    Nothing → return r+        go l !r = optional digit >>= \case+                    Just d  → go (l - 1) (r * radix + d)+                    Nothing → return r+        radix   = radixIn s+        digit   = digitIn s+{-# SPECIALIZE nncUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int #-}+{-# SPECIALIZE nncUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int8 #-}+{-# SPECIALIZE nncUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int16 #-}+{-# SPECIALIZE nncUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int32 #-}+{-# SPECIALIZE nncUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int64 #-}+{-# SPECIALIZE nncUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word #-}+{-# SPECIALIZE nncUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word8 #-}+{-# SPECIALIZE nncUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word16 #-}+{-# SPECIALIZE nncUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word32 #-}+{-# SPECIALIZE nncUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word64 #-}+{-# SPECIALIZE nncUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Binary → Int → μ α #-}+{-# SPECIALIZE nncUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Octal → Int → μ α #-}+{-# SPECIALIZE nncUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Decimal → Int → μ α #-}+{-# SPECIALIZE nncUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ α #-}+{-# SPECIALIZE nncUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ LowHex → Int → μ α #-}+{-# SPECIALIZE nncUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ UpHex → Int → μ α #-}++-- | Parse a non-negative number written in the specified positional+--   numeral system, failing on overflow.+nnBounded ∷ (PositionalSystem s, Ord α, Bounded α, Integral α,+             Monad μ, CharParsing μ) ⇒ s → μ α+nnBounded s = digit >>= go <?> systemName s ++ " digits"+  where (q, r) = quotRem maxBound radix+        go !n  = optional digit >>= \case+                   Just n1 → if n < q || (n == q && n1 <= r)+                             then go (n * radix + n1)+                             else fail "out of bounds"+                   Nothing → return n+        radix  = radixIn s+        digit  = digitIn s+{-# SPECIALIZE nnBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int #-}+{-# SPECIALIZE nnBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int8 #-}+{-# SPECIALIZE nnBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int16 #-}+{-# SPECIALIZE nnBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int32 #-}+{-# SPECIALIZE nnBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int64 #-}+{-# SPECIALIZE nnBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word #-}+{-# SPECIALIZE nnBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word8 #-}+{-# SPECIALIZE nnBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word16 #-}+{-# SPECIALIZE nnBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word32 #-}+{-# SPECIALIZE nnBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word64 #-}+{-# SPECIALIZE nnBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE nnBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE nnBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Decimal → μ α #-}+{-# SPECIALIZE nnBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE nnBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE nnBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Parse a non-negative number written in the specified positional+--   numeral system, failing on overflow. Leading zeroes are not allowed.+nncBounded ∷ (PositionalSystem s, Ord α, Bounded α, Integral α,+              Monad μ, CharParsing μ) ⇒ s → μ α+nncBounded s = (<?> systemName s ++ " digits") $ digit >>= \case+                 0 → optional (PC.satisfy $ isDigitIn s) >>= \case+                       Just _  → PC.unexpected "leading zero"+                       Nothing → return 0+                 n → go n+  where (q, r) = quotRem maxBound radix+        go !n  = optional digit >>= \case+                   Just d  → if n < q || (n == q && d <= r)+                             then go (n * radix + d)+                             else fail "out of bounds"+                   Nothing → return n+        radix  = radixIn s+        digit  = digitIn s+{-# SPECIALIZE nncBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int #-}+{-# SPECIALIZE nncBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int8 #-}+{-# SPECIALIZE nncBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int16 #-}+{-# SPECIALIZE nncBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int32 #-}+{-# SPECIALIZE nncBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int64 #-}+{-# SPECIALIZE nncBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word #-}+{-# SPECIALIZE nncBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word8 #-}+{-# SPECIALIZE nncBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word16 #-}+{-# SPECIALIZE nncBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word32 #-}+{-# SPECIALIZE nncBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word64 #-}+{-# SPECIALIZE nncBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE nncBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE nncBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Decimal → μ α #-}+{-# SPECIALIZE nncBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE nncBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE nncBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Parse a non-negative binary number written in the specified+--   positional numeral system.+nnBits ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) ⇒ s → μ α+nnBits s = digit >>= go <?> systemName s ++ " digits"+  where go !r     = optional digit >>= \case+                      Just d  → go ((r `shiftL` digitBits) .|. d)+                      Nothing → return r+        digitBits = digitBitsIn s+        digit     = digitIn s+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int8 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int16 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int32 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int64 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word8 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word16 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word32 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word64 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int8 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int16 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int32 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int64 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word8 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word16 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word32 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word64 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int8 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int16 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int32 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int64 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word8 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word16 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word32 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word64 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int8 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int16 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int32 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int64 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word8 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word16 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word32 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word64 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int8 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int16 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int32 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int64 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word8 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word16 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word32 #-}+{-# SPECIALIZE nnBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word64 #-}+{-# SPECIALIZE nnBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE nnBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE nnBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE nnBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE nnBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Parse a non-negative binary number written in the specified+--   positional numeral system. Leading zeroes are not allowed.+nncBits ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) ⇒ s → μ α+nncBits s = (<?> systemName s ++ " digits") $ digit >>= \case+              0 → optional (PC.satisfy $ isDigitIn s) >>= \case+                    Just _  → PC.unexpected "leading zero"+                    Nothing → return 0 +              r → go r+  where go !r     = optional digit >>= \case+                      Just d  → go ((r `shiftL` digitBits) .|. d)+                      Nothing → return r+        digitBits = digitBitsIn s+        digit     = digitIn s+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int8 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int16 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int32 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int64 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word8 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word16 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word32 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word64 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int8 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int16 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int32 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int64 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word8 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word16 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word32 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word64 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int8 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int16 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int32 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int64 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word8 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word16 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word32 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word64 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int8 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int16 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int32 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int64 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word8 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word16 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word32 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word64 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int8 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int16 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int32 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int64 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word8 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word16 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word32 #-}+{-# SPECIALIZE nncBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word64 #-}+{-# SPECIALIZE nncBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE nncBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE nncBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE nncBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE nncBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Parse a non-negative binary number written in the specified+--   positional numeral system (up to /n/ digits).+nnBitsUpTo ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ)+           ⇒ s → Int → μ α+nnBitsUpTo _ n | n <= 0 = empty+nnBitsUpTo s n = digit >>= go (n - 1) <?> systemName s ++ " digits"+  where go 0 !r   = optional (PC.satisfy $ isDigitIn s) >>= \case+                      Just _  → moreThan n+                      Nothing → return r+        go l !r   = optional digit >>= \case+                      Just d  → go (l - 1) ((r `shiftL` digitBits) .|. d)+                      Nothing → return r+        digitBits = digitBitsIn s+        digit     = digitIn s+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int8 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int16 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int32 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int64 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word8 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word16 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word32 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word64 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int8 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int16 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int32 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int64 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word8 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word16 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word32 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word64 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int8 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int16 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int32 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int64 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word8 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word16 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word32 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word64 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int8 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int16 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int32 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int64 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word8 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word16 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word32 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word64 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int8 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int16 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int32 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int64 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word8 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word16 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word32 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word64 #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Binary → Int → μ α #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Octal → Int → μ α #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ α #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ LowHex → Int → μ α #-}+{-# SPECIALIZE nnBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ UpHex → Int → μ α #-}++-- | Parse a non-negative binary number written in the specified+--   positional numeral system (up to /n/ digits). Leading zeroes are not+--   allowed.+nncBitsUpTo ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ)+            ⇒ s → Int → μ α+nncBitsUpTo _ n | n <= 0 = empty+nncBitsUpTo s n = (<?> systemName s ++ " digits") $ digitIn s >>= \case+                    0 → optional (PC.satisfy $ isDigitIn s) >>= \case+                          Just _  → PC.unexpected "leading zero"+                          Nothing → return 0 +                    r → go (n - 1) $ fromIntegral (r ∷ Word)+  where go 0 !r   = optional (PC.satisfy $ isDigitIn s) >>= \case+                      Just _  → moreThan n+                      Nothing → return r+        go l !r   = optional digit >>= \case+                      Just d  → go (l - 1) ((r `shiftL` digitBits) .|. d)+                      Nothing → return r+        digitBits = digitBitsIn s+        digit     = digitIn s+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int8 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int16 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int32 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int64 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word8 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word16 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word32 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word64 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int8 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int16 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int32 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int64 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word8 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word16 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word32 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word64 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int8 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int16 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int32 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int64 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word8 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word16 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word32 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word64 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int8 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int16 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int32 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int64 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word8 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word16 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word32 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word64 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int8 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int16 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int32 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int64 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word8 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word16 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word32 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word64 #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Binary → Int → μ α #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Octal → Int → μ α #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ α #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ LowHex → Int → μ α #-}+{-# SPECIALIZE nncBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ UpHex → Int → μ α #-}++-- | Parse a non-negative binary number written in the specified+--   positional numeral system, failing on overflow.+nnbBits ∷ (BitSystem s, Ord α, Bounded α, Num α, Bits α,+           Monad μ, CharParsing μ)+        ⇒ s → μ α+nnbBits s = digit >>= go <?> systemName s ++ " digits"+  where q = maxBound `shiftR` digitBits+        r = maxBound .&. digitMaskIn s+        go !n = optional digit >>= \case+                  Just d  → if n < q || (n == q && d <= r)+                            then go ((n `shiftL` digitBits) .|. d)+                            else fail "out of bounds"+                  Nothing → return n+        digitBits = digitBitsIn s+        digit     = digitIn s+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int8 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int16 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int32 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int64 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word8 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word16 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word32 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word64 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int8 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int16 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int32 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int64 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word8 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word16 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word32 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word64 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int8 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int16 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int32 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int64 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word8 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word16 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word32 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word64 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int8 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int16 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int32 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int64 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word8 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word16 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word32 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word64 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int8 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int16 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int32 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int64 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word8 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word16 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word32 #-}+{-# SPECIALIZE nnbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word64 #-}+{-# SPECIALIZE nnbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE nnbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE nnbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE nnbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE nnbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Parse a non-negative binary number written in the specified+--   positional numeral system, failing on overflow. Leading zeroes are not+--   allowed.+nncbBits ∷ (BitSystem s, Ord α, Bounded α, Num α, Bits α,+            Monad μ, CharParsing μ)+         ⇒ s → μ α+nncbBits s = (<?> systemName s ++ " digits") $ digitIn s >>= \case+               0 → optional (PC.satisfy $ isDigitIn s) >>= \case+                     Just _  → PC.unexpected "leading zero"+                     Nothing → return 0+               n → go $ fromIntegral (n ∷ Word)+  where q = maxBound `shiftR` digitBits+        r = maxBound .&. digitMaskIn s+        go !n = optional digit >>= \case+                  Just d  → if n < q || (n == q && d <= r)+                            then go ((n `shiftL` digitBits) .|. d)+                            else fail "out of bounds"+                  Nothing → return n+        digitBits = digitBitsIn s+        digit     = digitIn s+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int8 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int16 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int32 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int64 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word8 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word16 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word32 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word64 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int8 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int16 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int32 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int64 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word8 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word16 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word32 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word64 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int8 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int16 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int32 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int64 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word8 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word16 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word32 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word64 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int8 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int16 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int32 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int64 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word8 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word16 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word32 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word64 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int8 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int16 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int32 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int64 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word8 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word16 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word32 #-}+{-# SPECIALIZE nncbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word64 #-}+{-# SPECIALIZE nncbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE nncbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE nncbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE nncbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE nncbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Parse a non-positive number written in the specified positional+--   numeral system. For example, parsing \"123\" as a decimal would produce+--   /-123/, not /123/.+nonPositive ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ) ⇒ s → μ α+nonPositive s = (<?> systemName s ++ " digits") $ do+                  r ← digitIn s+                  go $ fromIntegral $ negate (r ∷ Int)+  where go !r = optional digit >>= \case+                  Just d  → go (r * radix - d)+                  Nothing → return r+        radix = radixIn s+        digit = digitIn s+{-# SPECIALIZE nonPositive ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int #-}+{-# SPECIALIZE nonPositive ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int8 #-}+{-# SPECIALIZE nonPositive ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int16 #-}+{-# SPECIALIZE nonPositive ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int32 #-}+{-# SPECIALIZE nonPositive ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int64 #-}+{-# SPECIALIZE nonPositive ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word #-}+{-# SPECIALIZE nonPositive ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word8 #-}+{-# SPECIALIZE nonPositive ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word16 #-}+{-# SPECIALIZE nonPositive ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word32 #-}+{-# SPECIALIZE nonPositive ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word64 #-}+{-# SPECIALIZE nonPositive ∷ (Num α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE nonPositive ∷ (Num α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE nonPositive ∷ (Num α, Monad μ, CharParsing μ) ⇒ Decimal → μ α #-}+{-# SPECIALIZE nonPositive ∷ (Num α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE nonPositive ∷ (Num α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE nonPositive ∷ (Num α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Parse a non-positive number written in the specified positional+--   numeral system. Leading zeroes are not allowed.+npCompact ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ) ⇒ s → μ α+npCompact s = (<?> systemName s ++ " digits") $ digitIn s >>= \case+                0 → optional (PC.satisfy $ isDigitIn s) >>= \case+                      Just _  → PC.unexpected "leading zero"+                      Nothing → return 0+                r → go $ fromIntegral $ negate (r ∷ Int)+  where go !r = optional digit >>= \case+                  Just d  → go (r * radix - d)+                  Nothing → return r+        radix = radixIn s+        digit = digitIn s+{-# SPECIALIZE npCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int #-}+{-# SPECIALIZE npCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int8 #-}+{-# SPECIALIZE npCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int16 #-}+{-# SPECIALIZE npCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int32 #-}+{-# SPECIALIZE npCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int64 #-}+{-# SPECIALIZE npCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word #-}+{-# SPECIALIZE npCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word8 #-}+{-# SPECIALIZE npCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word16 #-}+{-# SPECIALIZE npCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word32 #-}+{-# SPECIALIZE npCompact ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word64 #-}+{-# SPECIALIZE npCompact ∷ (Num α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE npCompact ∷ (Num α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE npCompact ∷ (Num α, Monad μ, CharParsing μ) ⇒ Decimal → μ α #-}+{-# SPECIALIZE npCompact ∷ (Num α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE npCompact ∷ (Num α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE npCompact ∷ (Num α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Parse a non-positive number written in the specified positional+--   numeral system (up to /n/ digits).+npUpTo ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ) ⇒ s → Int → μ α+npUpTo _ n | n <= 0 = empty+npUpTo s n = (<?> systemName s ++ " digits") $ do+               r ← digitIn s+               go (n - 1) $ fromIntegral $ negate (r ∷ Int)+  where go 0 !r = optional (PC.satisfy $ isDigitIn s) >>= \case+                    Just _  → moreThan n+                    Nothing → return r+        go l !r = optional digit >>= \case+                    Just d  → go (l - 1) (r * radix - d)+                    Nothing → return r+        radix   = radixIn s+        digit   = digitIn s+{-# SPECIALIZE npUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int #-}+{-# SPECIALIZE npUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int8 #-}+{-# SPECIALIZE npUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int16 #-}+{-# SPECIALIZE npUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int32 #-}+{-# SPECIALIZE npUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int64 #-}+{-# SPECIALIZE npUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word #-}+{-# SPECIALIZE npUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word8 #-}+{-# SPECIALIZE npUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word16 #-}+{-# SPECIALIZE npUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word32 #-}+{-# SPECIALIZE npUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word64 #-}+{-# SPECIALIZE npUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Binary → Int → μ α #-}+{-# SPECIALIZE npUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Octal → Int → μ α #-}+{-# SPECIALIZE npUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Decimal → Int → μ α #-}+{-# SPECIALIZE npUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ α #-}+{-# SPECIALIZE npUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ LowHex → Int → μ α #-}+{-# SPECIALIZE npUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ UpHex → Int → μ α #-}++-- | Parse a non-positive number written in the specified positional+--   numeral system (up to /n/ digits). Leading zeroes are not allowed.+npcUpTo ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ) ⇒ s → Int → μ α+npcUpTo _ n | n <= 0 = empty+npcUpTo s n = (<?> systemName s ++ " digits") $ digitIn s >>= \case+                0 → optional (PC.satisfy $ isDigitIn s) >>= \case+                      Just _  → PC.unexpected "leading zero"+                      Nothing → return 0+                r → go (n - 1) $ fromIntegral $ negate (r ∷ Int)+  where go 0 !r = optional (PC.satisfy $ isDigitIn s) >>= \case+                    Just _  → moreThan n+                    Nothing → return r+        go l !r = optional digit >>= \case+                    Just d  → go (l - 1) (r * radix - d)+                    Nothing → return r+        radix   = radixIn s+        digit   = digitIn s+{-# SPECIALIZE npcUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int #-}+{-# SPECIALIZE npcUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int8 #-}+{-# SPECIALIZE npcUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int16 #-}+{-# SPECIALIZE npcUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int32 #-}+{-# SPECIALIZE npcUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Int64 #-}+{-# SPECIALIZE npcUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word #-}+{-# SPECIALIZE npcUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word8 #-}+{-# SPECIALIZE npcUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word16 #-}+{-# SPECIALIZE npcUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word32 #-}+{-# SPECIALIZE npcUpTo ∷ (Monad μ, CharParsing μ) ⇒ Decimal → Int → μ Word64 #-}+{-# SPECIALIZE npcUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Binary → Int → μ α #-}+{-# SPECIALIZE npcUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Octal → Int → μ α #-}+{-# SPECIALIZE npcUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Decimal → Int → μ α #-}+{-# SPECIALIZE npcUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ α #-}+{-# SPECIALIZE npcUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ LowHex → Int → μ α #-}+{-# SPECIALIZE npcUpTo ∷ (Num α, Monad μ, CharParsing μ) ⇒ UpHex → Int → μ α #-}++-- | Parse a non-positive number written in the specified positional+--   numeral system, failing on overflow.+npBounded ∷ (PositionalSystem s, Ord α, Bounded α, Integral α,+             Monad μ, CharParsing μ)+          ⇒ s → μ α+npBounded s = (<?> systemName s ++ " digits") $ do+                n ← digitIn s+                go $ fromIntegral $ negate (n ∷ Int)+  where (q, r1) = quotRem minBound radix+        !r      = negate r1+        go !n   = optional digit >>= \case+                    Just d  → if n > q || (n == q && d <= r)+                              then go (n * radix - d)+                              else fail "out of bounds"+                    Nothing → return n+        radix   = radixIn s+        digit   = digitIn s+{-# SPECIALIZE npBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int #-}+{-# SPECIALIZE npBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int8 #-}+{-# SPECIALIZE npBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int16 #-}+{-# SPECIALIZE npBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int32 #-}+{-# SPECIALIZE npBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int64 #-}+{-# SPECIALIZE npBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word #-}+{-# SPECIALIZE npBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word8 #-}+{-# SPECIALIZE npBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word16 #-}+{-# SPECIALIZE npBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word32 #-}+{-# SPECIALIZE npBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word64 #-}+{-# SPECIALIZE npBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE npBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE npBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Decimal → μ α #-}+{-# SPECIALIZE npBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE npBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE npBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Parse a non-positive number written in the specified positional+--   numeral system, failing on overflow. Leading zeroes are not allowed.+npcBounded ∷ (PositionalSystem s, Ord α, Bounded α, Integral α,+              Monad μ, CharParsing μ)+           ⇒ s → μ α+npcBounded s = (<?> systemName s ++ " digits") $ digitIn s >>= \case+                 0 → optional (PC.satisfy $ isDigitIn s) >>= \case+                       Just _  → PC.unexpected "leading zero"+                       Nothing → return 0+                 n → go $ fromIntegral $ negate (n ∷ Int)+  where (q, r1) = quotRem minBound radix+        !r      = negate r1+        go !n   = optional digit >>= \case+                    Just d  → if n > q || (n == q && d <= r)+                              then go (n * radix - d)+                              else fail "out of bounds"+                    Nothing → return n+        radix   = radixIn s+        digit   = digitIn s+{-# SPECIALIZE npcBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int #-}+{-# SPECIALIZE npcBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int8 #-}+{-# SPECIALIZE npcBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int16 #-}+{-# SPECIALIZE npcBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int32 #-}+{-# SPECIALIZE npcBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Int64 #-}+{-# SPECIALIZE npcBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word #-}+{-# SPECIALIZE npcBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word8 #-}+{-# SPECIALIZE npcBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word16 #-}+{-# SPECIALIZE npcBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word32 #-}+{-# SPECIALIZE npcBounded ∷ (Monad μ, CharParsing μ) ⇒ Decimal → μ Word64 #-}+{-# SPECIALIZE npcBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE npcBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE npcBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Decimal → μ α #-}+{-# SPECIALIZE npcBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE npcBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE npcBounded ∷ (Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Parse a non-positive two\'s complement binary number written in+--   the specified positional numeral system.+npBits ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) ⇒ s → μ α+npBits s = (<?> systemName s ++ " digits") $ do+             r ← digit+             go $ fromIntegral $ negate (r ∷ Int)+  where go !r     = optional digit >>= \case+                      Just d1 → go ((r `shiftL` digitBits) + d)+                        where !d = fromIntegral $ negate d1+                      Nothing → return r+        digitBits = digitBitsIn s+        digit     = digitIn s+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int8 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int16 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int32 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int64 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word8 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word16 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word32 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word64 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int8 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int16 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int32 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int64 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word8 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word16 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word32 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word64 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int8 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int16 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int32 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int64 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word8 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word16 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word32 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word64 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int8 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int16 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int32 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int64 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word8 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word16 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word32 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word64 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int8 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int16 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int32 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int64 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word8 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word16 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word32 #-}+{-# SPECIALIZE npBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word64 #-}+{-# SPECIALIZE npBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE npBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE npBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE npBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE npBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Parse a non-positive two\'s complement binary number written in+--   the specified positional numeral system (up to /n/ digits).+npBitsUpTo ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ)+           ⇒ s → Int → μ α+npBitsUpTo _ n | n <= 0 = empty+npBitsUpTo s n = (<?> systemName s ++ " digits") $ do+                   r ← digit+                   go (n - 1) $ fromIntegral $ negate (r ∷ Int)+  where go 0 !r   = optional (PC.satisfy $ isDigitIn s) >>= \case+                      Just _  → moreThan n+                      Nothing → return r+        go l !r   = optional digit >>= \case+                      Just d1 → go (l - 1) ((r `shiftL` digitBits) + d)+                        where !d = fromIntegral $ negate d1+                      Nothing → return r+        digitBits = digitBitsIn s+        digit     = digitIn s+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int8 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int16 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int32 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int64 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word8 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word16 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word32 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word64 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int8 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int16 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int32 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int64 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word8 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word16 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word32 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word64 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int8 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int16 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int32 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int64 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word8 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word16 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word32 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word64 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int8 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int16 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int32 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int64 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word8 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word16 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word32 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word64 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int8 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int16 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int32 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int64 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word8 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word16 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word32 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word64 #-}+{-# SPECIALIZE npBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Binary → Int → μ α #-}+{-# SPECIALIZE npBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Octal → Int → μ α #-}+{-# SPECIALIZE npBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ α #-}+{-# SPECIALIZE npBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ LowHex → Int → μ α #-}+{-# SPECIALIZE npBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ UpHex → Int → μ α #-}++-- | Parse a non-positive two\'s complement binary number written in+--   the specified positional numeral system. Leading zeroes are not allowed.+npcBits ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) ⇒ s → μ α+npcBits s = (<?> systemName s ++ " digits") $ digit >>= \case+              0 → optional (PC.satisfy $ isDigitIn s) >>= \case+                    Just _  → PC.unexpected "leading zero"+                    Nothing → return 0+              r → go $ fromIntegral $ negate (r ∷ Int)+  where go !r     = optional digit >>= \case+                      Just d1 → go ((r `shiftL` digitBits) + d)+                        where !d = fromIntegral $ negate d1+                      Nothing → return r+        digitBits = digitBitsIn s+        digit     = digitIn s+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int8 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int16 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int32 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int64 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word8 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word16 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word32 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word64 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int8 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int16 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int32 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int64 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word8 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word16 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word32 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word64 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int8 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int16 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int32 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int64 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word8 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word16 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word32 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word64 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int8 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int16 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int32 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int64 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word8 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word16 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word32 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word64 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int8 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int16 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int32 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int64 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word8 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word16 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word32 #-}+{-# SPECIALIZE npcBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word64 #-}+{-# SPECIALIZE npcBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE npcBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE npcBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE npcBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE npcBits ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Parse a non-positive two\'s complement binary number written in+--   the specified positional numeral system (up to /n/ digits).+--   Leading zeroes are not allowed.+npcBitsUpTo ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ)+            ⇒ s → Int → μ α+npcBitsUpTo _ n | n <= 0 = empty+npcBitsUpTo s n = (<?> systemName s ++ " digits") $ digit >>= \case+                    0 → optional (PC.satisfy $ isDigitIn s) >>= \case+                          Just _  → PC.unexpected "leading zero"+                          Nothing → return 0+                    r → go (n - 1) $ fromIntegral $ negate (r ∷ Int)+  where go 0 !r   = optional (PC.satisfy $ isDigitIn s) >>= \case+                      Just _  → moreThan n+                      Nothing → return r+        go l !r   = optional digit >>= \case+                      Just d1 → go (l - 1) ((r `shiftL` digitBits) + d)+                        where !d = fromIntegral $ negate d1+                      Nothing → return r+        digitBits = digitBitsIn s+        digit     = digitIn s+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int8 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int16 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int32 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Int64 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word8 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word16 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word32 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Binary → Int → μ Word64 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int8 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int16 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int32 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Int64 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word8 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word16 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word32 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Octal → Int → μ Word64 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int8 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int16 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int32 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Int64 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word8 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word16 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word32 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ Word64 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int8 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int16 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int32 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Int64 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word8 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word16 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word32 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ LowHex → Int → μ Word64 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int8 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int16 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int32 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Int64 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word8 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word16 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word32 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Monad μ, CharParsing μ) ⇒ UpHex → Int → μ Word64 #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Binary → Int → μ α #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Octal → Int → μ α #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ Hexadecimal → Int → μ α #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ LowHex → Int → μ α #-}+{-# SPECIALIZE npcBitsUpTo ∷ (Num α, Bits α, Monad μ, CharParsing μ) ⇒ UpHex → Int → μ α #-}++-- | Parse a non-positive two\'s complement binary number written in+--   the specified positional numeral system, failing on overflow.+npbBits ∷ ∀ s μ α+        . (BitSystem s, Ord α, Bounded α, Num α, Bits α,+           Monad μ, CharParsing μ)+        ⇒ s → μ α+npbBits s = (<?> systemName s ++ " digits") $ do+              n ← digit+              go $ fromIntegral $ negate (n ∷ Int)+  where q1 = minBound `shiftR` digitBits+        r  = negate (lastDigitIn s (minBound ∷ α)) .&. digitMaskIn s+        q  = if r == 0 then q1 else q1 + 1+        go !n     = optional digit >>= \case+                      Just d1 → if n > q || (n == q && d1 <= r)+                                then go ((n `shiftL` digitBits) + d)+                                else fail "out of bounds"+                        where !d = fromIntegral $ negate d1+                      Nothing → return n+        digitBits = digitBitsIn s+        digit     = digitIn s+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int8 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int16 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int32 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int64 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word8 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word16 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word32 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word64 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int8 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int16 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int32 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int64 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word8 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word16 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word32 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word64 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int8 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int16 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int32 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int64 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word8 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word16 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word32 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word64 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int8 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int16 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int32 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int64 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word8 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word16 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word32 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word64 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int8 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int16 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int32 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int64 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word8 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word16 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word32 #-}+{-# SPECIALIZE npbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word64 #-}+{-# SPECIALIZE npbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE npbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE npbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE npbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE npbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Parse a non-positive two\'s complement binary number written in+--   the specified positional numeral system, failing on overflow.+--   Leading zeroes are not allowed.+npcbBits ∷ ∀ s μ α+         . (BitSystem s, Ord α, Bounded α, Num α, Bits α,+            Monad μ, CharParsing μ)+        ⇒ s → μ α+npcbBits s = (<?> systemName s ++ " digits") $ digit >>= \case+               0 → optional (PC.satisfy $ isDigitIn s) >>= \case+                     Just _  → PC.unexpected "leading zero"+                     Nothing → return 0+               n → go $ fromIntegral $ negate (n ∷ Int)+  where q1 = minBound `shiftR` digitBits+        r  = negate (lastDigitIn s (minBound ∷ α)) .&. digitMaskIn s+        q  = if r == 0 then q1 else q1 + 1+        go !n     = optional digit >>= \case+                      Just d1 → if n > q || (n == q && d1 <= r)+                                then go ((n `shiftL` digitBits) + d)+                                else fail "out of bounds"+                        where !d = fromIntegral $ negate d1+                      Nothing → return n+        digitBits = digitBitsIn s+        digit     = digitIn s+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int8 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int16 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int32 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Int64 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word8 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word16 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word32 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Binary → μ Word64 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int8 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int16 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int32 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Int64 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word8 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word16 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word32 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Octal → μ Word64 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int8 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int16 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int32 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Int64 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word8 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word16 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word32 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ Hexadecimal → μ Word64 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int8 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int16 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int32 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Int64 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word8 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word16 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word32 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ LowHex → μ Word64 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int8 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int16 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int32 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Int64 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word8 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word16 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word32 #-}+{-# SPECIALIZE npcbBits ∷ (Monad μ, CharParsing μ) ⇒ UpHex → μ Word64 #-}+{-# SPECIALIZE npcbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ Binary → μ α #-}+{-# SPECIALIZE npcbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ Octal → μ α #-}+{-# SPECIALIZE npcbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ Hexadecimal → μ α #-}+{-# SPECIALIZE npcbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ LowHex → μ α #-}+{-# SPECIALIZE npcbBits ∷ (Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) ⇒ UpHex → μ α #-}++-- | Sign of a number.+data Sign = NonNegative | NonPositive+            deriving (Typeable, Eq, Show, Read)++-- | Optional minus sign.+optMinus ∷ CharParsing μ ⇒ μ Sign+optMinus  =  (pure NonPositive <* PC.char '-') <|> pure NonNegative+         <?> "optional minus sign"+{-# INLINE optMinus #-}++-- | Optional minus or plus sign.+optSign ∷ CharParsing μ ⇒ μ Sign+optSign  =  (pure NonPositive <* PC.char '-')+        <|> (pure NonNegative <* PC.char '+')+        <|> pure NonNegative+        <?> "optional sign"+{-# INLINABLE optSign #-}++-- | Parse a number written in the specified positional numeral system.+--   The supplied parser is used to determine the sign of the number.+number' ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ)+        ⇒ μ Sign → s → μ α+number' neg s = (<?> systemName s) $ neg >>= \case+  NonNegative → nonNegative s+  NonPositive → nonPositive s+{-# INLINE number' #-}++-- | A shorthand for 'number\'' 'optMinus'.+number ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ) ⇒ s → μ α+number = number' optMinus+{-# INLINE number #-}++-- | Parse a number written in the specified positional numeral system.+--   The supplied parser is used to determine the sign of the number.+--   Leading zeroes are not allowed.+compact' ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ)+         ⇒ μ Sign → s → μ α+compact' neg s = (<?> systemName s) $ neg >>= \case+  NonNegative → nnCompact s+  NonPositive → npCompact s+{-# INLINE compact' #-}++-- | A shorthand for 'compact\'' 'optMinus'.+compact ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ) ⇒ s → μ α+compact = compact' optMinus+{-# INLINE compact #-}++-- | Parse a number written in the specified positional numeral system+--   (up to /n/ digits). The supplied parser is used to determine the sign of+--   the number.+numberUpTo' ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ)+            ⇒ μ Sign → s → Int → μ α+numberUpTo' neg s n = (<?> systemName s) $ neg >>= \case+  NonNegative → nnUpTo s n+  NonPositive → npUpTo s n+{-# INLINE numberUpTo' #-}++-- | A shorthand for 'numberUpTo\'' 'optMinus'.+numberUpTo ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ)+           ⇒ s → Int → μ α+numberUpTo = numberUpTo' optMinus+{-# INLINE numberUpTo #-}++-- | Parse a number written in the specified positional numeral system+--   (up to /n/ digits). The supplied parser is used to determine the sign of+--   the number. Leading zeroes are not allowed.+compactUpTo' ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ)+             ⇒ μ Sign → s → Int → μ α+compactUpTo' neg s n = (<?> systemName s) $ neg >>= \case+  NonNegative → nncUpTo s n+  NonPositive → npcUpTo s n+{-# INLINE compactUpTo' #-}++-- | A shorthand for 'compactUpTo\'' 'optMinus'.+compactUpTo ∷ (PositionalSystem s, Num α, Monad μ, CharParsing μ)+           ⇒ s → Int → μ α+compactUpTo = compactUpTo' optMinus+{-# INLINE compactUpTo #-}++-- | Parse a number written in the specified positional numeral system,+--   failing on overflow. The supplied parser is used to determine the sign+--   of the number.+bounded' ∷ (PositionalSystem s, Ord α, Bounded α, Integral α,+            Monad μ, CharParsing μ)+         ⇒ μ Sign → s → μ α+bounded' neg s = (<?> systemName s) $ neg >>= \case+  NonNegative → nnBounded s+  NonPositive → npBounded s+{-# INLINE bounded' #-}++-- | A shorthand for 'bounded\'' 'optMinus'.+bounded ∷ (PositionalSystem s, Ord α, Bounded α, Integral α,+           Monad μ, CharParsing μ) ⇒ s → μ α+bounded = bounded' optMinus+{-# INLINE bounded #-}++-- | Parse a number written in the specified positional numeral system,+--   failing on overflow. The supplied parser is used to determine the sign+--   of the number. Leading zeroes are not allowed.+cBounded' ∷ (PositionalSystem s, Ord α, Bounded α, Integral α,+             Monad μ, CharParsing μ)+          ⇒ μ Sign → s → μ α+cBounded' neg s = (<?> systemName s) $ neg >>= \case+  NonNegative → nncBounded s+  NonPositive → npcBounded s+{-# INLINE cBounded' #-}++-- | A shorthand for 'cBounded\'' 'optMinus'.+cBounded ∷ (PositionalSystem s, Ord α, Bounded α, Integral α,+            Monad μ, CharParsing μ) ⇒ s → μ α+cBounded = cBounded' optMinus+{-# INLINE cBounded #-}++-- | Parse a (two\'s complement) binary number written in the specified+--   positional numeral system. The supplied parser is used to determine+--   the sign of the number.+bits' ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ)+      ⇒ μ Sign → s → μ α+bits' neg s = (<?> systemName s) $ neg >>= \case+  NonNegative → nnBits s+  NonPositive → npBits s+{-# INLINE bits' #-}++-- | A shorthand for 'bits\'' 'optMinus'.+bits ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) ⇒ s → μ α+bits = bits' optMinus+{-# INLINE bits #-}++-- | Parse a (two\'s complement) binary number written in the specified+--   positional numeral system. The supplied parser is used to determine+--   the sign of the number. Leading zeroes are not allowed.+cBits' ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ)+       ⇒ μ Sign → s → μ α+cBits' neg s = (<?> systemName s) $ neg >>= \case+  NonNegative → nncBits s+  NonPositive → npcBits s+{-# INLINE cBits' #-}++-- | A shorthand for 'cBits\'' 'optMinus'.+cBits ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) ⇒ s → μ α+cBits = cBits' optMinus+{-# INLINE cBits #-}++-- | Parse a (two\'s complement) binary number written in the specified+--   positional numeral system (up to /n/ digits). The supplied parser is+--   used to determine the sign of the number.+bitsUpTo' ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ)+          ⇒ μ Sign → s → Int → μ α+bitsUpTo' neg s n = (<?> systemName s) $ neg >>= \case+  NonNegative → nnBitsUpTo s n+  NonPositive → npBitsUpTo s n+{-# INLINE bitsUpTo' #-}++-- | A shorthand for 'bitsUpTo\'' 'optMinus'.+bitsUpTo ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ)+         ⇒ s → Int → μ α+bitsUpTo = bitsUpTo' optMinus+{-# INLINE bitsUpTo #-}++-- | Parse a (two\'s complement) binary number written in the specified+--   positional numeral system (up to /n/ digits). The supplied parser is+--   used to determine the sign of the number. Leading zeroes are not+--   allowed.+cBitsUpTo' ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ)+           ⇒ μ Sign → s → Int → μ α+cBitsUpTo' neg s n = (<?> systemName s) $ neg >>= \case+  NonNegative → nncBitsUpTo s n+  NonPositive → npcBitsUpTo s n+{-# INLINE cBitsUpTo' #-}++-- | A shorthand for 'cBitsUpTo\'' 'optMinus'.+cBitsUpTo ∷ (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ)+          ⇒ s → Int → μ α+cBitsUpTo = cBitsUpTo' optMinus+{-# INLINE cBitsUpTo #-}++-- | Parse a (two\'s complement) binary number written in the specified+--   positional numeral system, failing on overflow. The supplied parser is+--   used to determine the sign of the number.+bBits' ∷ (BitSystem s, Ord α, Bounded α, Num α, Bits α,+          Monad μ, CharParsing μ)+       ⇒ μ Sign → s → μ α+bBits' neg s = (<?> systemName s) $ neg >>= \case+  NonNegative → nnbBits s+  NonPositive → npbBits s+{-# INLINE bBits' #-}++-- | A shorthand for 'bBits\'' 'optMinus'.+bBits ∷ (BitSystem s, Ord α, Bounded α, Num α, Bits α,+         Monad μ, CharParsing μ)+      ⇒ s → μ α+bBits = bBits' optMinus+{-# INLINE bBits #-}++-- | Parse a (two\'s complement) binary number written in the specified+--   positional numeral system, failing on overflow. The supplied parser is+--   used to determine the sign of the number. Leading zeroes are not+--   allowed.+cbBits' ∷ (BitSystem s, Ord α, Bounded α, Num α, Bits α,+           Monad μ, CharParsing μ)+        ⇒ μ Sign → s → μ α+cbBits' neg s = (<?> systemName s) $ neg >>= \case+  NonNegative → nncbBits s+  NonPositive → npcbBits s+{-# INLINE cbBits' #-}++-- | A shorthand for 'cbBits\'' 'optMinus'.+cbBits ∷ (BitSystem s, Ord α, Bounded α, Num α, Bits α,+          Monad μ, CharParsing μ)+       ⇒ s → μ α+cbBits = cbBits' optMinus+{-# INLINE cbBits #-}+

@@ -0,0 +1,288 @@+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE Rank2Types #-}+{-# OPTIONS_GHC -fno-warn-missing-signatures #-}++import Test.Framework (defaultMain)+import Test.Framework.Providers.QuickCheck2 (testProperty)+import Test.QuickCheck ((==>))++import Data.Word (Word)+import Data.Proxy (Proxy)+import Data.Textual+import Data.Textual.Numerals+import Control.Applicative+import Text.Printer (StringBuilder)+import qualified Text.Printer as TP+import qualified Text.Printer.Numerals as TP+import Text.Parser.Combinators as PC+import Text.Parser.Char (CharParsing)++main = defaultMain+  [ testProperty "nonNegative Binary Int" $ \i →+      (i >= 0) ==>+        parse (nonNegative Binary) (TP.binary i) == Parsed (i ∷ Int)+  , testProperty "nonNegative Binary Word" $ \w →+      parse (nonNegative Binary) (TP.binary w) == Parsed (w ∷ Word)+  , testProperty "nonNegative Decimal Int" $ \i →+      (i >= 0) ==>+        parse (nonNegative Decimal) (TP.decimal i) == Parsed (i ∷ Int)+  , testProperty "nonNegative Decimal Word" $ \w →+      parse (nonNegative Decimal) (TP.decimal w) == Parsed (w ∷ Word)+  , testProperty "nonNegative Hexadecimal Int" $ \i →+      (i >= 0) ==>+        parse (nonNegative Hexadecimal) (TP.upHex i) == Parsed (i ∷ Int)+  , testProperty "nonNegative Hexadecimal Word" $ \w →+      parse (nonNegative Hexadecimal) (TP.lowHex w) == Parsed (w ∷ Word)+  , testProperty "nnCompact Decimal" $ \w →+      parse (nnCompact Decimal) (TP.nnDecimal w) == Parsed (w ∷ Word)+  , testProperty "nnCompact Decimal fails on \"00\"" $+      isMalformed $ parseAs aWord (nnCompact Decimal) "00"+  , testProperty "nnCompact Decimal fails on \"01\"" $+      isMalformed $ parseAs aWord (nnCompact Decimal) "01"+  , testProperty "nnUpTo Decimal 3" $ \w →+      case parse (nnUpTo Decimal 3) (TP.nnDecimal w) of+        Malformed _ _ | w >= 1000        → True+        Parsed w'     | w' == (w ∷ Word) → True +        _                                → False+  , testProperty "nncUpTo Decimal 3" $ \w →+      case parse (nncUpTo Decimal 3) (TP.nnDecimal w) of+        Malformed _ _ | w >= 1000        → True+        Parsed w'     | w' == (w ∷ Word) → True +        _                                → False+  , testProperty "nncUpTo Decimal fails on \"00\"" $+      isMalformed $ parseAs aWord (nncUpTo Decimal 3) "00"+  , testProperty "nncUpTo Decimal fails on \"01\"" $+      isMalformed $ parseAs aWord (nncUpTo Decimal 3) "01"+  , testProperty "nnBounded Hexadecimal Word" $ \w →+      parse (nnBounded Hexadecimal) (TP.nnUpHex w) == Parsed (w ∷ Word)+  , testProperty "nnBounded Hexadecimal Int" $ \i →+      (i >= 0) ==>+        parse (nnBounded Hexadecimal) (TP.nnUpHex i) == Parsed (i ∷ Int)+  , testProperty "nnBounded Hexadecimal Word fails on overflow" $+      isMalformed $ parseAs aWord (nnBounded Hexadecimal)+                            (TP.nnUpHex $ toInteger (maxBound ∷ Word) + 1)+  , testProperty "nnBounded Hexadecimal Int fails on overflow" $+      isMalformed $ parseAs anInt (nnBounded Hexadecimal)+                            (TP.nnUpHex $ toInteger (maxBound ∷ Int) + 1)+  , testProperty "nncBounded Decimal fails on \"00\"" $+      isMalformed $ parseAs aWord (nncBounded Decimal) "00"+  , testProperty "nncBounded Decimal fails on \"01\"" $+      isMalformed $ parseAs aWord (nncBounded Decimal) "01"+  , testProperty "nnBits Binary Int" $ \i →+      (i >= 0) ==>+        parse (nnBits Binary) (TP.binaryBits i) == Parsed (i ∷ Int)+  , testProperty "nnBits Binary Word" $ \w →+      parse (nnBits Binary) (TP.nnBinaryBits w) == Parsed (w ∷ Word)+  , testProperty "nnBits Hexadecimal Int" $ \i →+      (i >= 0) ==>+        parse (nnBits Hexadecimal) (TP.upHex i) == Parsed (i ∷ Int)+  , testProperty "nnBits Hexadecimal Word" $ \w →+      parse (nnBits Hexadecimal) (TP.nnLowHex w) == Parsed (w ∷ Word)+  , testProperty "nncBits Octal" $ \w →+      parse (nncBits Octal) (TP.nnOctal w) == Parsed (w ∷ Word)+  , testProperty "nncBits Octal fails on \"00\"" $+      isMalformed $ parseAs aWord (nncBits Octal) "00"+  , testProperty "nncBits Octal fails on \"01\"" $+      isMalformed $ parseAs aWord (nncBits Octal) "01"+  , testProperty "nnBitsUpTo Hexadecimal 3" $ \w →+      case parse (nnBitsUpTo Hexadecimal 3) (TP.nnLowHex w) of+        Malformed _ _ | w >= 0x1000      → True+        Parsed w'     | w' == (w ∷ Word) → True +        _                                → False+  , testProperty "nncBitsUpTo Octal 3" $ \w →+      case parse (nncBitsUpTo Octal 3) (TP.nnOctal w) of+        Malformed _ _ | w >= 0o1000      → True+        Parsed w'     | w' == (w ∷ Word) → True +        _                                → False+  , testProperty "nncBitsUpTo LowHex fails on \"00\"" $+      isMalformed $ parseAs aWord (nncBitsUpTo LowHex 3) "00"+  , testProperty "nncBitsUpTo LowHex fails on \"01\"" $+      isMalformed $ parseAs aWord (nncBitsUpTo LowHex 3) "01"+  , testProperty "nnbBits Hexadecimal Word" $ \w →+      parse (nnbBits Hexadecimal) (TP.nnUpHex w) == Parsed (w ∷ Word)+  , testProperty "nnbBits Hexadecimal Int" $ \i →+      (i >= 0) ==>+        parse (nnbBits Hexadecimal) (TP.nnLowHexBits i) == Parsed (i ∷ Int)+  , testProperty "nnbBits Hexadecimal Word fails on overflow" $+      isMalformed $ parseAs aWord (nnbBits Hexadecimal)+                            (TP.nnUpHexBits $ toInteger (maxBound ∷ Word) + 1)+  , testProperty "nnbBits Hexadecimal Int fails on overflow" $+      isMalformed $ parseAs anInt (nnbBits Hexadecimal)+                            (TP.nnUpHexBits $ toInteger (maxBound ∷ Int) + 1)+  , testProperty "nncbBits Octal fails on \"00\"" $+      isMalformed $ parseAs aWord (nncbBits Octal) "00"+  , testProperty "nncbBits Octal fails on \"01\"" $+      isMalformed $ parseAs aWord (nncbBits Octal) "01"+  , testProperty "nonPositive Binary" $ \i →+      (i <= 0) ==>+        parse (nonPositive Binary) (TP.npBinary i) == Parsed (i ∷ Int)+  , testProperty "nonPositive Decimal" $ \i →+      (i <= 0) ==>+        parse (nonPositive Decimal) (TP.npDecimal i) == Parsed (i ∷ Int)+  , testProperty "nonPositive Hexadecimal" $ \i →+      (i <= 0) ==>+        parse (nonPositive Hexadecimal) (TP.npLowHex i) == Parsed (i ∷ Int)+  , testProperty "npCompact Decimal" $ \i →+      (i <= 0) ==>+        parse (npCompact Decimal) (TP.npDecimal i) == Parsed (i ∷ Int)+  , testProperty "npCompact Decimal fails on \"00\"" $+      isMalformed $ parseAs anInt (npCompact Decimal) "00"+  , testProperty "npCompact Decimal fails on \"01\"" $+      isMalformed $ parseAs anInt (npCompact Decimal) "01"+  , testProperty "npUpTo Decimal 3" $ \i →+      (i <= 0) ==> case parse (npUpTo Decimal 3) (TP.npDecimal i) of+        Malformed _ _ | i <= -1000      → True+        Parsed i'     | i' == (i ∷ Int) → True +        _                               → False+  , testProperty "npcUpTo Decimal 3" $ \i →+      (i <= 0) ==> case parse (npcUpTo Decimal 3) (TP.npDecimal i) of+        Malformed _ _ | i <= -1000      → True+        Parsed i'     | i' == (i ∷ Int) → True +        _                               → False+  , testProperty "nncUpTo Decimal fails on \"00\"" $+      isMalformed $ parseAs aWord (nncUpTo Decimal 3) "00"+  , testProperty "nncUpTo Decimal fails on \"01\"" $+      isMalformed $ parseAs aWord (nncUpTo Decimal 3) "01"+  , testProperty "npBounded Hexadecimal" $ \i →+      (i <= 0) ==>+        parse (npBounded Hexadecimal) (TP.npLowHex i) == Parsed (i ∷ Int)+  , testProperty "npBounded Hexadecimal fails on overflow" $+      isMalformed $ parseAs anInt (npBounded Hexadecimal)+                            (TP.npLowHex $ toInteger (minBound ∷ Int) - 1)+  , testProperty "npcBounded Decimal fails on \"00\"" $+      isMalformed $ parseAs anInt (npcBounded Decimal) "00"+  , testProperty "npcBounded Decimal fails on \"01\"" $+      isMalformed $ parseAs anInt (npcBounded Decimal) "01"+  , testProperty "npBits Binary" $ \i →+      (i <= 0) ==>+        parse (npBits Binary) (TP.npBinaryBits i) == Parsed (i ∷ Int)+  , testProperty "npBits Hexadecimal" $ \i →+      (i <= 0) ==>+        parse (npBits Hexadecimal) (TP.npUpHex i) == Parsed (i ∷ Int)+  , testProperty "npcBits Octal" $ \i →+      (i <= 0) ==>+        parse (npcBits Octal) (TP.npOctal i) == Parsed (i ∷ Int)+  , testProperty "npcBits Octal fails on \"00\"" $+      isMalformed $ parseAs anInt (npcBits Octal) "00"+  , testProperty "npcBits Octal fails on \"01\"" $+      isMalformed $ parseAs anInt (npcBits Octal) "01"+  , testProperty "npBitsUpTo Hexadecimal 3" $ \i →+      (i <= 0) ==> case parse (npBitsUpTo Hexadecimal 3) (TP.npUpHex i) of+        Malformed _ _ | i <= -0x1000    → True+        Parsed i'     | i' == (i ∷ Int) → True +        _                               → False+  , testProperty "npcBitsUpTo Octal 3" $ \i →+      (i <= 0) ==> case parse (npcBitsUpTo Octal 3) (TP.npOctal i) of+        Malformed _ _ | i <= -0o1000    → True+        Parsed i'     | i' == (i ∷ Int) → True +        _                               → False+  , testProperty "npcBitsUpTo UpHex fails on \"00\"" $+      isMalformed $ parseAs anInt (npcBitsUpTo UpHex 3) "00"+  , testProperty "npcBitsUpTo UpHex fails on \"01\"" $+      isMalformed $ parseAs anInt (npcBitsUpTo UpHex 3) "01"+  , testProperty "npbBits Hexadecimal" $ \i →+      (i <= 0) ==>+        parse (npbBits Hexadecimal) (TP.npUpHexBits i) == Parsed (i ∷ Int)+  , testProperty "npbBits Hexadecimal fails on overflow" $+      isMalformed $ parseAs anInt (npbBits Hexadecimal)+                            (TP.npUpHexBits $ toInteger (minBound ∷ Int) - 1)+  , testProperty "npcbBits Octal fails on \"00\"" $+      isMalformed $ parseAs anInt (npcbBits Octal) "00"+  , testProperty "npcbBits Octal fails on \"01\"" $+      isMalformed $ parseAs anInt (npcbBits Octal) "01"+  , testProperty "number Decimal" $ \i →+      parse (number Decimal) (TP.decimal i) == Parsed (i ∷ Int)+  , testProperty "compact Decimal" $ \i →+      parse (number Decimal) (TP.decimal i) == Parsed (i ∷ Int)+  , testProperty "compact Decimal fails on \"00\"" $+      isMalformed $ parseAs anInt (compact Decimal) "00"+  , testProperty "compact Decimal fails on \"01\"" $+      isMalformed $ parseAs anInt (compact Decimal) "01"+  , testProperty "compact Decimal fails on \"-01\"" $+      isMalformed $ parseAs anInt (compact Decimal) "-01"+  , testProperty "numberUpTo Decimal 3" $ \i →+      case parseAs anInt (numberUpTo Decimal 3) (TP.decimal i) of+        Malformed _ _ | i >= 1000 || i <= -1000 → True+        Parsed i'     | i' == i                 → True +        _                                       → False+  , testProperty "compactUpTo Decimal 3" $ \i →+      case parseAs anInt (compactUpTo Decimal 3) (TP.decimal i) of+        Malformed _ _ | i >= 1000 || i <= -1000 → True+        Parsed i'     | i' == i                 → True +        _                                       → False+  , testProperty "compactUpTo Decimal fails on \"00\"" $+      isMalformed $ parseAs anInt (compactUpTo Decimal 3) "00"+  , testProperty "compactUpTo Decimal fails on \"01\"" $+      isMalformed $ parseAs anInt (compactUpTo Decimal 3) "01"+  , testProperty "compactUpTo Decimal fails on \"-01\"" $+      isMalformed $ parseAs anInt (compactUpTo Decimal 3) "-01"+  , testProperty "bounded Decimal" $ \i →+      parse (bounded Decimal) (TP.decimal i) == Parsed (i ∷ Int)+  , testProperty "bounded Decimal fails on overflow (vs maxBound)" $+      isMalformed $ parseAs anInt (bounded Decimal)+                            (TP.decimal $ toInteger (maxBound ∷ Int) + 1)+  , testProperty "bounded Decimal fails on overflow (vs minBound)" $+      isMalformed $ parseAs anInt (bounded Decimal)+                            (TP.decimal $ toInteger (minBound ∷ Int) - 1)+  , testProperty "cBounded Decimal" $ \i →+      parse (cBounded Decimal) (TP.decimal i) == Parsed (i ∷ Int)+  , testProperty "cBounded Octal fails on \"00\"" $+      isMalformed $ parseAs anInt (cBounded Octal) "00"+  , testProperty "cBounded Octal fails on \"01\"" $+      isMalformed $ parseAs anInt (cBounded Octal) "01"+  , testProperty "cBounded Octal fails on \"-01\"" $+      isMalformed $ parseAs anInt (cBounded Octal) "-01"+  , testProperty "bits Binary" $ \i →+      parse (bits Binary) (TP.binaryBits i) == Parsed (i ∷ Int)+  , testProperty "bits Hexadecimal" $ \i →+      parse (bits Hexadecimal) (TP.lowHexBits i) == Parsed (i ∷ Int)+  , testProperty "cBits Octal" $ \i →+      parse (cBits Octal) (TP.octalBits i) == Parsed (i ∷ Int)+  , testProperty "cBits Octal fails on \"00\"" $+      isMalformed $ parseAs anInt (cBits Octal) "00"+  , testProperty "cBits Octal fails on \"01\"" $+      isMalformed $ parseAs anInt (cBits Octal) "01"+  , testProperty "cBits Octal fails on \"-01\"" $+      isMalformed $ parseAs anInt (cBits Octal) "-01"+  , testProperty "bitsUpTo LowHex 3" $ \i →+      case parseAs anInt (bitsUpTo LowHex 3) (TP.lowHex i) of+        Malformed _ _ | i >= 0x1000 || i <= -0x1000 → True+        Parsed i'     | i' == i                     → True +        _                                           → False+  , testProperty "cBitsUpTo UpHex 3" $ \i →+      case parseAs anInt (cBitsUpTo UpHex 3) (TP.upHex i) of+        Malformed _ _ | i >= 0x1000 || i <= -0x1000 → True+        Parsed i'     | i' == i                     → True +        _                                           → False+  , testProperty "cBitsUpTo Octal fails on \"00\"" $+      isMalformed $ parseAs anInt (cBitsUpTo Octal 3) "00"+  , testProperty "cBitsUpTo Octal fails on \"01\"" $+      isMalformed $ parseAs anInt (cBitsUpTo Octal 3) "01"+  , testProperty "cBitsUpTo Octal fails on \"-01\"" $+      isMalformed $ parseAs anInt (cBitsUpTo Octal 3) "-01"+  , testProperty "bBits LowHex" $ \i →+      parse (bBits LowHex) (TP.lowHexBits i) == Parsed (i ∷ Int)+  , testProperty "bBits LowHex fails on overflow (vs maxBound)" $+      isMalformed $ parseAs anInt (bBits LowHex)+                            (TP.lowHexBits $ toInteger (maxBound ∷ Int) + 1)+  , testProperty "bBits UpHex fails on overflow (vs minBound)" $+      isMalformed $ parseAs anInt (bBits UpHex)+                            (TP.upHexBits $ toInteger (minBound ∷ Int) - 1)+  , testProperty "cbBits Octal" $ \i →+      parse (cbBits Octal) (TP.octal i) == Parsed (i ∷ Int)+  , testProperty "cbBits Octal fails on \"00\"" $+      isMalformed $ parseAs anInt (cbBits Octal) "00"+  , testProperty "cbBits Octal fails on \"01\"" $+      isMalformed $ parseAs anInt (cbBits Octal) "01"+  , testProperty "cbBits Octal fails on \"-01\"" $+      isMalformed $ parseAs anInt (cbBits Octal) "-01"+  ]++parse ∷ (∀ μ . (Monad μ, CharParsing μ) ⇒ μ α) → StringBuilder → Parsed α+parse p b = builtInParser (p <* PC.eof) (TP.buildString b)++parseAs ∷ Proxy α → (∀ μ . (Monad μ, CharParsing μ) ⇒ μ α) → StringBuilder+        → Parsed α+parseAs _ = parse+