#12001: RFC: Add pattern synonyms to base -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: libraries/base | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): Some random ideas, === Data.Functor.Const === {{{#!hs pattern K :: forall a (b :: k). a -> Const a b pattern K a = Const a pattern K' :: forall a (b :: k). a -> Constant a b pattern K' a = Constant a }}} === GHC.Generics === {{{#!hs isAssociative :: Associativity -> Bool isAssociative LeftAssociative = True isAssociative RightAssociative = True isAssociative NotAssociative = False pattern Associative :: Associative pattern Associative <- (isAssociative -> True) }}} === Data.Ratio === {{{#!hs pattern Denominator :: a -> Ratio a pattern Denominator a <- (denominator -> a) pattern Numerator :: a -> Ratio a pattern Numerator a <- (numerator -> a) pattern (:%) :: Integral a => a -> a -> Ratio a pattern num :% den <- ((\r -> (numerator r, denominator r)) -> (num, den)) where num :% den = num % den }}} === System.Exit === {{{#!hs exitCode :: ExitCode -> Int exitCode = \case ExitSuccess -> 0 ExitFailure n -> n pattern ExitCode :: Int -> ExitCode pattern ExitCode n <- (exitCode -> n) where ExitCode 0 = ExitSuccess ExitCode n = ExitFailure n }}} === Data.Maybe === {{{#!hs pattern Some :: a -> Maybe a pattern Some a = Just a pattern None :: a -> Maybe a pattern None = Nothing }}} === Data.Functor.Identity === {{{#!hs pattern I :: a -> Identity pattern I a = Identity a }}} === Data.Ord === {{{#!hs pattern :: Ordering pattern Less = LT pattern :: Ordering pattern Equal = EQ pattern :: Ordering pattern Greater = GT }}} === Data.Foldable === {{{#!hs pattern Null :: Foldable f => f a pattern Null <- (null -> True) }}} === Data.Bool === {{{#!hs pattern T :: Bool pattern T = True pattern F :: Bool pattern F = False }}} It's fine if these don't get accepted, just throwing them into the universe -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12001#comment:2 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12001: RFC: Add pattern synonyms to base -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: libraries/base | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by ekmett): I'm pretty much in the same camp as Joachim: The only one of these that I think really passes muster as a pattern that models a constructor is `Polar`. It doesn't destroy information when you pattern match with it and then reconstruct. (It does, however, destroy the phase information if the magnitude is 0 if you construct then deconstruct). The rest seem all better managed as view patterns, using existing combinators so that their lossy nature is much more clear. It is worthy of discussion to explore whether we're ready to start incorporating patterns into the bulk of `base`, but I personally think I'd like to see them endure a couple of releases without the sorts of major overhauls they have going on with how to put signatures on them, etc. before they started taking a more prominent role in a place where they'd be as hard to dislodge as `base`. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12001#comment:4 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12001: RFC: Add pattern synonyms to base -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: libraries/base | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): Since `Polar` was the pick of the litter, it's worth mentioning that with record syntax: {{{#!hs pattern Polar :: RealFloat a => a -> a -> Complex a pattern Polar {m, theta} <- (polar -> (m, theta)) where Polar m theta = mkPolar m theta }}} we can write {{{ ghci> (3 :+ 1) { m = 2 } 1.8973665961010275 :+ 0.6324555320336759 ghci> ghci> set (_polar._1) 2 (3 :+ 1) 1.8973665961010275 :+ 0.6324555320336759 }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12001#comment:6 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12001: RFC: Add pattern synonyms to base -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: libraries/base | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): Not sure if makes sense === Control.DeepSeq === {{{#!hs pattern Force :: NFData a => a -> a pattern Force a <- !(force -> a) }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12001#comment:8 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12001: RFC: Add pattern synonyms to base -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: libraries/base | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): See #12767: {{{#!hs pattern Cont :: ((a -> r) -> r) -> Cont r a pattern Cont a <- (runCont -> a) where Cont a = cont a pattern Writer :: (a, w) -> Writer w a pattern Writer a <- (runWriter -> a) where Writer a = WriterT (Identity a) pattern Reader :: (r -> a) -> Reader r a pattern Reader a <- (runReader -> a) where Reader a = reader a pattern State :: (s -> (a, s)) -> State s a pattern State a <- (runState -> a) where State a = state a }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12001#comment:10 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12001: RFC: Add pattern synonyms to base -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: libraries/base | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Description changed by Iceland_jack: Old description:

