#13573: Add Foldable1 / Traversable1 to base -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #10365 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by Iceland_jack): * type: bug => feature request @@ -1,1 +1,1 @@ - `NonEmpty` and `Semigroup` are in ''base'' and are on our way to add + `NonEmpty` and `Semigroup` are in ''base'' and we are on our way to add @@ -43,1 +43,1 @@ - controversial + controversial but I never liked so many partial functions in `Foldable`. New description: `NonEmpty` and `Semigroup` are in ''base'' and we are on our way to add `Semigroup` as a superclass of `Monoid` (#10365), this is a fine time to ask if we should include [https://hackage.haskell.org/package/semigroupoids-5.1/docs/Data- Semigroup-Foldable.html Foldable1], [https://hackage.haskell.org/package/semigroupoids-5.1/docs/Data- Semigroup-Traversable.html Traversable1] in ''base'' as well. `Foldable` has partial functions already, functions that only make sense for non-empty structures such as `foldr1`, `foldl1`, `minimum` and `maximum`. There are also functions which ''could'' be defined in terms of `Foldable` like `head` / `tail` (for definition of `unimprove` and `Diff` see [https://github.com/ekmett/semigroupoids/issues/49 semigroupoids issue #49] and this [https://github.com/arkeet/difference/blob/0f0e14f51cf1ecd7ebf2d8c52204bd91ae... github] page) {{{#!hs minimum1 :: (Ord a, Foldable1 f) => f a -> a minimum1 = S.getMin . foldMap1 S.Min maximum1 :: (Ord a, Foldable1 f) => f a -> a maximum1 = S.getMax . foldMap1 S.Max head1 :: Foldable1 f => f a -> a head1 = S.getFirst . foldMap1 S.First last1 :: Foldable1 f => f a -> a last1 = S.getLast . foldMap1 S.Last foldr1 :: Foldable1 t => (a -> a -> a) -> (t a -> a) foldr1 f = unimprove . foldMap1 (\a -> Diff (f a) a) foldl1 :: Foldable1 t => (a -> a -> a) -> (t a -> a) foldl1 f = unimprove . getDual . foldMap1 (\a -> Dual $ Diff (flip f a) a) }}} There is also the possibility of adding further functions such as `foldM`, `foldM_`, `foldrM` and `foldlM` for non-empty structures. As usual I don't have more concrete ideas, but let's start by testing the waters before submitting a ghc-proposal. I understand this may be controversial but I never liked so many partial functions in `Foldable`. -- -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13573#comment:1 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#13573: Add Foldable1 to base -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #10365 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Description changed by Iceland_jack: @@ -5,1 +5,2 @@ - Semigroup-Foldable.html Foldable1] in ''base'' as well. + Semigroup-Foldable.html Foldable1] in ''base'' as well (`Foldable1` is + like `Foldable` for non-empty structures). @@ -7,5 +8,5 @@ - `Foldable` has partial functions already, functions that only make sense - for non-empty structures such as `foldr1`, `foldl1`, `minimum` and - `maximum`. There are also functions which ''could'' be defined in terms of - `Foldable` like `head` / `tail` (for definition of `unimprove` and `Diff` - see [https://github.com/ekmett/semigroupoids/issues/49 semigroupoids issue + `Foldable` has partial functions, functions that only make sense for non- + empty structures such as `foldr1`, `foldl1`, `minimum` and `maximum`. + There are also functions which ''could'' be defined in terms of `Foldable` + like `head` / `tail` (for definition of `unimprove` and `Diff` see + [https://github.com/ekmett/semigroupoids/issues/49 semigroupoids issue @@ -15,0 +16,2 @@ + + If `Foldable1` we can make these functions total: New description: `NonEmpty` and `Semigroup` are in ''base'' and we are on our way to add `Semigroup` as a superclass of `Monoid` (#10365), this is a fine time to ask if we should include [https://hackage.haskell.org/package/semigroupoids-5.1/docs/Data- Semigroup-Foldable.html Foldable1] in ''base'' as well (`Foldable1` is like `Foldable` for non-empty structures). `Foldable` has partial functions, functions that only make sense for non- empty structures such as `foldr1`, `foldl1`, `minimum` and `maximum`. There are also functions which ''could'' be defined in terms of `Foldable` like `head` / `tail` (for definition of `unimprove` and `Diff` see [https://github.com/ekmett/semigroupoids/issues/49 semigroupoids issue #49] and this [https://github.com/arkeet/difference/blob/0f0e14f51cf1ecd7ebf2d8c52204bd91ae... github] page) If `Foldable1` we can make these functions total: {{{#!hs minimum1 :: (Ord a, Foldable1 f) => f a -> a minimum1 = S.getMin . foldMap1 S.Min maximum1 :: (Ord a, Foldable1 f) => f a -> a maximum1 = S.getMax . foldMap1 S.Max head1 :: Foldable1 f => f a -> a head1 = S.getFirst . foldMap1 S.First last1 :: Foldable1 f => f a -> a last1 = S.getLast . foldMap1 S.Last foldr1 :: Foldable1 t => (a -> a -> a) -> (t a -> a) foldr1 f = unimprove . foldMap1 (\a -> Diff (f a) a) foldl1 :: Foldable1 t => (a -> a -> a) -> (t a -> a) foldl1 f = unimprove . getDual . foldMap1 (\a -> Dual $ Diff (flip f a) a) }}} There is also the possibility of adding further functions such as `foldM`, `foldM_`, `foldrM` and `foldlM` for non-empty structures. As usual I don't have more concrete ideas, but let's start by testing the waters before submitting a ghc-proposal. I understand this may be controversial but I never liked so many partial functions in `Foldable`. -- -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13573#comment:3 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#13573: Add Foldable1 to base -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #10365 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Description changed by Iceland_jack: @@ -1,3 +1,1 @@ - `NonEmpty` and `Semigroup` are in ''base'' and we are on our way to add - `Semigroup` as a superclass of `Monoid` (#10365), this is a fine time to - ask if we should include + This is a proposal to add @@ -5,2 +3,1 @@ - Semigroup-Foldable.html Foldable1] in ''base'' as well (`Foldable1` is - like `Foldable` for non-empty structures). + Semigroup-Foldable.html Foldable1] (non-empty `Foldable`) to base @@ -8,6 +5,14 @@ - `Foldable` has partial functions, functions that only make sense for non- - empty structures such as `foldr1`, `foldl1`, `minimum` and `maximum`. - There are also functions which ''could'' be defined in terms of `Foldable` - like `head` / `tail` (for definition of `unimprove` and `Diff` see - [https://github.com/ekmett/semigroupoids/issues/49 semigroupoids issue - #49] and this + {{{#!hs + -- Data.Semigroup.Foldable + class Foldable t => Foldable1 t where + fold1 :: Semigroup m => t m -> m + foldMap1 :: Semigroup m => (a -> m) -> t a -> m + + -- Possible methods (efficiency) + head1 :: t a -> a + last1 :: t a -> a + }}} + + along with instances and function that are only valid for non-empty + structures (details: [https://github.com/ekmett/semigroupoids/issues/49 + semigroupoids issue #49], @@ -15,3 +20,1 @@ - github] page) - - With `Foldable1` we can make these functions total: + github]) @@ -39,2 +42,2 @@ - There is also the possibility of adding further functions such as `foldM`, - `foldM_`, `foldrM` and `foldlM` for non-empty structures. + Adding `foldM`, `foldM_`, `foldrM` and `foldlM` for non-empty structures + is also a possibility. @@ -42,3 +45,10 @@ - As usual I don't have more concrete ideas, but let's start by testing the - waters before submitting a ghc-proposal. I understand this may be - controversial but I never liked so many partial functions in `Foldable`. + ---- + + Currently these are partial functions in `Foldable`. This proposal does + '''not''' propose replacing partial `Foldable` functions. + + ---- + + I wanted to test the waters before submitting it to the libraries mailing + list. This may be controversial but it gives us a path to avoid partial + functions in `Foldable`. New description: This is a proposal to add [https://hackage.haskell.org/package/semigroupoids-5.1/docs/Data- Semigroup-Foldable.html Foldable1] (non-empty `Foldable`) to base {{{#!hs -- Data.Semigroup.Foldable class Foldable t => Foldable1 t where fold1 :: Semigroup m => t m -> m foldMap1 :: Semigroup m => (a -> m) -> t a -> m -- Possible methods (efficiency) head1 :: t a -> a last1 :: t a -> a }}} along with instances and function that are only valid for non-empty structures (details: [https://github.com/ekmett/semigroupoids/issues/49 semigroupoids issue #49], [https://github.com/arkeet/difference/blob/0f0e14f51cf1ecd7ebf2d8c52204bd91ae... github]) {{{#!hs minimum1 :: (Ord a, Foldable1 f) => f a -> a minimum1 = S.getMin . foldMap1 S.Min maximum1 :: (Ord a, Foldable1 f) => f a -> a maximum1 = S.getMax . foldMap1 S.Max head1 :: Foldable1 f => f a -> a head1 = S.getFirst . foldMap1 S.First last1 :: Foldable1 f => f a -> a last1 = S.getLast . foldMap1 S.Last foldr1 :: Foldable1 t => (a -> a -> a) -> (t a -> a) foldr1 f = unimprove . foldMap1 (\a -> Diff (f a) a) foldl1 :: Foldable1 t => (a -> a -> a) -> (t a -> a) foldl1 f = unimprove . getDual . foldMap1 (\a -> Dual $ Diff (flip f a) a) }}} Adding `foldM`, `foldM_`, `foldrM` and `foldlM` for non-empty structures is also a possibility. ---- Currently these are partial functions in `Foldable`. This proposal does '''not''' propose replacing partial `Foldable` functions. ---- I wanted to test the waters before submitting it to the libraries mailing list. This may be controversial but it gives us a path to avoid partial functions in `Foldable`. -- -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13573#comment:5 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#13573: Add Foldable1 to base -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #10365 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Description changed by Iceland_jack: @@ -11,1 +11,1 @@ - -- Possible methods (efficiency) + -- Possible methods @@ -14,1 +14,1 @@ - toNonEmpty :: t a -> Nonempty a + toNonEmpty :: t a -> NonEmpty a New description: This is a proposal to add [https://hackage.haskell.org/package/semigroupoids-5.1/docs/Data- Semigroup-Foldable.html Foldable1] (non-empty `Foldable`) to base {{{#!hs -- Data.Semigroup.Foldable class Foldable t => Foldable1 t where fold1 :: Semigroup m => t m -> m foldMap1 :: Semigroup m => (a -> m) -> t a -> m -- Possible methods head1 :: t a -> a last1 :: t a -> a toNonEmpty :: t a -> NonEmpty a }}} along with instances and function that are only valid for non-empty structures (details: [https://github.com/ekmett/semigroupoids/issues/49 semigroupoids issue #49], [https://github.com/arkeet/difference/blob/0f0e14f51cf1ecd7ebf2d8c52204bd91ae... github]) {{{#!hs minimum1 :: (Ord a, Foldable1 f) => f a -> a minimum1 = S.getMin . foldMap1 S.Min maximum1 :: (Ord a, Foldable1 f) => f a -> a maximum1 = S.getMax . foldMap1 S.Max head1 :: Foldable1 f => f a -> a head1 = S.getFirst . foldMap1 S.First last1 :: Foldable1 f => f a -> a last1 = S.getLast . foldMap1 S.Last foldr1 :: Foldable1 t => (a -> a -> a) -> (t a -> a) foldr1 f = unimprove . foldMap1 (\a -> Diff (f a) a) foldl1 :: Foldable1 t => (a -> a -> a) -> (t a -> a) foldl1 f = unimprove . getDual . foldMap1 (\a -> Dual $ Diff (flip f a) a) }}} Adding `foldM`, `foldM_`, `foldrM` and `foldlM` for non-empty structures is also a possibility. ---- Currently these are partial functions in `Foldable`. This proposal does '''not''' propose replacing partial `Foldable` functions. ---- I wanted to test the waters before submitting it to the libraries mailing list. This may be controversial but it gives us a path to avoid partial functions in `Foldable`. -- -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13573#comment:7 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#13573: Add Foldable1 to base -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #10365 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Description changed by Iceland_jack: @@ -24,1 +24,3 @@ - minimum1 :: (Ord a, Foldable1 f) => f a -> a + import qualified Data.Semigroup as S + + minimum1, maximum1 :: (Ord a, Foldable1 f) => f a -> a @@ -26,2 +28,0 @@ - - maximum1 :: (Ord a, Foldable1 f) => f a -> a @@ -30,1 +30,1 @@ - head1 :: Foldable1 f => f a -> a + head1, last1 :: Foldable1 f => f a -> a @@ -32,0 +32,1 @@ + last1 = S.getLast . foldMap1 S.Last @@ -33,4 +34,1 @@ - last1 :: Foldable1 f => f a -> a - last1 = S.getLast . foldMap1 S.Last - - foldr1 :: Foldable1 f => (a -> a -> a) -> (f a -> a) + foldr1, foldl1 :: Foldable1 f => (a -> a -> a) -> (f a -> a) @@ -38,2 +36,0 @@ - - foldl1 :: Foldable1 f => (a -> a -> a) -> (f a -> a) New description: This is a proposal to add [https://hackage.haskell.org/package/semigroupoids-5.1/docs/Data- Semigroup-Foldable.html Foldable1] (non-empty `Foldable`) to base {{{#!hs -- Data.Semigroup.Foldable class Foldable f => Foldable1 f where fold1 :: Semigroup m => f m -> m foldMap1 :: Semigroup m => (a -> m) -> f a -> m -- Possible methods head1 :: f a -> a last1 :: f a -> a toNonEmpty :: f a -> NonEmpty a }}} along with instances and function that are only valid for non-empty structures (details: [https://github.com/ekmett/semigroupoids/issues/49 semigroupoids issue #49], [https://github.com/arkeet/difference/blob/0f0e14f51cf1ecd7ebf2d8c52204bd91ae... github]) {{{#!hs import qualified Data.Semigroup as S minimum1, maximum1 :: (Ord a, Foldable1 f) => f a -> a minimum1 = S.getMin . foldMap1 S.Min maximum1 = S.getMax . foldMap1 S.Max head1, last1 :: Foldable1 f => f a -> a head1 = S.getFirst . foldMap1 S.First last1 = S.getLast . foldMap1 S.Last foldr1, foldl1 :: Foldable1 f => (a -> a -> a) -> (f a -> a) foldr1 f = unimprove . foldMap1 (\a -> Diff (f a) a) foldl1 f = unimprove . getDual . foldMap1 (\a -> Dual $ Diff (flip f a) a) }}} Adding `foldM`, `foldM_`, `foldrM` and `foldlM` for non-empty structures is also a possibility. ---- Currently these are partial functions in `Foldable`. This proposal does '''not''' propose replacing partial `Foldable` functions. ---- I wanted to test the waters before submitting it to the libraries mailing list. This may be controversial but it gives us a path to avoid partial functions in `Foldable`. -- -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13573#comment:9 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#13573: Add Foldable1 to base -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #10365 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Description changed by Iceland_jack: @@ -9,1 +9,1 @@ - foldMap1 :: Semigroup m => (a -> m) -> f a -> m + foldMap1 :: Semigroup m => (a -> m) -> (f a -> m) New description: This is a proposal to add [https://hackage.haskell.org/package/semigroupoids-5.1/docs/Data- Semigroup-Foldable.html Foldable1] (non-empty `Foldable`) to base {{{#!hs -- Data.Semigroup.Foldable class Foldable f => Foldable1 f where fold1 :: Semigroup m => f m -> m foldMap1 :: Semigroup m => (a -> m) -> (f a -> m) -- Possible methods head1 :: f a -> a last1 :: f a -> a toNonEmpty :: f a -> NonEmpty a }}} along with instances and function that are only valid for non-empty structures (details: [https://github.com/ekmett/semigroupoids/issues/49 semigroupoids issue #49], [https://github.com/arkeet/difference/blob/0f0e14f51cf1ecd7ebf2d8c52204bd91ae... github]) {{{#!hs import qualified Data.Semigroup as S minimum1, maximum1 :: (Ord a, Foldable1 f) => f a -> a minimum1 = S.getMin . foldMap1 S.Min maximum1 = S.getMax . foldMap1 S.Max head1, last1 :: Foldable1 f => f a -> a head1 = S.getFirst . foldMap1 S.First last1 = S.getLast . foldMap1 S.Last foldr1, foldl1 :: Foldable1 f => (a -> a -> a) -> (f a -> a) foldr1 f = unimprove . foldMap1 (\a -> Diff (f a) a) foldl1 f = unimprove . getDual . foldMap1 (\a -> Dual $ Diff (flip f a) a) }}} Adding `foldM`, `foldM_`, `foldrM` and `foldlM` for non-empty structures is also a possibility. ---- Currently these are partial functions in `Foldable`. This proposal does '''not''' propose replacing partial `Foldable` functions. ---- I wanted to test the waters before submitting it to the libraries mailing list. This may be controversial but it gives us a path to avoid partial functions in `Foldable`. -- -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13573#comment:11 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler