Represent class dictionaries as newtypes by rhendric · Pull Request #4125 · purescript/purescript

rhendric · 2021-06-28T20:12:47Z

Class dictionaries are now represented as newtype wrappers of records.
This drops the awkward TypeClassDictionaryConstructorApp and
TypeClassDictionaryAccessor expressions in favor of regular newtype
constructors and record accessors.

Description of the change

This is mostly motivated by an attempt-in-progress at #4086, but I think it stands on its own merits.

Previously: #3567 and #781. I'm tempted to say that this PR closes those, but maybe there are reasons to prefer the data representation over the newtype one I've implemented? I quite like how simple the generated code for the newtype representation is, and how it means that the newtype constructors can be completely erased (with other newtypes, the constructors still have to be exported in case some code references them in a way that isn't an erased application, but with typeclass newtypes that's not possible). But adapting this PR to use data instead of newtype would be easy and would also suffice for my #4086 purposes.

This newly-updated comment describes the details:

purescript/src/Language/PureScript/Sugar/TypeClasses.hs

Lines 109 to 198 in cd869eb

    
           {- Desugar type class and type class instance declarations 
        
           -- 
        
           -- Type classes become newtypes for their dictionaries, and type instances become dictionary declarations. 
        
           -- Additional values are generated to access individual members of a dictionary, with the appropriate type. 
        
           -- 
        
           -- E.g. the following 
        
           -- 
        
           --   module Test where 
        
           -- 
        
           --   class Foo a where 
        
           --     foo :: a -> a 
        
           -- 
        
           --   instance fooString :: Foo String where 
        
           --     foo s = s ++ s 
        
           -- 
        
           --   instance fooArray :: (Foo a) => Foo [a] where 
        
           --     foo = map foo 
        
           -- 
        
           --   {- Superclasses -} 
        
           -- 
        
           --   class (Foo a) <= Sub a where 
        
           --     sub :: a 
        
           -- 
        
           --   instance subString :: Sub String where 
        
           --     sub = "" 
        
           -- 
        
           -- becomes: 
        
           -- 
        
           --   <TypeClassDeclaration Foo ...> 
        
           -- 
        
           --   newtype Foo$Dict a = Foo$Dict { foo :: a -> a } 
        
           -- 
        
           --   -- this following type is marked as not needing to be checked so a new Abs 
        
           --   -- is not introduced around the definition in type checking, but when 
        
           --   -- called the dictionary value is still passed in for the `dict` argument 
        
           --   foo :: forall a. (Foo$Dict a) => a -> a 
        
           --   foo (Foo$Dict dict) = dict.foo 
        
           -- 
        
           --   fooString :: Foo$Dict String 
        
           --   fooString = Foo$Dict { foo: \s -> s ++ s } 
        
           -- 
        
           --   fooArray :: forall a. (Foo$Dict a) => Foo$Dict [a] 
        
           --   fooArray = Foo$Dict { foo: map foo } 
        
           -- 
        
           --   {- Superclasses -} 
        
           -- 
        
           --   <TypeClassDeclaration Sub ...> 
        
           -- 
        
           --   newtype Sub$Dict a = Sub$Dict { sub :: a 
        
           --                                 , "Foo0" :: {} -> Foo$Dict a 
        
           --                                 } 
        
           -- 
        
           --   -- As with `foo` above, this type is unchecked at the declaration 
        
           --   sub :: forall a. (Sub$Dict a) => a 
        
           --   sub (Sub$Dict dict) = dict.sub 
        
           -- 
        
           --   subString :: Sub$Dict String 
        
           --   subString = Sub$Dict { sub: "", 
        
           --                        , "Foo0": \_ -> <DeferredDictionary Foo String> 
        
           --                        } 
        
           -- 
        
           -- and finally as the generated javascript: 
        
           -- 
        
           --   var foo = function (dict) { 
        
           --       return dict.foo; 
        
           --   }; 
        
           -- 
        
           --   var fooString = { 
        
           --      foo: function (s) { 
        
           --          return s + s; 
        
           --      } 
        
           --   }; 
        
           -- 
        
           --   var fooArray = function (dictFoo) { 
        
           --       return { 
        
           --           foo: map(foo(dictFoo)) 
        
           --       }; 
        
           --   }; 
        
           -- 
        
           --   var sub = function (dict) { 
        
           --       return dict.sub; 
        
           --   }; 
        
           -- 
        
           --   var subString = { 
        
           --       sub: "", 
        
           --       Foo0: function () { 
        
           --           return fooString; 
        
           --       } 
        
           --   }; 
        
           -}

Checklist:

Added the change to the changelog's "Unreleased" section with a reference to this PR (e.g. "- Made a change (#0000)")
Added myself to CONTRIBUTORS.md (if this is my first contribution)
Linked any existing issues or proposals that this pull request should close
Updated or added relevant documentation
Added a test for the contribution (if applicable)

garyb · 2021-06-28T20:39:50Z

I wanted to use data constructors as their implementation is more optimisable by JS runtimes*, and it makes the representation less record-dependent for backends that have to implement records by means that may be less efficient than static data types.

I was also thinking that perhaps it'd be easier to use annotations on the data constructor form of this to use for later optimisations, but you've already made good progress on a major part of that without needing it (#3915)!

* In light of some benchmarks Nate tried recently, there probably isn't much of a distinction between object and "class" performance anymore, so the JS concern isn't really there anymore. Property access used to be significantly faster on "classes" than on standard objects.

I'm in favour of this PR - even if later it seems that the data approach is better again for some reason, for we still get to eliminate the TypeClassDictionary... stuff in the mean time, which is totally worth it!

JordanMartinez · 2021-07-09T00:29:48Z

@garyb So, would you be willing to approve this PR? Or are there other things you think need to be addressed?

garyb · 2021-07-09T15:17:22Z

I haven't reviewed it thoroughly yet, but it looks good from a glance! Will try to remember to come back to it this weekend for a proper 👍

Class dictionaries are now represented as newtype wrappers of records. This drops the awkward TypeClassDictionaryConstructorApp and TypeClassDictionaryAccessor expressions in favor of regular newtype constructors and record accessors.

garyb

👍 Sorry it took ages to get to!

rhendric force-pushed the rhendric/typeclasses-are-newtypes branch from d8e67ea to cd869eb Compare June 28, 2021 20:13

rhendric force-pushed the rhendric/typeclasses-are-newtypes branch from cd869eb to a0d482e Compare June 28, 2021 23:03

rhendric mentioned this pull request Jul 3, 2021

Purs bundle drops var but keeps const and let #4039

Closed

JordanMartinez mentioned this pull request Jul 12, 2021

Represent class dictionaries as data types #3567

Closed

2 tasks

Represent class dictionaries as newtypes

880b6b0

Class dictionaries are now represented as newtype wrappers of records. This drops the awkward TypeClassDictionaryConstructorApp and TypeClassDictionaryAccessor expressions in favor of regular newtype constructors and record accessors.

rhendric force-pushed the rhendric/typeclasses-are-newtypes branch from a0d482e to 880b6b0 Compare July 12, 2021 21:45

garyb approved these changes Jul 18, 2021

View reviewed changes

rhendric merged commit 9908e62 into purescript:master Jul 19, 2021

rhendric deleted the rhendric/typeclasses-are-newtypes branch July 19, 2021 01:37

rhendric mentioned this pull request Aug 7, 2021

Avoids redundant substitution in unifyTypes when possible #4163

Closed

5 tasks

JordanMartinez mentioned this pull request Aug 25, 2021

Prepare for v0.14.4 release #4175

Merged

1 task

JordanMartinez mentioned this pull request Nov 17, 2021

Represent typeclasses as data constructors in functional core #781

Closed

sjpgarcia mentioned this pull request Dec 28, 2021

Proposal: Disallow polytypes in row/record fields #4223

Open

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Represent class dictionaries as newtypes#4125

Represent class dictionaries as newtypes#4125
rhendric merged 1 commit intopurescript:masterfrom
rhendric:rhendric/typeclasses-are-newtypes

rhendric commented Jun 28, 2021 •

edited

Loading

Uh oh!

garyb commented Jun 28, 2021

Uh oh!

JordanMartinez commented Jul 9, 2021

Uh oh!

garyb commented Jul 9, 2021

Uh oh!

garyb left a comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

	{- Desugar type class and type class instance declarations
	--
	-- Type classes become newtypes for their dictionaries, and type instances become dictionary declarations.
	-- Additional values are generated to access individual members of a dictionary, with the appropriate type.
	--
	-- E.g. the following
	--
	-- module Test where
	--
	-- class Foo a where
	-- foo :: a -> a
	--
	-- instance fooString :: Foo String where
	-- foo s = s ++ s
	--
	-- instance fooArray :: (Foo a) => Foo [a] where
	-- foo = map foo
	--
	-- {- Superclasses -}
	--
	-- class (Foo a) <= Sub a where
	-- sub :: a
	--
	-- instance subString :: Sub String where
	-- sub = ""
	--
	-- becomes:
	--
	-- <TypeClassDeclaration Foo ...>
	--
	-- newtype Foo$Dict a = Foo$Dict { foo :: a -> a }
	--
	-- -- this following type is marked as not needing to be checked so a new Abs
	-- -- is not introduced around the definition in type checking, but when
	-- -- called the dictionary value is still passed in for the `dict` argument
	-- foo :: forall a. (Foo$Dict a) => a -> a
	-- foo (Foo$Dict dict) = dict.foo
	--
	-- fooString :: Foo$Dict String
	-- fooString = Foo$Dict { foo: \s -> s ++ s }
	--
	-- fooArray :: forall a. (Foo$Dict a) => Foo$Dict [a]
	-- fooArray = Foo$Dict { foo: map foo }
	--
	-- {- Superclasses -}
	--
	-- <TypeClassDeclaration Sub ...>
	--
	-- newtype Sub$Dict a = Sub$Dict { sub :: a
	-- , "Foo0" :: {} -> Foo$Dict a
	-- }
	--
	-- -- As with `foo` above, this type is unchecked at the declaration
	-- sub :: forall a. (Sub$Dict a) => a
	-- sub (Sub$Dict dict) = dict.sub
	--
	-- subString :: Sub$Dict String
	-- subString = Sub$Dict { sub: "",
	-- , "Foo0": \_ -> <DeferredDictionary Foo String>
	-- }
	--
	-- and finally as the generated javascript:
	--
	-- var foo = function (dict) {
	-- return dict.foo;
	-- };
	--
	-- var fooString = {
	-- foo: function (s) {
	-- return s + s;
	-- }
	-- };
	--
	-- var fooArray = function (dictFoo) {
	-- return {
	-- foo: map(foo(dictFoo))
	-- };
	-- };
	--
	-- var sub = function (dict) {
	-- return dict.sub;
	-- };
	--
	-- var subString = {
	-- sub: "",
	-- Foo0: function () {
	-- return fooString;
	-- }
	-- };
	-}

Conversation

rhendric commented Jun 28, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

garyb commented Jun 28, 2021

Uh oh!

JordanMartinez commented Jul 9, 2021

Uh oh!

garyb commented Jul 9, 2021

Uh oh!

garyb left a comment

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

rhendric commented Jun 28, 2021 •

edited

Loading