unpacked-maybe-numeric 0.1.3.0 → 0.1.3.1
raw patch · 19 files changed
+716/−579 lines, 19 filesdep −primitivesetup-changednew-uploaderPVP: minor bump suggested
API additions: PVP suggests at least a minor version bump
Dependencies removed: primitive
API changes (from Hackage documentation)
+ Data.Maybe.Unpacked.Numeric.Int16: pattern Just :: Int16 -> Maybe
+ Data.Maybe.Unpacked.Numeric.Int16: pattern Nothing :: Maybe
+ Data.Maybe.Unpacked.Numeric.Int32: pattern Just :: Int32 -> Maybe
+ Data.Maybe.Unpacked.Numeric.Int32: pattern Nothing :: Maybe
+ Data.Maybe.Unpacked.Numeric.Int8: pattern Just :: Int8 -> Maybe
+ Data.Maybe.Unpacked.Numeric.Int8: pattern Nothing :: Maybe
+ Data.Maybe.Unpacked.Numeric.Word16: pattern Just :: Word16 -> Maybe
+ Data.Maybe.Unpacked.Numeric.Word16: pattern Nothing :: Maybe
+ Data.Maybe.Unpacked.Numeric.Word8: pattern Just :: Word8 -> Maybe
+ Data.Maybe.Unpacked.Numeric.Word8: pattern Nothing :: Maybe
Files
- CHANGELOG.md +10/−0
- Setup.hs +0/−2
- src/Data/Maybe/Unpacked/Numeric/Complex/Double.hs +37/−41
- src/Data/Maybe/Unpacked/Numeric/Complex/Float.hs +36/−40
- src/Data/Maybe/Unpacked/Numeric/Double.hs +36/−32
- src/Data/Maybe/Unpacked/Numeric/Float.hs +36/−32
- src/Data/Maybe/Unpacked/Numeric/Int.hs +36/−33
- src/Data/Maybe/Unpacked/Numeric/Int16.hs +60/−36
- src/Data/Maybe/Unpacked/Numeric/Int32.hs +59/−36
- src/Data/Maybe/Unpacked/Numeric/Int64.hs +36/−33
- src/Data/Maybe/Unpacked/Numeric/Int8.hs +58/−34
- src/Data/Maybe/Unpacked/Numeric/Word.hs +37/−34
- src/Data/Maybe/Unpacked/Numeric/Word128.hs +31/−35
- src/Data/Maybe/Unpacked/Numeric/Word16.hs +48/−31
- src/Data/Maybe/Unpacked/Numeric/Word32.hs +38/−34
- src/Data/Maybe/Unpacked/Numeric/Word64.hs +36/−33
- src/Data/Maybe/Unpacked/Numeric/Word8.hs +48/−31
- test/laws.hs +28/−24
- unpacked-maybe-numeric.cabal +46/−38
+ CHANGELOG.md view
@@ -0,0 +1,10 @@+# Changelog for unpacked-maybe-numeric++## 0.1.3.1 -- 2024-02-14++* Update package metadata.+* Fix failing test suite.++## 0.1.1.0 -- 2019-09-28++* Add module for `Word128`-variant of `Maybe`.
− Setup.hs
@@ -1,2 +0,0 @@-import Distribution.Simple-main = defaultMain
src/Data/Maybe/Unpacked/Numeric/Complex/Double.hs view
@@ -1,20 +1,14 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-}-{-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-} module Data.Maybe.Unpacked.Numeric.Complex.Double- ( Complex(..)+ ( Complex (..) , toBaseComplex , fromBaseComplex- - , Maybe(..)+ , Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -22,20 +16,19 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe- ) where - -import Prelude hiding (Maybe,maybe)+ ) where +import Prelude hiding (Maybe, maybe)+ import qualified Data.Complex as C import GHC.Base (build)-import GHC.Exts (Double#,Double(D#),(==##))+import GHC.Exts (Double (D#), Double#, (==##)) -import GHC.Read (Read(readPrec), expectP)-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec), expectP) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P data Complex = Complex Double# Double#@@ -44,20 +37,20 @@ toBaseComplex (Complex d1# d2#) = (D# d1#) C.:+ (D# d2#) fromBaseComplex :: C.Complex Double -> Complex-fromBaseComplex ( (D# d1#) C.:+ (D# d2#) ) = Complex d1# d2#+fromBaseComplex ((D# d1#) C.:+ (D# d2#)) = Complex d1# d2# instance Eq Complex where Complex a b == Complex c d = case a ==## c of 1# -> case b ==## d of 1# -> True- _ -> False- _ -> False+ _ -> False+ _ -> False instance Show Complex where- showsPrec p (Complex a b)- = showParen (p >= 11)- $ showString "Complex "+ showsPrec p (Complex a b) =+ showParen (p >= 11) $+ showString "Complex " . showsPrec 11 (D# a) . showString " " . showsPrec 11 (D# b)@@ -73,30 +66,33 @@ instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma- + maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma+ instance Show Maybe where showsPrec p (Maybe m) = case m of (# (# #) | #) -> showString "nothing"- (# | c #) -> showParen (p > 10)- $ showString "just "- . showsPrec 11 c+ (# | c #) ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 c instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Complex] -> Maybe listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Complex] maybeToList = maybe [] (: [])@@ -108,13 +104,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}@@ -148,4 +145,3 @@ fromBaseMaybe :: P.Maybe Complex -> Maybe fromBaseMaybe = P.maybe nothing just-
src/Data/Maybe/Unpacked/Numeric/Complex/Float.hs view
@@ -1,20 +1,14 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-}-{-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-} module Data.Maybe.Unpacked.Numeric.Complex.Float- ( Complex(..)+ ( Complex (..) , toBaseComplex , fromBaseComplex- - , Maybe(..)+ , Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -22,20 +16,19 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe- ) where + ) where -import Prelude hiding (Maybe,maybe)+import Prelude hiding (Maybe, maybe) import qualified Data.Complex as C import GHC.Base (build)-import GHC.Exts (Float#,Float(F#),eqFloat#)+import GHC.Exts (Float (F#), Float#, eqFloat#) -import GHC.Read (Read(readPrec), expectP)-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec), expectP) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P data Complex = Complex Float# Float#@@ -44,20 +37,20 @@ toBaseComplex (Complex d1# d2#) = (F# d1#) C.:+ (F# d2#) fromBaseComplex :: C.Complex Float -> Complex-fromBaseComplex ( (F# d1#) C.:+ (F# d2#) ) = Complex d1# d2#+fromBaseComplex ((F# d1#) C.:+ (F# d2#)) = Complex d1# d2# instance Eq Complex where Complex a b == Complex c d = case a `eqFloat#` c of 1# -> case b `eqFloat#` d of 1# -> True- _ -> False- _ -> False+ _ -> False+ _ -> False instance Show Complex where- showsPrec p (Complex a b)- = showParen (p >= 11)- $ showString "Complex "+ showsPrec p (Complex a b) =+ showParen (p >= 11) $+ showString "Complex " . showsPrec 11 (F# a) . showString " " . showsPrec 11 (F# b)@@ -73,30 +66,33 @@ instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma- + maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma+ instance Show Maybe where showsPrec p (Maybe m) = case m of (# (# #) | #) -> showString "nothing"- (# | c #) -> showParen (p > 10)- $ showString "just "- . showsPrec 11 c+ (# | c #) ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 c instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Complex] -> Maybe listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Complex] maybeToList = maybe [] (: [])@@ -108,13 +104,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}@@ -148,4 +145,3 @@ fromBaseMaybe :: P.Maybe Complex -> Maybe fromBaseMaybe = P.maybe nothing just-
src/Data/Maybe/Unpacked/Numeric/Double.hs view
@@ -1,16 +1,11 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-}-{-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-} module Data.Maybe.Unpacked.Numeric.Double- ( Maybe(..)+ ( Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -18,52 +13,60 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe- ) where + ) where -import Prelude hiding (Maybe,maybe)+import Prelude hiding (Maybe, maybe) import GHC.Base (build)-import GHC.Exts (Double#,Double(D#))+import GHC.Exts (Double (D#), Double#) -import GHC.Read (Read(readPrec))-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec)) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P data Maybe = Maybe (# (# #) | Double# #) instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma- + maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma+ instance Ord Maybe where- compare ma mb = maybe LT (\a -> maybe GT (compare a) mb) ma + compare (Maybe ma) (Maybe mb) = case ma of+ (# (# #) | #) -> case mb of+ (# (# #) | #) -> EQ+ (# | _ #) -> LT+ (# | a #) -> case mb of+ (# (# #) | #) -> GT+ (# | b #) -> compare (D# a) (D# b) instance Show Maybe where showsPrec p (Maybe m) = case m of (# (# #) | #) -> showString "nothing"- (# | d #) -> showParen (p > 10)- $ showString "just "- . showsPrec 11 (D# d)+ (# | d #) ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 (D# d) instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Double] -> Maybe listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Double] maybeToList = maybe [] (: [])@@ -75,13 +78,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}
src/Data/Maybe/Unpacked/Numeric/Float.hs view
@@ -1,16 +1,11 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-}-{-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-} module Data.Maybe.Unpacked.Numeric.Float- ( Maybe(..)+ ( Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -18,52 +13,60 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe- ) where + ) where -import Prelude hiding (Maybe,maybe)+import Prelude hiding (Maybe, maybe) import GHC.Base (build)-import GHC.Exts (Float#,Float(F#))+import GHC.Exts (Float (F#), Float#) -import GHC.Read (Read(readPrec))-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec)) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P data Maybe = Maybe (# (# #) | Float# #) instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma- + maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma+ instance Ord Maybe where- compare ma mb = maybe LT (\a -> maybe GT (compare a) mb) ma + compare (Maybe ma) (Maybe mb) = case ma of+ (# (# #) | #) -> case mb of+ (# (# #) | #) -> EQ+ (# | _ #) -> LT+ (# | a #) -> case mb of+ (# (# #) | #) -> GT+ (# | b #) -> compare (F# a) (F# b) instance Show Maybe where showsPrec p (Maybe m) = case m of (# (# #) | #) -> showString "nothing"- (# | d #) -> showParen (p > 10)- $ showString "just "- . showsPrec 11 (F# d)+ (# | d #) ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 (F# d) instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Float] -> Maybe listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Float] maybeToList = maybe [] (: [])@@ -75,13 +78,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}
src/Data/Maybe/Unpacked/Numeric/Int.hs view
@@ -1,16 +1,11 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-}-{-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-} module Data.Maybe.Unpacked.Numeric.Int- ( Maybe(..)+ ( Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -18,20 +13,19 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe- ) where + ) where -import Prelude hiding (Maybe,maybe)+import Prelude hiding (Maybe, maybe) import GHC.Base (build) import GHC.Exts (Int#)-import GHC.Int (Int(I#))+import GHC.Int (Int (I#)) -import GHC.Read (Read(readPrec))-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec)) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P @@ -39,33 +33,42 @@ instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma- + maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma+ instance Ord Maybe where- compare ma mb = maybe LT (\a -> maybe GT (compare a) mb) ma + compare (Maybe ma) (Maybe mb) = case ma of+ (# (# #) | #) -> case mb of+ (# (# #) | #) -> EQ+ (# | _ #) -> LT+ (# | a #) -> case mb of+ (# (# #) | #) -> GT+ (# | b #) -> compare (I# a) (I# b) instance Show Maybe where showsPrec p (Maybe m) = case m of (# (# #) | #) -> showString "nothing"- (# | i #) -> showParen (p > 10)- $ showString "just "- . showsPrec 11 (I# i)+ (# | i #) ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 (I# i) instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Int] -> Maybe listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Int] maybeToList = maybe [] (: [])@@ -77,13 +80,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}@@ -117,4 +121,3 @@ fromBaseMaybe :: P.Maybe Int -> Maybe fromBaseMaybe = P.maybe nothing just-
src/Data/Maybe/Unpacked/Numeric/Int16.hs view
@@ -1,17 +1,14 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-}+{-# LANGUAGE ViewPatterns #-} module Data.Maybe.Unpacked.Numeric.Int16- ( Maybe(..)+ ( Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -19,21 +16,23 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe- ) where - -import Prelude hiding (Maybe,maybe)+ -- * Patterns+ , pattern Nothing+ , pattern Just+ ) where +import Prelude hiding (Just, Maybe, Nothing, maybe)+ import GHC.Base (build)-import GHC.Exts (Int#, (>#), (<#))+import GHC.Exts (Int#, (<#), (>#)) import GHC.Int (Int16) import GHC.Int.Compat (pattern I16#) -import GHC.Read (Read(readPrec))-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec)) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P @@ -41,35 +40,46 @@ instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma- + maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma+ instance Ord Maybe where- compare ma mb = maybe LT (\a -> maybe GT (compare a) mb) ma + compare ma mb = case ma of+ Just a -> case mb of+ Just b -> compare a b+ _ -> GT+ _ -> case mb of+ Just{} -> LT+ _ -> EQ instance Show Maybe where showsPrec p m =- maybe (showString "nothing")- (\i -> showParen (p > 10)- $ showString "just "- . showsPrec 11 i- ) m+ maybe+ (showString "nothing")+ ( \i ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 i+ )+ m instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Int16] -> Maybe {-# INLINE listToMaybe #-} listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Int16] maybeToList m = maybe [] (: []) m@@ -81,13 +91,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}@@ -118,9 +129,9 @@ {-# INLINE maybe #-} maybe a f (M m) = case m ># 32767# of 1# -> a- _ -> case m <# -32768# of+ _ -> case m <# -32768# of 1# -> a- _ -> f (I16# m)+ _ -> f (I16# m) toBaseMaybe :: Maybe -> P.Maybe Int16 {-# INLINE toBaseMaybe #-}@@ -130,3 +141,16 @@ {-# INLINE fromBaseMaybe #-} fromBaseMaybe m = P.maybe nothing just m +pattern Nothing :: Maybe+pattern Nothing = M 32768#++pattern Just :: Int16 -> Maybe+pattern Just i <- (maybeInt16ToInt16 -> (# | i #))+ where+ Just (I16# i) = M i++maybeInt16ToInt16 :: Maybe -> (# (# #) | Int16 #)+{-# inline maybeInt16ToInt16 #-}+maybeInt16ToInt16 (M i) = case i of+ 32768# -> (# (# #) | #)+ _ -> (# | I16# i #)
src/Data/Maybe/Unpacked/Numeric/Int32.hs view
@@ -1,17 +1,14 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-}+{-# LANGUAGE ViewPatterns #-} module Data.Maybe.Unpacked.Numeric.Int32- ( Maybe(..)+ ( Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -19,20 +16,22 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe- ) where - -import Prelude hiding (Maybe,maybe)+ -- * Patterns+ , pattern Nothing+ , pattern Just+ ) where -import GHC.Exts +import Prelude hiding (Just, Maybe, Nothing, maybe)++import GHC.Exts import GHC.Int (Int32) import GHC.Int.Compat (pattern I32#) -import GHC.Read (Read(readPrec))-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec)) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P @@ -40,37 +39,47 @@ instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma+ maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma {-# INLINE (==) #-} instance Ord Maybe where- compare ma mb = maybe LT (\a -> maybe GT (compare a) mb) ma - {-# INLINE compare #-}+ compare ma mb = case ma of+ Just a -> case mb of+ Just b -> compare a b+ _ -> GT+ _ -> case mb of+ Just{} -> LT+ _ -> EQ instance Show Maybe where showsPrec p m =- maybe (showString "nothing")- (\i -> showParen (p > 10)- $ showString "just "- . showsPrec 11 i- ) m+ maybe+ (showString "nothing")+ ( \i ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 i+ )+ m instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Int32] -> Maybe {-# INLINE listToMaybe #-} listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Int32] maybeToList m = maybe [] (: []) m@@ -82,13 +91,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}@@ -119,9 +129,9 @@ {-# INLINE maybe #-} maybe a f (M m) = case m ># 2147483647# of 1# -> a- _ -> case m <# -2147483648# of+ _ -> case m <# -2147483648# of 1# -> a- _ -> f (I32# m)+ _ -> f (I32# m) toBaseMaybe :: Maybe -> P.Maybe Int32 {-# INLINE toBaseMaybe #-}@@ -131,3 +141,16 @@ {-# INLINE fromBaseMaybe #-} fromBaseMaybe m = P.maybe nothing just m +pattern Nothing :: Maybe+pattern Nothing = M 2147483648#++pattern Just :: Int32 -> Maybe+pattern Just i <- (maybeInt32ToInt32 -> (# | i #))+ where+ Just (I32# i) = M i++maybeInt32ToInt32 :: Maybe -> (# (# #) | Int32 #)+{-# inline maybeInt32ToInt32 #-}+maybeInt32ToInt32 (M i) = case i of+ 2147483648# -> (# (# #) | #)+ _ -> (# | I32# i #)
src/Data/Maybe/Unpacked/Numeric/Int64.hs view
@@ -1,16 +1,11 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-}-{-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-} module Data.Maybe.Unpacked.Numeric.Int64- ( Maybe(..)+ ( Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -18,20 +13,19 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe- ) where + ) where -import Prelude hiding (Maybe,maybe)+import Prelude hiding (Maybe, maybe) import GHC.Base (build) import GHC.Exts (Int64#)-import GHC.Int (Int64(I64#))+import GHC.Int (Int64 (I64#)) -import GHC.Read (Read(readPrec))-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec)) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P @@ -39,33 +33,42 @@ instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma- + maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma+ instance Ord Maybe where- compare ma mb = maybe LT (\a -> maybe GT (compare a) mb) ma + compare (Maybe ma) (Maybe mb) = case ma of+ (# (# #) | #) -> case mb of+ (# (# #) | #) -> EQ+ (# | _ #) -> LT+ (# | a #) -> case mb of+ (# (# #) | #) -> GT+ (# | b #) -> compare (I64# a) (I64# b) instance Show Maybe where showsPrec p (Maybe m) = case m of (# (# #) | #) -> showString "nothing"- (# | i #) -> showParen (p > 10)- $ showString "just "- . showsPrec 11 (I64# i)+ (# | i #) ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 (I64# i) instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Int64] -> Maybe listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Int64] maybeToList = maybe [] (: [])@@ -77,13 +80,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}@@ -117,4 +121,3 @@ fromBaseMaybe :: P.Maybe Int64 -> Maybe fromBaseMaybe = P.maybe nothing just-
src/Data/Maybe/Unpacked/Numeric/Int8.hs view
@@ -1,17 +1,14 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-}+{-# LANGUAGE ViewPatterns #-} module Data.Maybe.Unpacked.Numeric.Int8- ( Maybe(..)+ ( Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -19,20 +16,22 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe+ -- * Patterns+ , pattern Nothing+ , pattern Just ) where -import Prelude hiding (Maybe,maybe)+import Prelude hiding (Just, Maybe, Nothing, maybe) -import GHC.Exts +import GHC.Exts import GHC.Int (Int8) import GHC.Int.Compat (pattern I8#) -import GHC.Read (Read(readPrec))-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec)) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P @@ -40,35 +39,46 @@ instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma- + maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma+ instance Ord Maybe where- compare ma mb = maybe LT (\a -> maybe GT (compare a) mb) ma + compare ma mb = case ma of+ Just a -> case mb of+ Just b -> compare a b+ _ -> GT+ _ -> case mb of+ Just{} -> LT+ _ -> EQ instance Show Maybe where showsPrec p m =- maybe (showString "nothing")- (\i -> showParen (p > 10)- $ showString "just "- . showsPrec 11 i- ) m+ maybe+ (showString "nothing")+ ( \i ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 i+ )+ m instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Int8] -> Maybe {-# INLINE listToMaybe #-} listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Int8] maybeToList m = maybe [] (: []) m@@ -80,13 +90,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}@@ -117,9 +128,9 @@ {-# INLINE maybe #-} maybe a f (M m) = case m ># 127# of 1# -> a- _ -> case m <# -128# of+ _ -> case m <# -128# of 1# -> a- _ -> f (I8# m)+ _ -> f (I8# m) toBaseMaybe :: Maybe -> P.Maybe Int8 {-# INLINE toBaseMaybe #-}@@ -129,3 +140,16 @@ {-# INLINE fromBaseMaybe #-} fromBaseMaybe m = P.maybe nothing just m +pattern Nothing :: Maybe+pattern Nothing = M 128#++pattern Just :: Int8 -> Maybe+pattern Just i <- (maybeInt8ToInt8 -> (# | i #))+ where+ Just (I8# i) = M i++maybeInt8ToInt8 :: Maybe -> (# (# #) | Int8 #)+{-# inline maybeInt8ToInt8 #-}+maybeInt8ToInt8 (M i) = case i of+ 128# -> (# (# #) | #)+ _ -> (# | I8# i #)
src/Data/Maybe/Unpacked/Numeric/Word.hs view
@@ -1,16 +1,11 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-}-{-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-} module Data.Maybe.Unpacked.Numeric.Word- ( Maybe(..)+ ( Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -18,20 +13,19 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe- ) where - -import Prelude hiding (Maybe,maybe)+ ) where +import Prelude hiding (Maybe, maybe)+ import GHC.Base (build) import GHC.Exts (Word#)-import GHC.Word (Word(W#))+import GHC.Word (Word (W#)) -import GHC.Read (Read(readPrec))-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec)) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P @@ -39,33 +33,42 @@ instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma- + maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma+ instance Ord Maybe where- compare ma mb = maybe LT (\a -> maybe GT (compare a) mb) ma + compare (Maybe ma) (Maybe mb) = case ma of+ (# (# #) | #) -> case mb of+ (# (# #) | #) -> EQ+ (# | _ #) -> LT+ (# | a #) -> case mb of+ (# (# #) | #) -> GT+ (# | b #) -> compare (W# a) (W# b) instance Show Maybe where showsPrec p (Maybe m) = case m of (# (# #) | #) -> showString "nothing"- (# | w #) -> showParen (p > 10)- $ showString "just "- . showsPrec 11 (W# w)+ (# | w #) ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 (W# w) instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Word] -> Maybe listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Word] maybeToList = maybe [] (: [])@@ -77,13 +80,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}@@ -117,4 +121,3 @@ fromBaseMaybe :: P.Maybe Word -> Maybe fromBaseMaybe = P.maybe nothing just-
src/Data/Maybe/Unpacked/Numeric/Word128.hs view
@@ -1,16 +1,11 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-}-{-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-} module Data.Maybe.Unpacked.Numeric.Word128- ( Maybe(..)+ ( Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -18,21 +13,20 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe- ) where + ) where -import Prelude hiding (Maybe,maybe)+import Prelude hiding (Maybe, maybe) -import Data.WideWord (Word128(..))+import Data.WideWord (Word128 (..)) import GHC.Base (build) import GHC.Exts (Word64#)-import GHC.Word (Word64(W64#))+import GHC.Word (Word64 (W64#)) -import GHC.Read (Read(readPrec))-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec)) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P @@ -40,33 +34,36 @@ instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma- + maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma+ instance Ord Maybe where- compare ma mb = maybe LT (\a -> maybe GT (compare a) mb) ma + compare ma mb = maybe LT (\a -> maybe GT (compare a) mb) ma instance Show Maybe where showsPrec p (Maybe m) = case m of (# (# #) | #) -> showString "nothing"- (# | (# wa, wb #) #) -> showParen (p > 10)- $ showString "just "- . showsPrec 11 (Word128 (W64# wa) (W64# wb))+ (# | (# wa, wb #) #) ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 (Word128 (W64# wa) (W64# wb)) instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = prec 10 $ do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = prec 10 $ do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Word128] -> Maybe listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Word128] maybeToList = maybe [] (: [])@@ -78,13 +75,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}@@ -118,5 +116,3 @@ fromBaseMaybe :: P.Maybe Word128 -> Maybe fromBaseMaybe = P.maybe nothing just--
src/Data/Maybe/Unpacked/Numeric/Word16.hs view
@@ -1,17 +1,13 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-} {-# LANGUAGE PatternSynonyms #-}-{-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-}+{-# LANGUAGE ViewPatterns #-} module Data.Maybe.Unpacked.Numeric.Word16- ( Maybe(..)+ ( Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -19,21 +15,23 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe- ) where + -- * Patterns+ , pattern Nothing+ , pattern Just+ ) where -import Prelude hiding (Maybe,maybe)+import Prelude hiding (Just, Maybe, Nothing, maybe) import GHC.Base (build) import GHC.Exts (Word#) import GHC.Word (Word16) import GHC.Word.Compat (pattern W16#) -import GHC.Read (Read(readPrec))-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec)) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P @@ -41,33 +39,42 @@ instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma- + maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma+ instance Ord Maybe where- compare ma mb = maybe LT (\a -> maybe GT (compare a) mb) ma + compare ma mb = case ma of+ Just a -> case mb of+ Just b -> compare a b+ _ -> GT+ _ -> case mb of+ Just{} -> LT+ _ -> EQ instance Show Maybe where showsPrec p (Maybe m) = case m of (# (# #) | #) -> showString "nothing"- (# | w #) -> showParen (p > 10)- $ showString "just "- . showsPrec 11 (W16# w)+ (# | w #) ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 (W16# w) instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Word16] -> Maybe listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Word16] maybeToList = maybe [] (: [])@@ -79,13 +86,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}@@ -120,3 +128,12 @@ fromBaseMaybe :: P.Maybe Word16 -> Maybe fromBaseMaybe = P.maybe nothing just +pattern Nothing :: Maybe+pattern Nothing = Maybe (# (# #) | #)++pattern Just :: Word16 -> Maybe+pattern Just i <- Maybe (# | (W16# -> i) #)+ where+ Just (W16# i) = Maybe (# | i #)++{-# COMPLETE Nothing, Just #-}
src/Data/Maybe/Unpacked/Numeric/Word32.hs view
@@ -1,18 +1,13 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-} {-# LANGUAGE PatternSynonyms #-}-{-# LANGUAGE ViewPatterns #-}-{-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-}+{-# LANGUAGE ViewPatterns #-} module Data.Maybe.Unpacked.Numeric.Word32- ( Maybe(..)+ ( Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -20,25 +15,24 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe -- * Patterns , pattern Nothing , pattern Just- ) where + ) where -import Prelude hiding (Maybe,Nothing,Just,maybe)+import Prelude hiding (Just, Maybe, Nothing, maybe) import GHC.Base (build) import GHC.Exts (Word#) import GHC.Word (Word32) import GHC.Word.Compat (pattern W32#) -import GHC.Read (Read(readPrec))-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec)) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P @@ -49,39 +43,49 @@ pattern Just :: Word32 -> Maybe pattern Just i <- Maybe (# | (W32# -> i) #)- where Just (W32# i) = Maybe (# | i #)+ where+ Just (W32# i) = Maybe (# | i #) {-# COMPLETE Nothing, Just #-} instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma- + maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma+ instance Ord Maybe where- compare ma mb = maybe LT (\a -> maybe GT (compare a) mb) ma + compare ma mb = case ma of+ Just a -> case mb of+ Just b -> compare a b+ _ -> GT+ _ -> case mb of+ Just{} -> LT+ _ -> EQ instance Show Maybe where showsPrec p (Maybe m) = case m of (# (# #) | #) -> showString "nothing"- (# | w #) -> showParen (p > 10)- $ showString "just "- . showsPrec 11 (W32# w)+ (# | w #) ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 (W32# w) instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Word32] -> Maybe listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Word32] maybeToList = maybe [] (: [])@@ -93,13 +97,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}@@ -133,4 +138,3 @@ fromBaseMaybe :: P.Maybe Word32 -> Maybe fromBaseMaybe = P.maybe nothing just-
src/Data/Maybe/Unpacked/Numeric/Word64.hs view
@@ -1,16 +1,11 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-}-{-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-} module Data.Maybe.Unpacked.Numeric.Word64- ( Maybe(..)+ ( Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -18,20 +13,19 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe- ) where + ) where -import Prelude hiding (Maybe,maybe)+import Prelude hiding (Maybe, maybe) import GHC.Base (build) import GHC.Exts (Word64#)-import GHC.Word (Word64(W64#))+import GHC.Word (Word64 (W64#)) -import GHC.Read (Read(readPrec))-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec)) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P @@ -39,33 +33,42 @@ instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma- + maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma+ instance Ord Maybe where- compare ma mb = maybe LT (\a -> maybe GT (compare a) mb) ma + compare (Maybe ma) (Maybe mb) = case ma of+ (# (# #) | #) -> case mb of+ (# (# #) | #) -> EQ+ (# | _ #) -> LT+ (# | a #) -> case mb of+ (# (# #) | #) -> GT+ (# | b #) -> compare (W64# a) (W64# b) instance Show Maybe where showsPrec p (Maybe m) = case m of (# (# #) | #) -> showString "nothing"- (# | w #) -> showParen (p > 10)- $ showString "just "- . showsPrec 11 (W64# w)+ (# | w #) ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 (W64# w) instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Word64] -> Maybe listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Word64] maybeToList = maybe [] (: [])@@ -77,13 +80,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}@@ -117,4 +121,3 @@ fromBaseMaybe :: P.Maybe Word64 -> Maybe fromBaseMaybe = P.maybe nothing just-
src/Data/Maybe/Unpacked/Numeric/Word8.hs view
@@ -1,17 +1,13 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-} {-# LANGUAGE MagicHash #-} {-# LANGUAGE PatternSynonyms #-}-{-# LANGUAGE UnboxedSums #-} {-# LANGUAGE UnboxedTuples #-}+{-# LANGUAGE ViewPatterns #-} module Data.Maybe.Unpacked.Numeric.Word8- ( Maybe(..)+ ( Maybe (..) , just , nothing- , maybe- , isJust , isNothing , fromMaybe@@ -19,21 +15,23 @@ , maybeToList , catMaybes , mapMaybe- , toBaseMaybe , fromBaseMaybe- ) where + -- * Patterns+ , pattern Nothing+ , pattern Just+ ) where -import Prelude hiding (Maybe,maybe)+import Prelude hiding (Just, Maybe, Nothing, maybe) import GHC.Base (build) import GHC.Exts (Word#) import GHC.Word (Word8) import GHC.Word.Compat (pattern W8#) -import GHC.Read (Read(readPrec))-import Text.Read (parens, Lexeme(Ident), lexP, (+++))+import GHC.Read (Read (readPrec)) import Text.ParserCombinators.ReadPrec (prec, step)+import Text.Read (Lexeme (Ident), lexP, parens, (+++)) import qualified Prelude as P @@ -41,33 +39,42 @@ instance Eq Maybe where ma == mb =- maybe (isNothing mb)- (\a -> maybe False (\b -> a == b) mb) ma- + maybe+ (isNothing mb)+ (\a -> maybe False (\b -> a == b) mb)+ ma+ instance Ord Maybe where- compare ma mb = maybe LT (\a -> maybe GT (compare a) mb) ma + compare ma mb = case ma of+ Just a -> case mb of+ Just b -> compare a b+ _ -> GT+ _ -> case mb of+ Just{} -> LT+ _ -> EQ instance Show Maybe where showsPrec p (Maybe m) = case m of (# (# #) | #) -> showString "nothing"- (# | w #) -> showParen (p > 10)- $ showString "just "- . showsPrec 11 (W8# w)+ (# | w #) ->+ showParen (p > 10) $+ showString "just "+ . showsPrec 11 (W8# w) instance Read Maybe where readPrec = parens $ nothingP +++ justP- where- nothingP = do- Ident "nothing" <- lexP- return nothing- justP = prec 10 $ do- Ident "just" <- lexP- a <- step readPrec- return (just a)+ where+ nothingP = do+ Ident "nothing" <- lexP+ return nothing+ justP = prec 10 $ do+ Ident "just" <- lexP+ a <- step readPrec+ return (just a) listToMaybe :: [Word8] -> Maybe listToMaybe [] = nothing-listToMaybe (x:_) = just x+listToMaybe (x : _) = just x maybeToList :: Maybe -> [Word8] maybeToList = maybe [] (: [])@@ -79,13 +86,14 @@ mapMaybe _ [] = [] mapMaybe f (a : as) = let ws = mapMaybe f as- in maybe ws (: ws) (f a)+ in maybe ws (: ws) (f a) {-# NOINLINE [1] mapMaybe #-} {-# RULES-"mapMaybe" [~1] forall f xs. mapMaybe f xs- = build (\c n -> foldr (mapMaybeFB c f) n xs)-"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f+"mapMaybe" [~1] forall f xs.+ mapMaybe f xs =+ build (\c n -> foldr (mapMaybeFB c f) n xs)+"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-} {-# NOINLINE [0] mapMaybeFB #-}@@ -120,3 +128,12 @@ fromBaseMaybe :: P.Maybe Word8 -> Maybe fromBaseMaybe = P.maybe nothing just +pattern Nothing :: Maybe+pattern Nothing = Maybe (# (# #) | #)++pattern Just :: Word8 -> Maybe+pattern Just i <- Maybe (# | (W8# -> i) #)+ where+ Just (W8# i) = Maybe (# | i #)++{-# COMPLETE Nothing, Just #-}
test/laws.hs view
@@ -1,29 +1,29 @@-{-# LANGUAGE MagicHash #-}-{-# LANGUAGE TypeApplications #-}+{-# LANGUAGE MagicHash #-}+{-# OPTIONS_GHC -Wno-orphans #-} -import Test.QuickCheck.Arbitrary-import Test.QuickCheck.Gen-import Test.QuickCheck.Classes import Data.Proxy (Proxy (Proxy)) import GHC.Exts+import Test.QuickCheck.Arbitrary+import Test.QuickCheck.Classes+import Test.QuickCheck.Gen -import qualified Data.Maybe.Unpacked.Numeric.Complex.Float as MComplexFloat import qualified Data.Maybe.Unpacked.Numeric.Complex.Double as MComplexDouble+import qualified Data.Maybe.Unpacked.Numeric.Complex.Float as MComplexFloat -import qualified Data.Maybe.Unpacked.Numeric.Float as MFloat import qualified Data.Maybe.Unpacked.Numeric.Double as MDouble+import qualified Data.Maybe.Unpacked.Numeric.Float as MFloat -import qualified Data.Maybe.Unpacked.Numeric.Int as MInt-import qualified Data.Maybe.Unpacked.Numeric.Int8 as MInt8-import qualified Data.Maybe.Unpacked.Numeric.Int16 as MInt16-import qualified Data.Maybe.Unpacked.Numeric.Int32 as MInt32-import qualified Data.Maybe.Unpacked.Numeric.Int64 as MInt64+import qualified Data.Maybe.Unpacked.Numeric.Int as MInt+import qualified Data.Maybe.Unpacked.Numeric.Int16 as MInt16+import qualified Data.Maybe.Unpacked.Numeric.Int32 as MInt32+import qualified Data.Maybe.Unpacked.Numeric.Int64 as MInt64+import qualified Data.Maybe.Unpacked.Numeric.Int8 as MInt8 -import qualified Data.Maybe.Unpacked.Numeric.Word as MWord-import qualified Data.Maybe.Unpacked.Numeric.Word8 as MWord8+import qualified Data.Maybe.Unpacked.Numeric.Word as MWord import qualified Data.Maybe.Unpacked.Numeric.Word16 as MWord16 import qualified Data.Maybe.Unpacked.Numeric.Word32 as MWord32 import qualified Data.Maybe.Unpacked.Numeric.Word64 as MWord64+import qualified Data.Maybe.Unpacked.Numeric.Word8 as MWord8 main :: IO () main = lawsCheckMany allPropsApplied@@ -34,17 +34,21 @@ , Ord a , Show a , Read a- ) => Proxy a -> [Laws]-allLaws p = map ($ p)- [ eqLaws, ordLaws, showReadLaws- ]-+ ) =>+ Proxy a ->+ [Laws]+allLaws p =+ map+ ($ p)+ [ eqLaws+ , ordLaws+ , showReadLaws+ ] allPropsApplied :: [(String, [Laws])] allPropsApplied = [ ("Maybe (Complex Float)", map ($ (Proxy :: Proxy MComplexFloat.Maybe)) [eqLaws, showReadLaws]) , ("Maybe (Complex Double)", map ($ (Proxy :: Proxy MComplexDouble.Maybe)) [eqLaws, showReadLaws])- , ("Maybe Float", allLaws (Proxy :: Proxy MFloat.Maybe)) , ("Maybe Double", allLaws (Proxy :: Proxy MDouble.Maybe)) , ("Maybe Int8", allLaws (Proxy :: Proxy MInt8.Maybe))@@ -78,16 +82,16 @@ pure (MComplexDouble.Complex (unDouble x) (unDouble y)) instance Arbitrary MComplexFloat.Maybe where- arbitrary = frequency [(1,pure MComplexFloat.nothing), (1, MComplexFloat.just <$> arbitrary)]+ arbitrary = frequency [(1, pure MComplexFloat.nothing), (1, MComplexFloat.just <$> arbitrary)] instance Arbitrary MComplexDouble.Maybe where- arbitrary = frequency [(1,pure MComplexDouble.nothing), (1, MComplexDouble.just <$> arbitrary)]+ arbitrary = frequency [(1, pure MComplexDouble.nothing), (1, MComplexDouble.just <$> arbitrary)] instance Arbitrary MFloat.Maybe where- arbitrary = frequency [(1,pure MFloat.nothing), (1, MFloat.just <$> arbitrary)]+ arbitrary = frequency [(1, pure MFloat.nothing), (1, MFloat.just <$> arbitrary)] instance Arbitrary MDouble.Maybe where- arbitrary = frequency [(1,pure MDouble.nothing), (1, MDouble.just <$> arbitrary)]+ arbitrary = frequency [(1, pure MDouble.nothing), (1, MDouble.just <$> arbitrary)] instance Arbitrary MWord8.Maybe where arbitrary = frequency [(1, pure MWord8.nothing), (1, MWord8.just <$> arbitrary)]
unpacked-maybe-numeric.cabal view
@@ -1,7 +1,7 @@-cabal-version: 2.2-name: unpacked-maybe-numeric-version: 0.1.3.0-synopsis: maybes of numeric values with fewer indirections+cabal-version: 3.0+name: unpacked-maybe-numeric+version: 0.1.3.1+synopsis: maybes of numeric values with fewer indirections description: This library provides one `Maybe` type per the usual numeric types: Float, Double, Complex {Float|Double}, Int{8|16|32|64}, and Word{8|16|32|64|128}@@ -11,65 +11,73 @@ the `Maybe` is just a wrapper around the underlying type, with out-of-bounds corresponding to the `Nothing` value. Thus, the use of these constructors is unsafe, as this is only checked internally.-homepage: https://github.com/andrewthad/unpacked-maybe-numeric#readme-bug-reports: https://github.com/andrewthad/unpacked-maybe-numeric/issues-author: Andrew Martin, chessai-maintainer: andrew.thaddeus@gmail.com, chessai1996@gmail.com-category: Data-copyright: 2018 Andrew Martin-license: BSD-3-Clause-license-file: LICENSE-build-type: Simple-extra-source-files: README.md -source-repository head- type: git- location: https://github.com/andrewthad/unpacked-maybe-numeric+homepage: https://github.com/byteverse/unpacked-maybe-numeric+bug-reports: https://github.com/byteverse/unpacked-maybe-numeric/issues+author: Andrew Martin, chessai+maintainer: amartin@layer3com.com, chessai1996@gmail.com+category: Data+copyright: 2018 Andrew Martin+license: BSD-3-Clause+license-file: LICENSE+build-type: Simple+extra-doc-files:+ CHANGELOG.md+ README.md +tested-with: GHC ==9.4.8 || ==9.6.3 || ==9.8.1++common build-settings+ default-language: Haskell2010+ ghc-options: -Wall -Wunused-packages+ library+ import: build-settings exposed-modules:- Data.Maybe.Unpacked.Numeric.Complex.Float Data.Maybe.Unpacked.Numeric.Complex.Double- Data.Maybe.Unpacked.Numeric.Float+ Data.Maybe.Unpacked.Numeric.Complex.Float Data.Maybe.Unpacked.Numeric.Double+ Data.Maybe.Unpacked.Numeric.Float Data.Maybe.Unpacked.Numeric.Int- Data.Maybe.Unpacked.Numeric.Int8 Data.Maybe.Unpacked.Numeric.Int16 Data.Maybe.Unpacked.Numeric.Int32 Data.Maybe.Unpacked.Numeric.Int64+ Data.Maybe.Unpacked.Numeric.Int8 Data.Maybe.Unpacked.Numeric.Word- Data.Maybe.Unpacked.Numeric.Word8+ Data.Maybe.Unpacked.Numeric.Word128 Data.Maybe.Unpacked.Numeric.Word16 Data.Maybe.Unpacked.Numeric.Word32 Data.Maybe.Unpacked.Numeric.Word64- Data.Maybe.Unpacked.Numeric.Word128- hs-source-dirs: src+ Data.Maybe.Unpacked.Numeric.Word8++ hs-source-dirs: src build-depends:- , base >=4.17.1.0 && <5- , primitive >= 0.6.4- , wide-word >= 0.1.0.8 && < 0.2- , word-compat >= 0.0.4 && <0.1- ghc-options: -Wall -O2- default-language: Haskell2010+ , base >=4.17.1.0 && <5+ , wide-word >=0.1.0.8 && <0.2+ , word-compat >=0.0.4 && <0.1 + ghc-options: -O2+ test-suite spec- default-language: Haskell2010- ghc-options: -Wall- type: exitcode-stdio-1.0- main-is: spec.hs+ import: build-settings+ type: exitcode-stdio-1.0+ main-is: spec.hs hs-source-dirs: test build-depends: , base , unpacked-maybe-numeric test-suite laws- default-language: Haskell2010- ghc-options: -Wall- type: exitcode-stdio-1.0- main-is: laws.hs+ import: build-settings+ type: exitcode-stdio-1.0+ main-is: laws.hs hs-source-dirs: test build-depends:- , QuickCheck , base+ , QuickCheck , quickcheck-classes , unpacked-maybe-numeric++source-repository head+ type: git+ location: git://github.com/byteverse/unpacked-maybe-numeric.git