March 2021 - Haskell-Cafe

Puzzling instance method definitions in Data.Sequence.Internal
by Viktor Dukhovni 02 Mar '21

02 Mar '21

In `containers`, Data.Sequence.Internal defines a Foldable instance for `Seq` with method definitions for `length` and `null` that I'm struggling to understand: https://github.com/haskell/containers/blob/master/containers/src/Data/Seque… #if MIN_VERSION_base(4,8,0) length = length {-# INLINE length #-} null = null {-# INLINE null #-} #endif further down the file there are also explicit top-level definitions for these functions: https://github.com/haskell/containers/blob/master/containers/src/Data/Seque… -- | \( O(1) \). Is this the empty sequence? null :: Seq a -> Bool null (Seq EmptyT) = True null _ = False -- | \( O(1) \). The number of elements in the sequence. length :: Seq a -> Int length (Seq xs) = size xs So the intent seems clear, but I don't understand how the instance method definitions are valid. The imports of Both Prelude and Data.Foldable don't include `length` or `null`: https://github.com/haskell/containers/blob/master/containers/src/Data/Seque… So the RHS definitions should plausibly resolve to the top-level functions, but when I try to define a similar type class instance GHC tells me: ‘method’ is not a (visible) method of class ‘Class’ and in any case I'd expect `length = length` to yield an infinite loop, regardless of any other bindings in the outer scope. How is Data.Sequence.Internal getting away with this??? -- Viktor.

2 2

DatatypeContexts / alternative
by CASANOVA Juan 01 Mar '21

01 Mar '21

Hello again, Haskell Cafe, Here again with another doubt on how am I supposed to. This one should be fairly easier, I believe. In short, I would like to have a functor type that can only be applied to certain type parameters. Why? Well, something like this: module DatatypeContextsExample where import Data.Map import Data.Bifunctor data Foo t = Foo (Map t t) instance Functor Foo where fmap f (Foo m) = Foo (fromList (fmap (bimap f f) (toList m))) This does not compile, because I am using toList and fromList, which require (Ord t). But I cannot really have Foo be a functor in this way without it. The thing is, every time I am going to use it, t is actually going to be Ord. But how do I tell Haskell to have this constraint? DatatypeContexts seems to be the extension that allows this: data Ord t => Foo t = Foo (Map t t) But this has two issues. First, DatatypeContexts is deprecated. Second, more importantly, it still does not type check! It produces the exact same error, saying that Ord t could not be inferred. It should be inferred from the very fact that I am using the type Foo, but GHC does not seem to want to understand this. I could also try with GADTs: data Foo t where Foo :: Ord t => Map t t -> Foo t But this still gives the same error on the fmap definition, stating it cannot use Foo without Ord. But I am pattern-matching against it, shouldn't that be enough to know that (Ord t) is going to hold? I don't understand it. Is there anything simple I am missing? Any other simple way to achieve this? Any fundamental problem with what I am trying to do? Thanks as usual, Juan. The University of Edinburgh is a charitable body, registered in Scotland, with registration number SC005336. Is e buidheann carthannais a th' ann an Oilthigh Dhùn Èideann, clàraichte an Alba, àireamh clàraidh SC005336.

5 14

Re: [Haskell-cafe] Not too extensible records?
by Anthony Clayden 01 Mar '21

01 Mar '21

Hi Ignat, as an example of what an extensible records system might look like in Haskell, you could play with Hugs.Trex -- https://www.haskell.org/hugs/pages/hugsman/exts.html#sect7.2 To match a few of its features to your post: > suppose I have two functions: one is a layout algorithm that assigns to nodes some spatial positions, and the second is a topological algorithm that discerns roots and leaves. These two functions are conceptually independent and ... r1 = (label = blah1) r2 = (topology = blah2 | r1) r3 = (v2 = blah3 :: Double | r2) The `( ... | r1)` means extend `r1` with some extra field or fields comma-separated. This is an 'extensible' 'anonymous' records system -- 'anonymous' in that you don't pre-declare your record types via `data`. You can name your record types, either with a `type` decl or with a `newtype` that provides a constructor for known-in-advance types. > may be applied in any order, Yes you can extend an existing record with arbitrary fields, the result is always a 'flat' tuple with the labels-value pairs forming a set: two records are same type providing they have the same set of labels and the same field types at each label, irrespective of how the labels got added. > I would like to make sure their fields are not mixed. > I need to be able to add more and more fields to labels, but in such a way that it is impossible to assign an unsuitable field. There's a so-called 'lacks' constraint you can put on record operations (written with backslash): foo :: r1\topology => Rec r1 -> a -> Rec (edges :: a | r1) is the type of a function that will extend record type `r1` lacking label 'topology' with a field `edges` at type `a`. You can put record types with lacks constraints on instances: instance (r2\v2) => Foo (Rec (label :: String | r2)) (Rec (v2 :: Double, label :: String | r2)) where ... holds for any record that includes label `label` at `String`, and possibly other labels in `r2`, but lacks `v2`. (I'm presuming there's a FunDep on Foo so the second instance parameter is the return type.) > a huge number of `HasThis` and `HasThat` instances That instance head is in effect a `Has` `label` constraint. There's also a shorthand `#label` that generates a function to extract the value at `label` **from any record with a `label`** -- that is, Hugs infers the `Has` constraint for you. > it seems to me that some smart technology is needed to make this manageable. I'm not seeing Trex as 'smart'. It follows conventional relational algebra semantics; was developed ~1996; last release of Hugs was 2006. I'd have thought GHC would come up with something comparable by now. As Olaf's and Henning's replies show, you could fake it with "a lot of boilerplate" and/or some dubious type trickery. AntC

1 0