Since we have pattern synonyms it's worth considering if some belong in base:

[https://hackage.haskell.org/package/lens-4.14/docs/Data-Complex- Lens.html Data.Complex.Lens] contains patterns that could be defined in base, here are some more suggestions:

=== Data.Array === {{{#!hs pattern ArrayIx :: Ix i => (i, i) -> [(i, e)] -> Array i e pattern ArrayIx low'high xs <- ((\arr -> (bounds arr, assocs arr)) -> (low'high, xs)) where ArrayIx low'high xs = array low'high xs }}}

=== Data.Bits === {{{#!hs pattern ZeroBits :: (Eq a, Bits a) => a pattern ZeroBits <- ((== zeroBits) -> True) where ZeroBits = zeroBits

pattern BitSize :: Bits a => Int -> a pattern BitSize n <- (bitSizeMaybe -> Just n)

pattern Signed :: Bits a => a pattern Signed <- (isSigned -> True)

pattern Unsigned :: Bits a => a pattern Unsigned <- (isSigned -> False)

pattern PopCount :: Bits a => Int -> a pattern PopCount n <- (popCount -> n) }}}

=== Data.Char === {{{#!hs pattern ControlChar :: Char pattern ControlChar <- (isControl -> True)

pattern SpaceChar :: Char pattern SpaceChar <- (isSpace -> True) }}}

=== Data.Complex === {{{#!hs import Data.Complex (Complex, conjugate, polar, mkPolar) import qualified Data.Complex as C

pattern Conjugate :: Num a => Complex a -> Complex a pattern Conjugate a <- (conjugate -> a) where Conjugate a = conjugate a

pattern Polar :: RealFloat a => a -> a -> Complex a pattern Polar m theta <- (polar -> (m, theta)) where Polar m theta = mkPolar m theta

-- See https://github.com/ekmett/lens/issues/653 pattern Real :: Num a => a -> Complex a pattern Real r <- r C.:+ _ where Real r = r C.:+ 0

pattern Imaginary :: Num a => a -> Complex a pattern Imaginary i <- _ C.:+ i where Imaginary i = 0 C.:+ i

pattern (:+) :: a -> a -> Complex a pattern (:+) { realPart, imagPart } = realPart C.:+ imagPart }}}

=== GHC.Float === {{{#!hs pattern NegativeZero :: RealFloat a => a pattern NegativeZero <- (isNegativeZero -> True) where NegativeZero = -0

pattern Denormalized :: RealFloat a => a pattern Denormalized <- (isDenormalized -> True)

pattern NaN :: RealFloat a => a pattern NaN <- (isNaN -> True) where NaN = 0 / 0

-- How ever negative infinity is handled pattern Infinity :: RealFloat a => a pattern Infinity <- ((== 1 / 0) -> True) where Infinity = 1 / 0 }}}

New description: Since we have pattern synonyms it's worth considering if some belong in base: [https://hackage.haskell.org/package/lens-4.14/docs/Data-Complex-Lens.html Data.Complex.Lens] contains patterns that could be defined in base, here are some more suggestions: === Data.Array === {{{#!hs pattern ArrayIx :: Ix i => (i, i) -> [(i, e)] -> Array i e pattern ArrayIx low'high xs <- ((\arr -> (bounds arr, assocs arr)) -> (low'high, xs)) where ArrayIx low'high xs = array low'high xs }}} === Data.Bits === {{{#!hs pattern ZeroBits :: (Eq a, Bits a) => a pattern ZeroBits <- ((== zeroBits) -> True) where ZeroBits = zeroBits pattern BitSize :: Bits a => Int -> a pattern BitSize n <- (bitSizeMaybe -> Just n) pattern Signed :: Bits a => a pattern Signed <- (isSigned -> True) pattern Unsigned :: Bits a => a pattern Unsigned <- (isSigned -> False) pattern PopCount :: Bits a => Int -> a pattern PopCount n <- (popCount -> n) }}} === Data.Char === {{{#!hs pattern ControlChar :: Char pattern ControlChar <- (isControl -> True) pattern SpaceChar :: Char pattern SpaceChar <- (isSpace -> True) }}} === Data.Complex === {{{#!hs import Data.Complex (Complex, conjugate, polar, mkPolar) import qualified Data.Complex as C pattern Conjugate :: Num a => Complex a -> Complex a pattern Conjugate a <- (conjugate -> a) where Conjugate a = conjugate a pattern Polar :: RealFloat a => a -> a -> Complex a pattern Polar m theta <- (polar -> (m, theta)) where Polar m theta = mkPolar m theta -- See https://github.com/ekmett/lens/issues/653 pattern Real :: Num a => a -> Complex a pattern Real r <- r C.:+ _ where Real r = r C.:+ 0 pattern Imaginary :: Num a => a -> Complex a pattern Imaginary i <- _ C.:+ i where Imaginary i = 0 C.:+ i pattern (:+) :: a -> a -> Complex a pattern (:+) { realPart, imagPart } = realPart C.:+ imagPart }}} === GHC.Float === {{{#!hs pattern NegativeZero :: RealFloat a => a pattern NegativeZero <- (isNegativeZero -> True) where NegativeZero = -0 pattern Denormalized :: RealFloat a => a pattern Denormalized <- (isDenormalized -> True) pattern NaN :: RealFloat a => a pattern NaN <- (isNaN -> True) where NaN = 0 / 0 -- How ever negative infinity is handled pattern Infinity :: RealFloat a => a pattern Infinity <- (isInfinite -> True) where Infinity = 1 / 0 }}} Used [https://github.com/cchalmers/optical/blob/a85484ad23a7f4d6b5da1dcb78781ea9c4... here] -- -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12001#comment:14 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12001: RFC: Add pattern synonyms to base -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: libraries/base | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Description changed by Iceland_jack: Old description:

Since we have pattern synonyms it's worth considering if some belong in base:

[https://hackage.haskell.org/package/lens-4.14/docs/Data-Complex- Lens.html Data.Complex.Lens] contains patterns that could be defined in base, here are some more suggestions:

=== Data.Array === {{{#!hs pattern ArrayIx :: Ix i => (i, i) -> [(i, e)] -> Array i e pattern ArrayIx low'high xs <- ((\arr -> (bounds arr, assocs arr)) -> (low'high, xs)) where ArrayIx low'high xs = array low'high xs }}}

=== Data.Bits === {{{#!hs pattern ZeroBits :: (Eq a, Bits a) => a pattern ZeroBits <- ((== zeroBits) -> True) where ZeroBits = zeroBits

pattern BitSize :: Bits a => Int -> a pattern BitSize n <- (bitSizeMaybe -> Just n)

pattern Signed :: Bits a => a pattern Signed <- (isSigned -> True)

pattern Unsigned :: Bits a => a pattern Unsigned <- (isSigned -> False)

pattern PopCount :: Bits a => Int -> a pattern PopCount n <- (popCount -> n) }}}

=== Data.Char === {{{#!hs pattern ControlChar :: Char pattern ControlChar <- (isControl -> True)

pattern SpaceChar :: Char pattern SpaceChar <- (isSpace -> True) }}}

=== Data.Complex === {{{#!hs import Data.Complex (Complex, conjugate, polar, mkPolar) import qualified Data.Complex as C

pattern Conjugate :: Num a => Complex a -> Complex a pattern Conjugate a <- (conjugate -> a) where Conjugate a = conjugate a

pattern Polar :: RealFloat a => a -> a -> Complex a pattern Polar m theta <- (polar -> (m, theta)) where Polar m theta = mkPolar m theta

-- See https://github.com/ekmett/lens/issues/653 pattern Real :: Num a => a -> Complex a pattern Real r <- r C.:+ _ where Real r = r C.:+ 0

pattern Imaginary :: Num a => a -> Complex a pattern Imaginary i <- _ C.:+ i where Imaginary i = 0 C.:+ i

pattern (:+) :: a -> a -> Complex a pattern (:+) { realPart, imagPart } = realPart C.:+ imagPart }}}

=== GHC.Float === {{{#!hs pattern NegativeZero :: RealFloat a => a pattern NegativeZero <- (isNegativeZero -> True) where NegativeZero = -0

pattern Denormalized :: RealFloat a => a pattern Denormalized <- (isDenormalized -> True)

pattern NaN :: RealFloat a => a pattern NaN <- (isNaN -> True) where NaN = 0 / 0

-- How ever negative infinity is handled pattern Infinity :: RealFloat a => a pattern Infinity <- (isInfinite -> True) where Infinity = 1 / 0

=== Foreign.Ptr === {{{#!hs pattern NullPtr :: Ptr a pattern NullPtr <- ((==) nullPtr -> True) where NullPtr = nullPtr }}}

Used [https://github.com/cchalmers/optical/blob/a85484ad23a7f4d6b5da1dcb78781ea9c4... here]

New description: Since we have pattern synonyms it's worth considering if some belong in base: [https://hackage.haskell.org/package/lens-4.14/docs/Data-Complex-Lens.html Data.Complex.Lens] contains patterns that could be defined in base, here are some more suggestions: === Data.Array === {{{#!hs pattern ArrayIx :: Ix i => (i, i) -> [(i, e)] -> Array i e pattern ArrayIx low'high xs <- ((\arr -> (bounds arr, assocs arr)) -> (low'high, xs)) where ArrayIx low'high xs = array low'high xs }}} === Data.Bits === {{{#!hs pattern ZeroBits :: (Eq a, Bits a) => a pattern ZeroBits <- ((== zeroBits) -> True) where ZeroBits = zeroBits pattern BitSize :: Bits a => Int -> a pattern BitSize n <- (bitSizeMaybe -> Just n) pattern Signed :: Bits a => a pattern Signed <- (isSigned -> True) pattern Unsigned :: Bits a => a pattern Unsigned <- (isSigned -> False) pattern PopCount :: Bits a => Int -> a pattern PopCount n <- (popCount -> n) }}} === Data.Char === {{{#!hs pattern ControlChar :: Char pattern ControlChar <- (isControl -> True) pattern SpaceChar :: Char pattern SpaceChar <- (isSpace -> True) }}} === Data.Complex === {{{#!hs import Data.Complex (Complex, conjugate, polar, mkPolar) import qualified Data.Complex as C pattern Conjugate :: Num a => Complex a -> Complex a pattern Conjugate a <- (conjugate -> a) where Conjugate a = conjugate a pattern Polar :: RealFloat a => a -> a -> Complex a pattern Polar m theta <- (polar -> (m, theta)) where Polar m theta = mkPolar m theta -- See https://github.com/ekmett/lens/issues/653 pattern Real :: Num a => a -> Complex a pattern Real r <- r C.:+ _ where Real r = r C.:+ 0 pattern Imaginary :: Num a => a -> Complex a pattern Imaginary i <- _ C.:+ i where Imaginary i = 0 C.:+ i pattern (:+) :: a -> a -> Complex a pattern (:+) { realPart, imagPart } = realPart C.:+ imagPart }}} === GHC.Float === {{{#!hs pattern NegativeZero :: RealFloat a => a pattern NegativeZero <- (isNegativeZero -> True) where NegativeZero = -0 pattern Denormalized :: RealFloat a => a pattern Denormalized <- (isDenormalized -> True) pattern NaN :: RealFloat a => a pattern NaN <- (isNaN -> True) where NaN = 0 / 0 -- How ever negative infinity is handled pattern Infinity :: RealFloat a => a pattern Infinity <- (isInfinite -> True) where Infinity = 1 / 0 }}} === Foreign.Ptr === {{{#!hs pattern NullPtr :: Ptr a pattern NullPtr <- ((==) nullPtr -> True) where NullPtr = nullPtr }}} Used [https://github.com/cchalmers/optical/blob/a85484ad23a7f4d6b5da1dcb78781ea9c4... here] -- -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12001#comment:16 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler