digit 0.1.2 → 0.2.0

raw patch · 15 files changed

+462/−893 lines, 15 filesdep ~basedep ~lensdep ~template-haskellPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: base, lens, template-haskell

API changes (from Hackage documentation)

Files

• digit.cabal +11/−23
• src/Data/Digit.hs +451/−14
• src/Data/Digit/D0.hs +0/−9
• src/Data/Digit/D1.hs +0/−9
• src/Data/Digit/D2.hs +0/−9
• src/Data/Digit/D3.hs +0/−9
• src/Data/Digit/D4.hs +0/−9
• src/Data/Digit/D5.hs +0/−9
• src/Data/Digit/D6.hs +0/−9
• src/Data/Digit/D7.hs +0/−9
• src/Data/Digit/D8.hs +0/−9
• src/Data/Digit/D9.hs +0/−9
• src/Data/Digit/Digit.hs +0/−272
• src/Data/Digit/Digit1_8.hs +0/−255
• src/Data/Digit/Digit1_9.hs +0/−239

@@ -1,10 +1,10 @@ name:               digit-version:            0.1.2+version:            0.2.0 license:            BSD3 license-File:       etc/LICENCE author:             Tony Morris <ʇǝu˙sıɹɹoɯʇ@ןןǝʞsɐɥ> maintainer:         Tony Morris-copyright:          Copyright (C) 2010-2013 NICTA Limited+copyright:          Copyright (C) 2010-2016 NICTA Limited synopsis:           A data-type representing digits 0-9 and other combinations category:           Data homepage:           https://github.com/NICTA/digit@@ -29,9 +29,9 @@                     Haskell2010    build-depends:-                    base < 5 && >= 3-                    , lens >= 3.9.2-                    , template-haskell+                    base < 5 && >= 4.8+                    , lens >= 4.3.3 && < 5.0+                    , template-haskell >= 2.8    ghc-options:                     -Wall@@ -41,19 +41,6 @@    exposed-modules:                     Data.Digit-                    Data.Digit.D0-                    Data.Digit.D1-                    Data.Digit.D2-                    Data.Digit.D3-                    Data.Digit.D4-                    Data.Digit.D5-                    Data.Digit.D6-                    Data.Digit.D7-                    Data.Digit.D8-                    Data.Digit.D9-                    Data.Digit.Digit-                    Data.Digit.Digit1_8-                    Data.Digit.Digit1_9  test-suite doctests   type:@@ -66,11 +53,12 @@                     Haskell2010    build-depends:-                    base < 5 && >= 3,-                    doctest >= 0.9.7,-                    filepath >= 1.3,-                    directory >= 1.1,-                    QuickCheck >= 2.0+                    base < 5 && >= 4.8+                    , doctest >= 0.9.7+                    , filepath >= 1.3+                    , directory >= 1.1+                    , QuickCheck >= 2.0+                    , template-haskell >= 2.8    ghc-options:                     -Wall

@@ -1,15 +1,452 @@-module Data.Digit(module D) where+{-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE QuasiQuotes #-} -import Data.Digit.D0 as D-import Data.Digit.D1 as D-import Data.Digit.D2 as D-import Data.Digit.D3 as D-import Data.Digit.D4 as D-import Data.Digit.D5 as D-import Data.Digit.D6 as D-import Data.Digit.D7 as D-import Data.Digit.D8 as D-import Data.Digit.D9 as D-import Data.Digit.Digit as D-import Data.Digit.Digit1_8 as D-import Data.Digit.Digit1_9 as D+-- | A data type with ten nullary constructors [0-9] and combinators.+module Data.Digit+(+-- * Data type+  Digit+-- * Destructors+, foldDigit+-- * Prisms+, D0(..)+, x0+, D1(..)+, x1+, D2(..)+, x2+, D3(..)+, x3+, D4(..)+, x4+, D5(..)+, x5+, D6(..)+, x6+, D7(..)+, x7+, D8(..)+, x8+, D9(..)+, x9+, digit+, digitC+, digitQ+) where++import Control.Category((.))+import Control.Lens(Prism', prism', (^?), ( # ))+import Data.Char(Char)+import Data.Data (Data)+import Data.Eq(Eq)+import Data.Function(const)+import Data.Int(Int)+import Data.Maybe(Maybe(Nothing, Just), maybe)+import Data.Ord(Ord)+import Data.Typeable (Typeable)+import Language.Haskell.TH(ExpQ, PatQ, varE, varP, mkName)+import Language.Haskell.TH.Quote(QuasiQuoter(QuasiQuoter), quotePat, quoteExp, quoteDec, dataToExpQ, dataToPatQ, quoteType)+import Prelude(Show(..), Read(..), Enum(..), Bounded, error)++-- $setup+-- >>> import Prelude++-- | A data type with ten nullary constructors.+data Digit =+  D0+  | D1+  | D2+  | D3+  | D4+  | D5+  | D6+  | D7+  | D8+  | D9+  deriving (Eq, Ord, Enum, Bounded, Data, Typeable)++-- | Catamorphism for @Digit@.+--+-- prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d0 == x0+--+-- prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d1 == x1+--+-- prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d2 == x2+--+-- prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d3 == x3+--+-- prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d4 == x4+--+-- prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d5 == x5+--+-- prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d6 == x6+--+-- prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d7 == x7+--+-- prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d8 == x8+--+-- prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d9 == x9+foldDigit ::+  a -- ^ Zero.+  -> a -- ^ One.+  -> a -- ^ Two.+  -> a -- ^ Three.+  -> a -- ^ Four.+  -> a -- ^ Five.+  -> a -- ^ Six.+  -> a -- ^ Seven.+  -> a -- ^ Eight.+  -> a -- ^ Nine.+  -> Digit -- ^ The digit to fold.+  -> a+foldDigit q0 _  _  _  _  _  _  _  _  _  D0 =+  q0+foldDigit _  q1 _  _  _  _  _  _  _  _  D1 =+  q1+foldDigit _  _  q2 _  _  _  _  _  _  _  D2 =+  q2+foldDigit _  _  _  q3 _  _  _  _  _  _  D3 =+  q3+foldDigit _  _  _  _  q4 _  _  _  _  _  D4 =+  q4+foldDigit _  _  _  _  _  q5 _  _  _  _  D5 =+  q5+foldDigit _  _  _  _  _  _  q6 _  _  _  D6 =+  q6+foldDigit _  _  _  _  _  _  _  q7 _  _  D7 =+  q7+foldDigit _  _  _  _  _  _  _  _  q8 _  D8 =+  q8+foldDigit _  _  _  _  _  _  _  _  _  q9 D9 =+  q9++class D0 d where+  d0 ::+    Prism'+      d+      ()++instance D0 Digit where+  d0 =+    prism'+      (\() -> D0)+      (\d -> case d of+               D0 -> Just ()+               _ -> Nothing)++x0 ::+  D0 d =>+  d+x0 =+  d0 # ()++class D1 d where+  d1 ::+    Prism'+      d+      ()++instance D1 Digit where+  d1 =+    prism'+      (\() -> D1)+      (\d -> case d of+               D1 -> Just ()+               _ -> Nothing)++x1 ::+  D1 d =>+  d+x1 =+  d1 # ()++class D2 d where+  d2 ::+    Prism'+      d+      ()++instance D2 Digit where+  d2 =+    prism'+      (\() -> D2)+      (\d -> case d of+               D2 -> Just ()+               _ -> Nothing)++x2 ::+  D2 d =>+  d+x2 =+  d2 # ()++class D3 d where+  d3 ::+    Prism'+      d+      ()++instance D3 Digit where+  d3 =+    prism'+      (\() -> D3)+      (\d -> case d of+               D3 -> Just ()+               _ -> Nothing)++x3 ::+  D3 d =>+  d+x3 =+  d3 # ()++class D4 d where+  d4 ::+    Prism'+      d+      ()++instance D4 Digit where+  d4 =+    prism'+      (\() -> D4)+      (\d -> case d of+               D4 -> Just ()+               _ -> Nothing)++x4 ::+  D4 d =>+  d+x4 =+  d4 # ()++class D5 d where+  d5 ::+    Prism'+      d+      ()++instance D5 Digit where+  d5 =+    prism'+      (\() -> D5)+      (\d -> case d of+               D5 -> Just ()+               _ -> Nothing)++x5 ::+  D5 d =>+  d+x5 =+  d5 # ()++class D6 d where+  d6 ::+    Prism'+      d+      ()++instance D6 Digit where+  d6 =+    prism'+      (\() -> D6)+      (\d -> case d of+               D6 -> Just ()+               _ -> Nothing)++x6 ::+  D6 d =>+  d+x6 =+  d6 # ()++class D7 d where+  d7 ::+    Prism'+      d+      ()++instance D7 Digit where+  d7 =+    prism'+      (\() -> D7)+      (\d -> case d of+               D7 -> Just ()+               _ -> Nothing)++x7 ::+  D7 d =>+  d+x7 =+  d7 # ()++class D8 d where+  d8 ::+    Prism'+      d+      ()++instance D8 Digit where+  d8 =+    prism'+      (\() -> D8)+      (\d -> case d of+               D8 -> Just ()+               _ -> Nothing)++x8 ::+  D8 d =>+  d+x8 =+  d8 # ()++class D9 d where+  d9 ::+    Prism'+      d+      ()++instance D9 Digit where+  d9 =+    prism'+      (\() -> D9)+      (\d -> case d of+               D9 -> Just ()+               _ -> Nothing)++x9 ::+  D9 d =>+  d+x9 =+  d9 # ()++-- | A prism for using @Int@ as @Digit@.+--+-- >>> 5 ^? digit+-- Just 5+--+-- >>> 0 ^? digit+-- Just 0+--+-- >>> 9 ^? digit+-- Just 9+--+-- >>> 10 ^? digit+-- Nothing+--+-- >>> (-5) ^? digit+-- Nothing+digit ::+  Prism' Int Digit+digit =+  prism'+    fromEnum+    (\n -> case n of 0 -> Just D0+                     1 -> Just D1+                     2 -> Just D2+                     3 -> Just D3+                     4 -> Just D4+                     5 -> Just D5+                     6 -> Just D6+                     7 -> Just D7+                     8 -> Just D8+                     9 -> Just D9+                     _ -> Nothing)++-- | A prism for using @Char@ as @Digit@.+--+-- >>> '5' ^? digitC+-- Just 5+--+-- >>> '0' ^? digitC+-- Just 0+--+-- >>> '9' ^? digitC+-- Just 9+--+-- >>> 'a' ^? digitC+-- Nothing+--+-- >>> '@' ^? digitC+-- Nothing+digitC ::+  Prism' Char Digit+digitC =+  prism'+    (\d -> case d of D0 -> '0'+                     D1 -> '1'+                     D2 -> '2'+                     D3 -> '3'+                     D4 -> '4'+                     D5 -> '5'+                     D6 -> '6'+                     D7 -> '7'+                     D8 -> '8'+                     D9 -> '9')+    (\n -> case n of '0' -> Just D0+                     '1' -> Just D1+                     '2' -> Just D2+                     '3' -> Just D3+                     '4' -> Just D4+                     '5' -> Just D5+                     '6' -> Just D6+                     '7' -> Just D7+                     '8' -> Just D8+                     '9' -> Just D9+                     _ -> Nothing)++instance Show Digit where+  show = show . fromEnum++instance Read Digit where+  readsPrec _ ('0':t) =+    [(D0, t)]+  readsPrec _ ('1':t) =+    [(D1, t)]+  readsPrec _ ('2':t) =+    [(D2, t)]+  readsPrec _ ('3':t) =+    [(D3, t)]+  readsPrec _ ('4':t) =+    [(D4, t)]+  readsPrec _ ('5':t) =+    [(D5, t)]+  readsPrec _ ('6':t) =+    [(D6, t)]+  readsPrec _ ('7':t) =+    [(D7, t)]+  readsPrec _ ('8':t) =+    [(D8, t)]+  readsPrec _ ('9':t) =+    [(D9, t)]+  readsPrec _ _       =+    []++-- | A QuasiQuoter for any range of @Digit@.+--+-- [digitQ|4|] :: Digit+-- 4+--+-- named [digitQ|4|]  = "four"+-- named [digitQ|$x|] = "not four, " ++ show x ++ " instead"+--+-- mod10D x = let y = mod x 10 in [digitQ|$y|]+digitQ :: QuasiQuoter+digitQ = QuasiQuoter {+    quoteExp = dexp+  , quotePat = dpat+  , quoteType = error "not quotable"+  , quoteDec = error "not quotable"+  }++dexp :: [Char] -> ExpQ+dexp ('$':vn) = varE (mkName vn)+dexp (d:[])   = maybe (error "not a digit") (dataToExpQ (const Nothing)) (d ^? digitC)+dexp _        = error "not a digit"++dpat :: [Char] -> PatQ+dpat ('$':vn) = varP (mkName vn)+dpat (d:[])   = maybe (error "not a digit") (dataToPatQ (const Nothing)) (d ^? digitC)+dpat _        = error "not a digit"

@@ -1,9 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D0 where--import Prelude(Eq)--class Eq a => D0 a where-  d0 ::-    a

@@ -1,9 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D1 where--import Prelude(Eq)--class Eq a => D1 a where-  d1 ::-    a

@@ -1,9 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D2 where--import Prelude(Eq)--class Eq a => D2 a where-  d2 ::-    a

@@ -1,9 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D3 where--import Prelude(Eq)--class Eq a => D3 a where-  d3 ::-    a

@@ -1,9 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D4 where--import Prelude(Eq)--class Eq a => D4 a where-  d4 ::-    a

@@ -1,9 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D5 where--import Prelude(Eq)--class Eq a => D5 a where-  d5 ::-    a

@@ -1,9 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D6 where--import Prelude(Eq)--class Eq a => D6 a where-  d6 ::-    a

@@ -1,9 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D7 where--import Prelude(Eq)--class Eq a => D7 a where-  d7 ::-    a

@@ -1,9 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D8 where--import Prelude(Eq)--class Eq a => D8 a where-  d8 ::-    a

@@ -1,9 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Data.Digit.D9 where--import Prelude(Eq)--class Eq a => D9 a where-  d9 ::-    a

@@ -1,272 +0,0 @@-{-# LANGUAGE NoImplicitPrelude, DeriveDataTypeable, TemplateHaskell, QuasiQuotes #-}---- | A data type with ten nullary constructors [0-9] and combinators.-module Data.Digit.Digit-(--- * Data type-  Digit--- * Destructors-, foldDigit--- * Prisms-, digit-, digitC-, digitQ-) where--import Prelude(Show(..), Read(..), Eq, Enum(..), Maybe(..), Bounded, Ord, Int, Char, (.), const, maybe, error)-import Data.Digit.D0-import Data.Digit.D1-import Data.Digit.D2-import Data.Digit.D3-import Data.Digit.D4-import Data.Digit.D5-import Data.Digit.D6-import Data.Digit.D7-import Data.Digit.D8-import Data.Digit.D9-import Control.Lens-import Data.Data (Data)-import Data.Typeable (Typeable)-import Language.Haskell.TH-import Language.Haskell.TH.Quote---- $setup--- >>> import Prelude---- | A data type with ten nullary constructors.-data Digit =-  D0-  | D1-  | D2-  | D3-  | D4-  | D5-  | D6-  | D7-  | D8-  | D9-  deriving (Eq, Ord, Enum, Bounded, Data, Typeable)---- | Catamorphism for @Digit@.------ prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d0 == x0------ prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d1 == x1------ prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d2 == x2------ prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d3 == x3------ prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d4 == x4------ prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d5 == x5------ prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d6 == x6------ prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d7 == x7------ prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d8 == x8------ prop> foldDigit x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 d9 == x9-foldDigit ::-  a -- ^ Zero.-  -> a -- ^ One.-  -> a -- ^ Two.-  -> a -- ^ Three.-  -> a -- ^ Four.-  -> a -- ^ Five.-  -> a -- ^ Six.-  -> a -- ^ Seven.-  -> a -- ^ Eight.-  -> a -- ^ Nine.-  -> Digit -- ^ The digit to fold.-  -> a-foldDigit x0 _  _  _  _  _  _  _  _  _  D0 =-  x0-foldDigit _  x1 _  _  _  _  _  _  _  _  D1 =-  x1-foldDigit _  _  x2 _  _  _  _  _  _  _  D2 =-  x2-foldDigit _  _  _  x3 _  _  _  _  _  _  D3 =-  x3-foldDigit _  _  _  _  x4 _  _  _  _  _  D4 =-  x4-foldDigit _  _  _  _  _  x5 _  _  _  _  D5 =-  x5-foldDigit _  _  _  _  _  _  x6 _  _  _  D6 =-  x6-foldDigit _  _  _  _  _  _  _  x7 _  _  D7 =-  x7-foldDigit _  _  _  _  _  _  _  _  x8 _  D8 =-  x8-foldDigit _  _  _  _  _  _  _  _  _  x9 D9 =-  x9--instance D0 Digit where-  d0 =-    D0--instance D1 Digit where-  d1 =-    D1--instance D2 Digit where-  d2 =-    D2--instance D3 Digit where-  d3 =-    D3--instance D4 Digit where-  d4 =-    D4--instance D5 Digit where-  d5 =-    D5--instance D6 Digit where-  d6 =-    D6--instance D7 Digit where-  d7 =-    D7--instance D8 Digit where-  d8 =-    D8--instance D9 Digit where-  d9 =-    D9---- | A prism for using @Int@ as @Digit@.------ >>> 5 ^? digit--- Just 5------ >>> 0 ^? digit--- Just 0------ >>> 9 ^? digit--- Just 9------ >>> 10 ^? digit--- Nothing------ >>> (-5) ^? digit--- Nothing-digit ::-  Prism' Int Digit-digit =-  prism'-    fromEnum-    (\n -> case n of 0 -> Just D0-                     1 -> Just D1-                     2 -> Just D2-                     3 -> Just D3-                     4 -> Just D4-                     5 -> Just D5-                     6 -> Just D6-                     7 -> Just D7-                     8 -> Just D8-                     9 -> Just D9-                     _ -> Nothing)---- | A prism for using @Char@ as @Digit@.------ >>> '5' ^? digitC--- Just 5------ >>> '0' ^? digitC--- Just 0------ >>> '9' ^? digitC--- Just 9------ >>> 'a' ^? digitC--- Nothing------ >>> '@' ^? digitC--- Nothing-digitC ::-  Prism' Char Digit-digitC =-  prism'-    (\d -> case d of D0 -> '0'-                     D1 -> '1'-                     D2 -> '2'-                     D3 -> '3'-                     D4 -> '4'-                     D5 -> '5'-                     D6 -> '6'-                     D7 -> '7'-                     D8 -> '8'-                     D9 -> '9')-    (\n -> case n of '0' -> Just D0-                     '1' -> Just D1-                     '2' -> Just D2-                     '3' -> Just D3-                     '4' -> Just D4-                     '5' -> Just D5-                     '6' -> Just D6-                     '7' -> Just D7-                     '8' -> Just D8-                     '9' -> Just D9-                     _ -> Nothing)--instance Show Digit where-  show = show . fromEnum--instance Read Digit where-  readsPrec _ ('0':t) =-    [(D0, t)]-  readsPrec _ ('1':t) =-    [(D1, t)]-  readsPrec _ ('2':t) =-    [(D2, t)]-  readsPrec _ ('3':t) =-    [(D3, t)]-  readsPrec _ ('4':t) =-    [(D4, t)]-  readsPrec _ ('5':t) =-    [(D5, t)]-  readsPrec _ ('6':t) =-    [(D6, t)]-  readsPrec _ ('7':t) =-    [(D7, t)]-  readsPrec _ ('8':t) =-    [(D8, t)]-  readsPrec _ ('9':t) =-    [(D9, t)]-  readsPrec _ _       =-    []---- | A QuasiQuoter for any range of @Digit@.------ [digitQ|4|] :: Digit--- 4------ named [digitQ|4|]  = "four"--- named [digitQ|$x|] = "not four, " ++ show x ++ " instead"------ mod10D x = let y = mod x 10 in [digitQ|$y|]-digitQ :: QuasiQuoter-digitQ = QuasiQuoter {-    quoteExp = dexp-  , quotePat = dpat-  , quoteType = error "not quotable"-  , quoteDec = error "not quotable"-  }--dexp :: [Char] -> ExpQ-dexp ('$':vn) = varE (mkName vn)-dexp (d:[])   = maybe (error "not a digit") (dataToExpQ (const Nothing)) (d ^? digitC)-dexp _        = error "not a digit"--dpat :: [Char] -> PatQ-dpat ('$':vn) = varP (mkName vn)-dpat (d:[])   = maybe (error "not a digit") (dataToPatQ (const Nothing)) (d ^? digitC)-dpat _        = error "not a digit"

@@ -1,255 +0,0 @@-{-# LANGUAGE NoImplicitPrelude, DeriveDataTypeable #-}---- | A data type with eight nullary constructors [1-8] and combinators.-module Data.Digit.Digit1_8-(--- * Data type-  Digit1_8--- * Destructors-, foldDigit1_8--- * Prisms-, digit1_8-, digitC1_8-, digit1_8digit-, digit1_8digit1_9-) where--import Prelude(Show(..), Read(..), Eq, Enum(..), Maybe(..), Bounded, Ord, Int, Char, (.))-import Data.Digit.Digit(Digit, digit, digitC)-import Data.Digit.Digit1_9(Digit1_9, foldDigit1_9, digit1_9digit)-import Data.Digit.D1-import Data.Digit.D2-import Data.Digit.D3-import Data.Digit.D4-import Data.Digit.D5-import Data.Digit.D6-import Data.Digit.D7-import Data.Digit.D8-import Control.Lens-import Data.Data (Data)-import Data.Typeable (Typeable)---- $setup--- >>> import Prelude--- >>> import Data.Digit.D0--- >>> import Data.Digit.D9---- | A data type with eight nullary constructors.-data Digit1_8 =-  D1-  | D2-  | D3-  | D4-  | D5-  | D6-  | D7-  | D8-  deriving (Eq, Ord, Enum, Bounded, Data, Typeable)---- | Catamorphism for @Digit1_8@.------ prop> foldDigit1_8 x1 x2 x3 x4 x5 x6 x7 x8 d1 == x1------ prop> foldDigit1_8 x1 x2 x3 x4 x5 x6 x7 x8 d2 == x2------ prop> foldDigit1_8 x1 x2 x3 x4 x5 x6 x7 x8 d3 == x3------ prop> foldDigit1_8 x1 x2 x3 x4 x5 x6 x7 x8 d4 == x4------ prop> foldDigit1_8 x1 x2 x3 x4 x5 x6 x7 x8 d5 == x5------ prop> foldDigit1_8 x1 x2 x3 x4 x5 x6 x7 x8 d6 == x6------ prop> foldDigit1_8 x1 x2 x3 x4 x5 x6 x7 x8 d7 == x7------ prop> foldDigit1_8 x1 x2 x3 x4 x5 x6 x7 x8 d8 == x8-foldDigit1_8 ::-  a -- ^ One.-  -> a -- ^ Two.-  -> a -- ^ Three.-  -> a -- ^ Four.-  -> a -- ^ Five.-  -> a -- ^ Six.-  -> a -- ^ Seven.-  -> a -- ^ Eight.-  -> Digit1_8 -- ^ The digit to fold.-  -> a-foldDigit1_8 x1 _  _  _  _  _  _  _  D1 =-  x1-foldDigit1_8 _  x2 _  _  _  _  _  _  D2 =-  x2-foldDigit1_8 _  _  x3 _  _  _  _  _  D3 =-  x3-foldDigit1_8 _  _  _  x4 _  _  _  _  D4 =-  x4-foldDigit1_8 _  _  _  _  x5 _  _  _  D5 =-  x5-foldDigit1_8 _  _  _  _  _  x6 _  _  D6 =-  x6-foldDigit1_8 _  _  _  _  _  _  x7 _  D7 =-  x7-foldDigit1_8 _  _  _  _  _  _  _  x8 D8 =-  x8--instance D1 Digit1_8 where-  d1 =-    D1--instance D2 Digit1_8 where-  d2 =-    D2--instance D3 Digit1_8 where-  d3 =-    D3--instance D4 Digit1_8 where-  d4 =-    D4--instance D5 Digit1_8 where-  d5 =-    D5--instance D6 Digit1_8 where-  d6 =-    D6--instance D7 Digit1_8 where-  d7 =-    D7--instance D8 Digit1_8 where-  d8 =-    D8---- | A prism for using @Int@ as @Digit1_8@.------ >>> 5 ^? digit1_8--- Just 5------ >>> 0 ^? digit1_8--- Nothing------ >>> 8 ^? digit1_8--- Just 8------ >>> 9 ^? digit1_8--- Nothing------ >>> 10 ^? digit1_8--- Nothing------ >>> (-5) ^? digit1_8--- Nothing-digit1_8 ::-  Prism' Int Digit1_8-digit1_8 =-  digit . digit1_8digit---- | A prism for using @Char@ as @Digit1_8@.------ >>> '5' ^? digitC1_8--- Just 5------ >>> '0' ^? digitC1_8--- Nothing------ >>> '8' ^? digitC1_8--- Just 8------ >>> '9' ^? digitC1_8--- Nothing------ >>> 'x' ^? digitC1_8--- Nothing------ >>> '*' ^? digitC1_8--- Nothing-digitC1_8 ::-  Prism' Char Digit1_8-digitC1_8 =-  digitC . digit1_8digit---- | A prism for using @Digit@ as @Digit1_8@.------ >>> d5 ^? digit1_8digit--- Just 5------ >>> d0 ^? digit1_8digit--- Nothing------ >>> d8 ^? digit1_8digit--- Just 8------ >>> d9 ^? digit1_8digit--- Nothing------ >>> d1 ^? digit1_8digit--- Just 1-digit1_8digit ::-  Prism' Digit Digit1_8-digit1_8digit =-  digit1_9digit . digit1_8digit1_9---- | A prism for using @Digit1_9@ as @Digit1_8@.------ >>> d5 ^? digit1_8digit1_9--- Just 5------ >>> d8 ^? digit1_8digit1_9--- Just 8------ >>> d9 ^? digit1_8digit1_9--- Nothing------ >>> d1 ^? digit1_8digit1_9--- Just 1-digit1_8digit1_9 ::-  Prism' Digit1_9 Digit1_8-digit1_8digit1_9 =-  prism'-    (foldDigit1_8-           d1-           d2-           d3-           d4-           d5-           d6-           d7-           d8)-    (foldDigit1_9-      (Just D1)-      (Just D2)-      (Just D3)-      (Just D4)-      (Just D5)-      (Just D6)-      (Just D7)-      (Just D8)-      Nothing)---instance Show Digit1_8 where-  show d =-    show (digit1_8 # d)--instance Read Digit1_8 where-  readsPrec _ ('1':t) =-    [(D1, t)]-  readsPrec _ ('2':t) =-    [(D2, t)]-  readsPrec _ ('3':t) =-    [(D3, t)]-  readsPrec _ ('4':t) =-    [(D4, t)]-  readsPrec _ ('5':t) =-    [(D5, t)]-  readsPrec _ ('6':t) =-    [(D6, t)]-  readsPrec _ ('7':t) =-    [(D7, t)]-  readsPrec _ ('8':t) =-    [(D8, t)]-  readsPrec _ _       =-    []

@@ -1,239 +0,0 @@-{-# LANGUAGE NoImplicitPrelude, DeriveDataTypeable #-}---- | A data type with nine nullary constructors [1-9] and combinators.-module Data.Digit.Digit1_9-(--- * Data type-  Digit1_9--- * Destructors-, foldDigit1_9--- * Prisms-, digit1_9-, digitC1_9-, digit1_9digit-) where--import Prelude(Show(..), Read(..), Eq, Enum(..), Maybe(..), Bounded, Ord, Int, Char, (.))-import Data.Digit.Digit(Digit, foldDigit, digit, digitC)-import Data.Digit.D1-import Data.Digit.D2-import Data.Digit.D3-import Data.Digit.D4-import Data.Digit.D5-import Data.Digit.D6-import Data.Digit.D7-import Data.Digit.D8-import Data.Digit.D9-import Control.Lens-import Data.Data (Data)-import Data.Typeable (Typeable)---- $setup--- >>> import Prelude--- >>> import Data.Digit.D0---- | A data type with nine nullary constructors.-data Digit1_9 =-  D1-  | D2-  | D3-  | D4-  | D5-  | D6-  | D7-  | D8-  | D9-  deriving (Eq, Ord, Enum, Bounded, Data, Typeable)---- | Catamorphism for @Digit1_9@.------ prop> foldDigit1_9 x1 x2 x3 x4 x5 x6 x7 x8 x9 d1 == x1------ prop> foldDigit1_9 x1 x2 x3 x4 x5 x6 x7 x8 x9 d2 == x2------ prop> foldDigit1_9 x1 x2 x3 x4 x5 x6 x7 x8 x9 d3 == x3------ prop> foldDigit1_9 x1 x2 x3 x4 x5 x6 x7 x8 x9 d4 == x4------ prop> foldDigit1_9 x1 x2 x3 x4 x5 x6 x7 x8 x9 d5 == x5------ prop> foldDigit1_9 x1 x2 x3 x4 x5 x6 x7 x8 x9 d6 == x6------ prop> foldDigit1_9 x1 x2 x3 x4 x5 x6 x7 x8 x9 d7 == x7------ prop> foldDigit1_9 x1 x2 x3 x4 x5 x6 x7 x8 x9 d8 == x8------ prop> foldDigit1_9 x1 x2 x3 x4 x5 x6 x7 x8 x9 d9 == x9-foldDigit1_9 ::-  a -- ^ One.-  -> a -- ^ Two.-  -> a -- ^ Three.-  -> a -- ^ Four.-  -> a -- ^ Five.-  -> a -- ^ Six.-  -> a -- ^ Seven.-  -> a -- ^ Eight.-  -> a -- ^ Nine.-  -> Digit1_9 -- ^ The digit to fold.-  -> a-foldDigit1_9 x1 _  _  _  _  _  _  _  _  D1 =-  x1-foldDigit1_9 _  x2 _  _  _  _  _  _  _  D2 =-  x2-foldDigit1_9 _  _  x3 _  _  _  _  _  _  D3 =-  x3-foldDigit1_9 _  _  _  x4 _  _  _  _  _  D4 =-  x4-foldDigit1_9 _  _  _  _  x5 _  _  _  _  D5 =-  x5-foldDigit1_9 _  _  _  _  _  x6 _  _  _  D6 =-  x6-foldDigit1_9 _  _  _  _  _  _  x7 _  _  D7 =-  x7-foldDigit1_9 _  _  _  _  _  _  _  x8 _  D8 =-  x8-foldDigit1_9 _  _  _  _  _  _  _  _  x9 D9 =-  x9--instance D1 Digit1_9 where-  d1 =-    D1--instance D2 Digit1_9 where-  d2 =-    D2--instance D3 Digit1_9 where-  d3 =-    D3--instance D4 Digit1_9 where-  d4 =-    D4--instance D5 Digit1_9 where-  d5 =-    D5--instance D6 Digit1_9 where-  d6 =-    D6--instance D7 Digit1_9 where-  d7 =-    D7--instance D8 Digit1_9 where-  d8 =-    D8--instance D9 Digit1_9 where-  d9 =-    D9---- | A prism for using @Int@ as @Digit1_9@.------ >>> 5 ^? digit1_9--- Just 5------ >>> 0 ^? digit1_9--- Nothing------ >>> 9 ^? digit1_9--- Just 9------ >>> 10 ^? digit1_9--- Nothing------ >>> (-5) ^? digit1_9--- Nothing-digit1_9 ::-  Prism' Int Digit1_9-digit1_9 =-  digit . digit1_9digit---- | A prism for using @Char@ as @Digit1_9@.------ >>> '5' ^? digitC1_9--- Just 5------ >>> '0' ^? digitC1_9--- Nothing------ >>> '9' ^? digitC1_9--- Just 9------ >>> 'x' ^? digitC1_9--- Nothing------ >>> '*' ^? digitC1_9--- Nothing-digitC1_9 ::-  Prism' Char Digit1_9-digitC1_9 =-  digitC . digit1_9digit---- | A prism for using @Digit@ as @Digit1_9@.------ >>> d5 ^? digit1_9digit--- Just 5------ >>> d0 ^? digit1_9digit--- Nothing------ >>> d9 ^? digit1_9digit--- Just 9------ >>> d1 ^? digit1_9digit--- Just 1-digit1_9digit ::-  Prism' Digit Digit1_9-digit1_9digit =-  prism'-    (foldDigit1_9-      d1-      d2-      d3-      d4-      d5-      d6-      d7-      d8-      d9)-    (foldDigit-      Nothing-      (Just D1)-      (Just D2)-      (Just D3)-      (Just D4)-      (Just D5)-      (Just D6)-      (Just D7)-      (Just D8)-      (Just D9))--instance Show Digit1_9 where-  show d =-    show (digit1_9 # d)--instance Read Digit1_9 where-  readsPrec _ ('1':t) =-    [(D1, t)]-  readsPrec _ ('2':t) =-    [(D2, t)]-  readsPrec _ ('3':t) =-    [(D3, t)]-  readsPrec _ ('4':t) =-    [(D4, t)]-  readsPrec _ ('5':t) =-    [(D5, t)]-  readsPrec _ ('6':t) =-    [(D6, t)]-  readsPrec _ ('7':t) =-    [(D7, t)]-  readsPrec _ ('8':t) =-    [(D8, t)]-  readsPrec _ ('9':t) =-    [(D9, t)]-  readsPrec _ _       =-    []