packages feed

ascii-superset 1.0.1.10 → 1.0.1.12

raw patch · 8 files changed

+148/−165 lines, 8 filesdep +hedgehogdep ~ascii-chardep ~basedep ~textPVP ok

version bump matches the API change (PVP)

Dependencies added: hedgehog

Dependency ranges changed: ascii-char, base, text

API changes (from Hackage documentation)

Files

ascii-superset.cabal view
@@ -1,11 +1,15 @@-cabal-version: 2.0+cabal-version: 3.0  name: ascii-superset-version: 1.0.1.10+version: 1.0.1.12 synopsis: Representing ASCII with refined supersets category: Data, Text -description: This package defines classes which describe what subset of a type is valid as ASCII, as well as a type constructor representing a value of a superset that is known to be valid ASCII.+description:+    This package defines classes which describe what+    subset of a type is valid as ASCII, as well as a+    type constructor representing a value of a+    superset that is known to be valid ASCII.  license: Apache-2.0 license-file: license.txt@@ -13,47 +17,60 @@ author: Chris Martin maintainer: Chris Martin, Julie Moronuki -homepage:    https://github.com/typeclasses/ascii+homepage: https://github.com/typeclasses/ascii bug-Reports: https://github.com/typeclasses/ascii/issues  build-type: Simple -extra-source-files: changelog.txt- source-repository head-    type:     git+    type: git     location: git://github.com/typeclasses/ascii.git -library+common base     default-language: Haskell2010-    default-extensions: NoImplicitPrelude-    default-extensions: StandaloneDeriving-    default-extensions: DerivingStrategies-    default-extensions: GeneralizedNewtypeDeriving-    default-extensions: DeriveDataTypeable-    default-extensions: DeriveGeneric-    ghc-options: -Wall -fno-warn-unused-imports+    ghc-options: -Wall++    default-extensions:+        NoImplicitPrelude++    build-depends:+        ascii-char ^>= 1.0+      , base >= 4.11 && < 4.17+      , text ^>= 1.2.3++library+    import: base+    ghc-options: -fno-warn-unused-imports     hs-source-dirs: library -    build-depends: ascii-char ^>= 1.0+    default-extensions:+        DeriveDataTypeable+        DeriveGeneric+        DerivingStrategies+        GeneralizedNewtypeDeriving+        StandaloneDeriving -    build-depends: base       >= 4.11 && < 4.17-    build-depends: bytestring ^>= 0.10 || ^>= 0.11-    build-depends: hashable   >= 1.2  && < 1.5-    build-depends: text       ^>= 1.2.3+    build-depends:+        bytestring ^>= 0.10 || ^>= 0.11+      , hashable >= 1.2 && < 1.5 -    exposed-modules: ASCII.Superset-    exposed-modules: ASCII.Isomorphism-    exposed-modules: ASCII.Refinement-    exposed-modules: ASCII.Lift+    exposed-modules:+        ASCII.Superset+      , ASCII.Isomorphism+      , ASCII.Refinement+      , ASCII.Lift -test-suite test+test-suite test-ascii-superset+    import: base     type: exitcode-stdio-1.0-    default-language: Haskell2010-    default-extensions: NoImplicitPrelude-    default-extensions: OverloadedStrings-    default-extensions: QuasiQuotes-    ghc-options: -Wall     hs-source-dirs: test-    main-is: test.hs-    build-depends: ascii-char, ascii-superset, base, text+    main-is: Main.hs++    default-extensions:+        OverloadedStrings+        QuasiQuotes+        TemplateHaskell++    build-depends:+        ascii-superset+      , hedgehog ^>= 1.0 || ^>= 1.1
− changelog.txt 
@@ -1,26 +0,0 @@-1.0.0.0 - 2020-05-05 - Initial release--1.0.0.2 - 2020-05-18 - Support GHC 8.10--1.0.0.4 - 2021-01-25 - Add some comments--1.0.1.0 - 2021-01-27--    New functions:-        - convertCharMaybe-        - convertCharOrFail-        - convertStringMaybe-        - convertStringOrFail--1.0.1.2 - 2021-02-09 - Support bytestring-0.11--1.0.1.4 - 2021-02-10 - Support GHC 9.0--1.0.1.6 - 2021-09-26--    - Add a test suite-    - Raise 'text' lower bound to 1.2.3--1.0.1.8 - 2021-11-13 - Support hashable 1.4--1.0.0.10 - 2022-01-09 - Support GHC 9.2
library/ASCII/Isomorphism.hs view
@@ -1,9 +1,9 @@ module ASCII.Isomorphism ( CharIso (..), asChar, StringIso (..) ) where -import ASCII.Char     ( Char )-import ASCII.Superset ( CharSuperset (..), StringSuperset (..) )-import Data.Function  ( id, (.) )-import Data.List      ( map )+import ASCII.Char (Char)+import ASCII.Superset (CharSuperset (..), StringSuperset (..))+import Data.Function (id, (.))+import Data.List (map)  class CharSuperset char => CharIso char   where
library/ASCII/Lift.hs view
@@ -2,9 +2,9 @@  module ASCII.Lift ( Lift (..) ) where -import ASCII.Char       ( Char )-import ASCII.Refinement ( ASCII )-import ASCII.Superset   ( CharSuperset, StringSuperset )+import ASCII.Char (Char)+import ASCII.Refinement (ASCII)+import ASCII.Superset (CharSuperset, StringSuperset)  import qualified ASCII.Refinement as R import qualified ASCII.Superset as S
library/ASCII/Refinement.hs view
@@ -7,23 +7,23 @@   where  import qualified ASCII.Char as ASCII-import qualified ASCII.Superset as S import qualified ASCII.Isomorphism as I+import qualified ASCII.Superset as S -import ASCII.Superset    ( CharSuperset, StringSuperset )-import Data.Bool         ( Bool (..) )-import Data.Data         ( Data )-import Data.Eq           ( Eq )-import Data.Function     ( (.), ($), id )-import Data.Hashable     ( Hashable )-import Data.List         ( map )-import Data.Maybe        ( Maybe (..) )-import Data.Monoid       ( Monoid )-import Data.Ord          ( Ord, (>) )-import Data.Semigroup    ( Semigroup )-import GHC.Generics      ( Generic )-import Prelude           ( succ )-import Text.Show         ( Show, showString, showsPrec, showParen, showList )+import ASCII.Superset (CharSuperset, StringSuperset)+import Data.Bool (Bool (..))+import Data.Data (Data)+import Data.Eq (Eq)+import Data.Function (id, ($), (.))+import Data.Hashable (Hashable)+import Data.List (map)+import Data.Maybe (Maybe (..))+import Data.Monoid (Monoid)+import Data.Ord (Ord, (>))+import Data.Semigroup (Semigroup)+import GHC.Generics (Generic)+import Prelude (succ)+import Text.Show (Show, showList, showParen, showString, showsPrec)  {- | This type constructor indicates that a value from some ASCII superset is valid ASCII. The type parameter is the ASCII superset, which should be a type with an instance of either 'CharSuperset' or 'StringSuperset'.
library/ASCII/Superset.hs view
@@ -10,27 +10,27 @@      ) where -import Control.Monad      ( return )-import Control.Monad.Fail ( MonadFail (fail) )-import Data.Bool          ( Bool, (&&) )-import Data.Function      ( (.), id )-import Data.Functor       ( fmap )-import Data.Ord           ( (<=), (>=) )-import Data.Maybe         ( Maybe (..) )+import Control.Monad (return)+import Control.Monad.Fail (MonadFail (fail))+import Data.Bool (Bool, (&&))+import Data.Function (id, (.))+import Data.Functor (fmap)+import Data.Maybe (Maybe (..))+import Data.Ord ((<=), (>=)) -import qualified ASCII.Char               as  ASCII-import qualified Data.Bool                as  Bool-import qualified Data.ByteString          as  BS-import qualified Data.ByteString.Lazy     as  LBS-import qualified Data.ByteString.Builder  as  BSB-import qualified Data.Char                as  Unicode-import qualified Data.Int                 as  Int-import qualified Data.List                as  List-import qualified Data.Text                as  T-import qualified Data.Text.Lazy           as  LT-import qualified Data.Text.Lazy.Builder   as  TB-import qualified Data.Word                as  Word-import qualified Numeric.Natural          as  Nat+import qualified ASCII.Char as ASCII+import qualified Data.Bool as Bool+import qualified Data.ByteString as BS+import qualified Data.ByteString.Builder as BSB+import qualified Data.ByteString.Lazy as LBS+import qualified Data.Char as Unicode+import qualified Data.Int as Int+import qualified Data.List as List+import qualified Data.Text as T+import qualified Data.Text.Lazy as LT+import qualified Data.Text.Lazy.Builder as TB+import qualified Data.Word as Word+import qualified Numeric.Natural as Nat import qualified Prelude
+ test/Main.hs view
@@ -0,0 +1,57 @@+module Main (main) where++import ASCII.Refinement (ASCII, asciiUnsafe)++import qualified ASCII.Lift as Lift+import qualified ASCII.Refinement as Refinement++import ASCII.Char (Char (..))++import Control.Monad (Monad (..), when)+import Data.Bool (not)+import Data.Function (($))+import Data.Int (Int)+import Data.List (map)+import Data.Maybe (Maybe (..))+import Data.String (String)+import Data.Text (Text)+import Data.Word (Word8)+import System.Exit (exitFailure)+import System.IO (IO)++import Hedgehog (Property, checkParallel, discover, property, withTests, (===))++main :: IO ()+main = checkParallel $$(discover) >>= \ok -> when (not ok) exitFailure++prop_lift_letter :: Property+prop_lift_letter = withTests 1 $ property $+    (Lift.lift CapitalLetterA :: Word8) === 65++prop_lift_list :: Property+prop_lift_list = withTests 1 $ property $+    (Lift.lift [CapitalLetterH,SmallLetterI,ExclamationMark] :: Text) === "Hi!"++prop_validate_char :: Property+prop_validate_char = withTests 1 $ property $+    (map Refinement.validateChar [-1, 65, 97, 128] :: [Maybe (ASCII Int)]) === [Nothing, Just (asciiUnsafe 65), Just (asciiUnsafe 97), Nothing]++prop_from_char_list :: Property+prop_from_char_list = withTests 1 $ property $+    (Refinement.fromCharList [CapitalLetterH,SmallLetterI,ExclamationMark] :: ASCII Text) === asciiUnsafe "Hi!"++prop_to_char_list :: Property+prop_to_char_list = withTests 1 $ property $+    Refinement.toCharList (Refinement.substituteString "Piñata" :: ASCII Text) === [CapitalLetterP, SmallLetterI, Substitute, SmallLetterA, SmallLetterT, SmallLetterA]++prop_substitute_string :: Property+prop_substitute_string = withTests 1 $ property $+    (Refinement.substituteString "Cristóbal" :: ASCII Text) === asciiUnsafe "Crist\SUBbal"++prop_validate_text :: Property+prop_validate_text = withTests 1 $ property $+    (map Refinement.validateString ["Hello", "Cristóbal"] :: [Maybe (ASCII Text)]) === [Just (asciiUnsafe "Hello"), Nothing]++prop_validate_string :: Property+prop_validate_string = withTests 1 $ property $+    (map Refinement.validateString ["Hello", "Cristóbal"] :: [Maybe (ASCII String)]) === [Just (asciiUnsafe "Hello"), Nothing]
− test/test.hs 
@@ -1,65 +0,0 @@-module Main where--import ASCII.Refinement (ASCII, asciiUnsafe)--import qualified ASCII.Lift as Lift-import qualified ASCII.Refinement as Refinement--import ASCII.Char (Char (..))--import Control.Applicative (Applicative (..))-import Control.Monad (Monad (..))-import Data.Bool (Bool (..))-import Data.Eq (Eq ((==)))-import Data.Function ((.), ($))-import Data.Functor (Functor (..))-import Data.Int (Int)-import Data.List (intercalate, map, null)-import Data.Maybe (Maybe (..))-import Data.Semigroup ((<>))-import Data.String (String)-import Data.Text (Text)-import Data.Word (Word8)-import Numeric.Natural (Natural)-import System.Exit (die)-import System.IO (IO, putStrLn)-import Text.Show (show)--main :: IO ()-main = dieIfFailures $ do--    test 1 $ (Lift.lift CapitalLetterA :: Word8) == 65-    test 2 $ (Lift.lift [CapitalLetterH,SmallLetterI,ExclamationMark] :: Text) == "Hi!"--    test 3 $ (map Refinement.validateChar [-1, 65, 97, 128] :: [Maybe (ASCII Int)]) == [Nothing, Just (asciiUnsafe 65), Just (asciiUnsafe 97), Nothing]-    test 4 $ (Refinement.fromCharList [CapitalLetterH,SmallLetterI,ExclamationMark] :: ASCII Text) == asciiUnsafe "Hi!"-    test 5 $ Refinement.toCharList (Refinement.substituteString "Piñata" :: ASCII Text) == [CapitalLetterP, SmallLetterI, Substitute, SmallLetterA, SmallLetterT, SmallLetterA]-    test 6 $ (Refinement.substituteString "Cristóbal" :: ASCII Text) == asciiUnsafe "Crist\SUBbal"-    test 7 $ (map Refinement.validateString ["Hello", "Cristóbal"] :: [Maybe (ASCII Text)]) == [Just (asciiUnsafe "Hello"), Nothing]-    test 8 $ (map Refinement.validateString ["Hello", "Cristóbal"] :: [Maybe (ASCII String)]) == [Just (asciiUnsafe "Hello"), Nothing]--dieIfFailures :: Failures a -> IO a-dieIfFailures (Failures fs x) =-    if null fs-        then do putStrLn "💯"; return x-        else die $ intercalate " " (map (("🔥" <> ) . show) fs)--type TestNumber = Natural--test :: TestNumber -> Bool -> Failures ()-test n t = Failures (if t then [] else [n]) ()--data Failures a = Failures [TestNumber] a--instance Functor Failures-  where-    fmap f (Failures a x) = Failures a (f x)--instance Applicative Failures-  where-    pure x = Failures [] x-    Failures a f <*> Failures b x = Failures (a <> b) (f x)--instance Monad Failures-  where-    Failures a x >>= f = let Failures b y = f x in Failures (a <> b) y