Send Beginners mailing list submissions to
[email protected]
To subscribe or unsubscribe via the World Wide Web, visit
http://www.haskell.org/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
[email protected]
You can reach the person managing the list at
[email protected]
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. Re: Abstracting Data.List (mukesh tiwari)
2. Re: Abstracting Data.List (Peter Hall)
3. Re: Abstracting Data.List (Giacomo Tesio)
----------------------------------------------------------------------
Message: 1
Date: Fri, 31 May 2013 15:46:28 +0530
From: mukesh tiwari <[email protected]>
Subject: Re: [Haskell-beginners] Abstracting Data.List
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Message-ID:
<CAFHZvE9XznZgP+EAJ2t5=za+lwjaytwjf_7pyamd-pztzwz...@mail.gmail.com>
Content-Type: text/plain; charset="iso-8859-1"
Hi Giacomo,
Data.List can be abstracted using Foldable and Traversable but
unfortunately I could not find the functions corresponding to head, take.
Prelude Data.Traversable Data.Foldable> :t Data.Foldable.
Data.Foldable.Foldable Data.Foldable.concatMap
Data.Foldable.foldl' Data.Foldable.foldrM
Data.Foldable.minimum Data.Foldable.sequenceA_
Data.Foldable.all Data.Foldable.elem
Data.Foldable.foldl1 Data.Foldable.forM_
Data.Foldable.minimumBy Data.Foldable.sequence_
Data.Foldable.and Data.Foldable.find
Data.Foldable.foldlM Data.Foldable.for_
Data.Foldable.msum Data.Foldable.sum
Data.Foldable.any Data.Foldable.fold
Data.Foldable.foldr Data.Foldable.mapM_
Data.Foldable.notElem Data.Foldable.toList
Data.Foldable.asum Data.Foldable.foldMap
Data.Foldable.foldr' Data.Foldable.maximum
Data.Foldable.or Data.Foldable.traverse_
Data.Foldable.concat Data.Foldable.foldl
Data.Foldable.foldr1 Data.Foldable.maximumBy Data.Foldable.product
Prelude Data.Traversable Data.Foldable> :t Data.Traversable.
Data.Traversable.Traversable Data.Traversable.for
Data.Traversable.mapAccumR Data.Traversable.sequenceA
Data.Traversable.fmapDefault Data.Traversable.forM
Data.Traversable.mapM Data.Traversable.traverse
Data.Traversable.foldMapDefault Data.Traversable.mapAccumL
Data.Traversable.sequence
Prelude Data.Traversable Data.Foldable> :i Foldable
class Foldable t where
fold :: Data.Monoid.Monoid m => t m -> m
foldMap :: Data.Monoid.Monoid m => (a -> m) -> t a -> m
Data.Foldable.foldr :: (a -> b -> b) -> b -> t a -> b
foldr' :: (a -> b -> b) -> b -> t a -> b
Data.Foldable.foldl :: (a -> b -> a) -> a -> t b -> a
foldl' :: (a -> b -> a) -> a -> t b -> a
Data.Foldable.foldr1 :: (a -> a -> a) -> t a -> a
Data.Foldable.foldl1 :: (a -> a -> a) -> t a -> a
-- Defined in `Data.Foldable'
instance Foldable [] -- Defined in `Data.Foldable'
instance Foldable Maybe -- Defined in `Data.Foldable'
Prelude Data.Traversable Data.Foldable> :i Tr
Traversable True
Prelude Data.Traversable Data.Foldable> :i Traversable
class (Functor t, Foldable t) => Traversable t where
traverse ::
Control.Applicative.Applicative f => (a -> f b) -> t a -> f (t b)
sequenceA ::
Control.Applicative.Applicative f => t (f a) -> f (t a)
Data.Traversable.mapM :: Monad m => (a -> m b) -> t a -> m (t b)
Data.Traversable.sequence :: Monad m => t (m a) -> m (t a)
-- Defined in `Data.Traversable'
instance Traversable [] -- Defined in `Data.Traversable'
instance Traversable Maybe -- Defined in `Data.Traversable'
Prelude Data.Traversable Data.Foldable> :t foldMap
foldMap
:: (Foldable t, Data.Monoid.Monoid m) => (a -> m) -> t a -> m
-Mukesh
On Fri, May 31, 2013 at 2:26 PM, Giacomo Tesio <[email protected]> wrote:
> I'm looking for a class abstracting Data.List. I mean something that
> enable the use of say head, map, take and so on into different kind of
> types.
>
> Is there already something like that?
>
>
> Giacomo
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20130531/5cdca020/attachment-0001.htm>
------------------------------
Message: 2
Date: Fri, 31 May 2013 11:44:29 +0100
From: Peter Hall <[email protected]>
Subject: Re: [Haskell-beginners] Abstracting Data.List
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Message-ID:
<caa6hak7lje9dw5ckg4da0teqekukbr7bjal7szdtxd80z7z...@mail.gmail.com>
Content-Type: text/plain; charset="iso-8859-1"
http://hackage.haskell.org/packages/archive/ListLike/3.1.4/doc/html/Data-ListLike.html
Peter
On 31 May 2013 11:16, mukesh tiwari <[email protected]> wrote:
> Hi Giacomo,
> Data.List can be abstracted using Foldable and Traversable but
> unfortunately I could not find the functions corresponding to head, take.
>
> Prelude Data.Traversable Data.Foldable> :t Data.Foldable.
> Data.Foldable.Foldable Data.Foldable.concatMap
> Data.Foldable.foldl' Data.Foldable.foldrM
> Data.Foldable.minimum Data.Foldable.sequenceA_
> Data.Foldable.all Data.Foldable.elem
> Data.Foldable.foldl1 Data.Foldable.forM_
> Data.Foldable.minimumBy Data.Foldable.sequence_
> Data.Foldable.and Data.Foldable.find
> Data.Foldable.foldlM Data.Foldable.for_
> Data.Foldable.msum Data.Foldable.sum
> Data.Foldable.any Data.Foldable.fold
> Data.Foldable.foldr Data.Foldable.mapM_
> Data.Foldable.notElem Data.Foldable.toList
> Data.Foldable.asum Data.Foldable.foldMap
> Data.Foldable.foldr' Data.Foldable.maximum
> Data.Foldable.or Data.Foldable.traverse_
> Data.Foldable.concat Data.Foldable.foldl
> Data.Foldable.foldr1 Data.Foldable.maximumBy Data.Foldable.product
> Prelude Data.Traversable Data.Foldable> :t Data.Traversable.
> Data.Traversable.Traversable Data.Traversable.for
> Data.Traversable.mapAccumR Data.Traversable.sequenceA
> Data.Traversable.fmapDefault Data.Traversable.forM
> Data.Traversable.mapM Data.Traversable.traverse
> Data.Traversable.foldMapDefault Data.Traversable.mapAccumL
> Data.Traversable.sequence
> Prelude Data.Traversable Data.Foldable> :i Foldable
> class Foldable t where
> fold :: Data.Monoid.Monoid m => t m -> m
> foldMap :: Data.Monoid.Monoid m => (a -> m) -> t a -> m
> Data.Foldable.foldr :: (a -> b -> b) -> b -> t a -> b
> foldr' :: (a -> b -> b) -> b -> t a -> b
> Data.Foldable.foldl :: (a -> b -> a) -> a -> t b -> a
> foldl' :: (a -> b -> a) -> a -> t b -> a
> Data.Foldable.foldr1 :: (a -> a -> a) -> t a -> a
> Data.Foldable.foldl1 :: (a -> a -> a) -> t a -> a
> -- Defined in `Data.Foldable'
> instance Foldable [] -- Defined in `Data.Foldable'
> instance Foldable Maybe -- Defined in `Data.Foldable'
> Prelude Data.Traversable Data.Foldable> :i Tr
> Traversable True
> Prelude Data.Traversable Data.Foldable> :i Traversable
> class (Functor t, Foldable t) => Traversable t where
> traverse ::
> Control.Applicative.Applicative f => (a -> f b) -> t a -> f (t b)
> sequenceA ::
> Control.Applicative.Applicative f => t (f a) -> f (t a)
> Data.Traversable.mapM :: Monad m => (a -> m b) -> t a -> m (t b)
> Data.Traversable.sequence :: Monad m => t (m a) -> m (t a)
> -- Defined in `Data.Traversable'
> instance Traversable [] -- Defined in `Data.Traversable'
> instance Traversable Maybe -- Defined in `Data.Traversable'
> Prelude Data.Traversable Data.Foldable> :t foldMap
> foldMap
> :: (Foldable t, Data.Monoid.Monoid m) => (a -> m) -> t a -> m
>
> -Mukesh
>
>
> On Fri, May 31, 2013 at 2:26 PM, Giacomo Tesio <[email protected]> wrote:
>
>> I'm looking for a class abstracting Data.List. I mean something that
>> enable the use of say head, map, take and so on into different kind of
>> types.
>>
>> Is there already something like that?
>>
>>
>> Giacomo
>>
>> _______________________________________________
>> Beginners mailing list
>> [email protected]
>> http://www.haskell.org/mailman/listinfo/beginners
>>
>>
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20130531/519eb7b3/attachment-0001.htm>
------------------------------
Message: 3
Date: Fri, 31 May 2013 12:46:30 +0200
From: Giacomo Tesio <[email protected]>
Subject: Re: [Haskell-beginners] Abstracting Data.List
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Message-ID:
<CAHL7psEjvGmfTr=o8ppr5hlmbsfwry8rje6ncgyyku3xj_r...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
Thanks, that's a good starting point. What would be the proper name for
such an abstraction in Haskell?
In C# it would be Enumerable (and indeed the static class Enumerable<T>
contains such kind of functions applicable to anything implementing
IEnumerable<T>). What would be the idiomatic name of such a *class* in
Haskell?
- List ?
- Listable ?
- Enumerable ?
- ListWithContext ?
Giacomo
On Fri, May 31, 2013 at 12:16 PM, mukesh tiwari <
[email protected]> wrote:
> Hi Giacomo,
> Data.List can be abstracted using Foldable and Traversable but
> unfortunately I could not find the functions corresponding to head, take.
>
> Prelude Data.Traversable Data.Foldable> :t Data.Foldable.
> Data.Foldable.Foldable Data.Foldable.concatMap
> Data.Foldable.foldl' Data.Foldable.foldrM
> Data.Foldable.minimum Data.Foldable.sequenceA_
> Data.Foldable.all Data.Foldable.elem
> Data.Foldable.foldl1 Data.Foldable.forM_
> Data.Foldable.minimumBy Data.Foldable.sequence_
> Data.Foldable.and Data.Foldable.find
> Data.Foldable.foldlM Data.Foldable.for_
> Data.Foldable.msum Data.Foldable.sum
> Data.Foldable.any Data.Foldable.fold
> Data.Foldable.foldr Data.Foldable.mapM_
> Data.Foldable.notElem Data.Foldable.toList
> Data.Foldable.asum Data.Foldable.foldMap
> Data.Foldable.foldr' Data.Foldable.maximum
> Data.Foldable.or Data.Foldable.traverse_
> Data.Foldable.concat Data.Foldable.foldl
> Data.Foldable.foldr1 Data.Foldable.maximumBy Data.Foldable.product
> Prelude Data.Traversable Data.Foldable> :t Data.Traversable.
> Data.Traversable.Traversable Data.Traversable.for
> Data.Traversable.mapAccumR Data.Traversable.sequenceA
> Data.Traversable.fmapDefault Data.Traversable.forM
> Data.Traversable.mapM Data.Traversable.traverse
> Data.Traversable.foldMapDefault Data.Traversable.mapAccumL
> Data.Traversable.sequence
> Prelude Data.Traversable Data.Foldable> :i Foldable
> class Foldable t where
> fold :: Data.Monoid.Monoid m => t m -> m
> foldMap :: Data.Monoid.Monoid m => (a -> m) -> t a -> m
> Data.Foldable.foldr :: (a -> b -> b) -> b -> t a -> b
> foldr' :: (a -> b -> b) -> b -> t a -> b
> Data.Foldable.foldl :: (a -> b -> a) -> a -> t b -> a
> foldl' :: (a -> b -> a) -> a -> t b -> a
> Data.Foldable.foldr1 :: (a -> a -> a) -> t a -> a
> Data.Foldable.foldl1 :: (a -> a -> a) -> t a -> a
> -- Defined in `Data.Foldable'
> instance Foldable [] -- Defined in `Data.Foldable'
> instance Foldable Maybe -- Defined in `Data.Foldable'
> Prelude Data.Traversable Data.Foldable> :i Tr
> Traversable True
> Prelude Data.Traversable Data.Foldable> :i Traversable
> class (Functor t, Foldable t) => Traversable t where
> traverse ::
> Control.Applicative.Applicative f => (a -> f b) -> t a -> f (t b)
> sequenceA ::
> Control.Applicative.Applicative f => t (f a) -> f (t a)
> Data.Traversable.mapM :: Monad m => (a -> m b) -> t a -> m (t b)
> Data.Traversable.sequence :: Monad m => t (m a) -> m (t a)
> -- Defined in `Data.Traversable'
> instance Traversable [] -- Defined in `Data.Traversable'
> instance Traversable Maybe -- Defined in `Data.Traversable'
> Prelude Data.Traversable Data.Foldable> :t foldMap
> foldMap
> :: (Foldable t, Data.Monoid.Monoid m) => (a -> m) -> t a -> m
>
> -Mukesh
>
>
> On Fri, May 31, 2013 at 2:26 PM, Giacomo Tesio <[email protected]> wrote:
>
>> I'm looking for a class abstracting Data.List. I mean something that
>> enable the use of say head, map, take and so on into different kind of
>> types.
>>
>> Is there already something like that?
>>
>>
>> Giacomo
>>
>> _______________________________________________
>> Beginners mailing list
>> [email protected]
>> http://www.haskell.org/mailman/listinfo/beginners
>>
>>
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20130531/d513840f/attachment.htm>
------------------------------
_______________________________________________
Beginners mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/beginners
End of Beginners Digest, Vol 59, Issue 44
*****************************************
