Another example are non-empty containers, e.g. for `NonEmpty`  one cannot have 
a total `fromList :: [a] -> NonEmpty a`.

Regards,

Marcin

Sent with ProtonMail Secure Email.

‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐

On Sunday, September 19th, 2021 at 08:49, David Feuer <david.fe...@gmail.com> 
wrote:

> No, fromList is too much. Consider
> 

> data Foo a = Foo (IORef String) [a]  deriving Foldable
> 

> What IORef should fromList use?
> 

> On Sun, Sep 19, 2021, 2:44 AM Anthony Clayden <anthony.d.clay...@gmail.com> 
> wrote:
> 

> > (Moving this discussion to glasgow-users. It's just not appropriate on the 
> > cafe.)
> > 

> > > I am no longer a novice, and yet would still have a hard time making any 
> > >use of the laws as written in constructing instances. Instead, I'd ignore 
> > >the laws and write a natural intuitive instance, and it would invariably 
> > >work.
> > 

> > Seems my approach is very similar to Viktor's. My (very informal) 
> > understanding of the Laws looks nothing like the docos. I regard Foldable 
> > structures as merely more efficient ways to hold a List. Then I expect 
> > 'moral equivalences':
> > 

> > > toList . fromList ~=~ id -- going via the Foldable structure> fromList . 
> > > toList ~=~ id> toList ~=~ foldr (:) []
> > 

> > But those aren't equalities. 'moral equivalence' means the Lists have the 
> > same elements, not necessarily in the same order; the structures have the 
> > same elements but possibly in a different arrangement -- that is, in the 
> > `Tree` example, there might be `Empty` scattered about, and elements held 
> > variously in `Leaf`s vs `Node`s. So more accurately:
> > 

> > > fromList . toList . fromList === fromList -- i.e. there's a 'canonical' 
> > > arrangement> toList . fromList . toList === toList -- i.e. there's a 
> > > 'canonical' List ordering
> > 

> > (That triple-journey business is a similar style to defining Lattice 
> > pseudocomplements https://en.wikipedia.org/wiki/Pseudocomplement#Properties 
> > -- if I can chuck in some math theory.)
> > 

> > I'd expect all other methods to be one of: `reduceStuff === reduceStuff . 
> > toList` or `mapStuff === fromList . mapStuff . toList`.
> > 

> > But! there's no method `fromList` in Foldable. Why not?/please explain. 
> > (Are there Foldable structures which we can't load from a List? At least 
> > assuming the List is finite.) `fromList` is the first thing I write after 
> > declaring the datatype, so I can easily load up some test data. There is 
> > one example `fromList` in the doco. Is that not generalisable? `foldMap 
> > Leaf` would be brutal, but should work? `foldMap singleton` ? (But there's 
> > no method `singleton`.)
> > 

> > _______________________________________________
> > 

> > Glasgow-haskell-users mailing list
> > 

> > Glasgow-haskell-users@haskell.org
> > 

> > http://mail.haskell.org/cgi-bin/mailman/listinfo/glasgow-haskell-users

Attachment: signature.asc
Description: OpenPGP digital signature

_______________________________________________
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/glasgow-haskell-users

Reply via email to