Dear Committe,

it’s been two weeks since we started voting. We are still short one
vote (Cale, release the suspsense!). But also, there are still plenty
of “maybes” in your vote. I encourage you to change them to yes or no
(at least for those extensions that are near the edge), so that we have
more clarity on which extensions are actually worth spending emails on.

As always, the table
https://github.com/ghc-proposals/ghc-proposals/blob/ghc2021/proposals/0000-ghc2021.rst#data
has the current data. (And even even got community contributions to
improve its readability. Yay!)

We discussed many extensions on (and I might have missed some):

 * The innnocence of PostfixOperators was pointed out, and widely
   appreciated
 * Joachim pleads for UnicodeSyntax
 * InstanceSigs worries seems to have been addressed, it’s on its way
   in
 * Whether OverloadedString is harmless enough.
 * Whether ViewPatterns are good enough (given that alternative ideas
   exist)
 * That ForeignFunctionInterfaces is actually part of Haskell2010
 * That this isn’t quite the right time to ditch StarIsType
 * CUSKs vs. StandaloneKindSignatures
 * BlockArguments is liked by some, but may be too new
 * GADTs were advocated for a lot, but also a bit against, so not
   uncontroversial
 * Same with ExistentialQuantification
 * PolyKinds were advocated for (and got many votes)
 * ScopedTypeVariables is wanted on by default by some,
   despite the fact that nobody believes it’s the last
   word on that design corner. Alejandro argues that it’s
   ok to include it even if it will change in GHC202X again,
   but elsewhere SPJ says that GHC2021 should only include extensions
   we have reason to hope are stable and stay around .
 * Arnaud wonders about the hesitation to include
   FunctionalDependencies


Applying the actual quota of ⅔ out of 11, i.e. 8 votes, these would go
in no matter how Cale votes:

   BangPatterns, BinaryLiterals, ConstrainedClassMethods,
   ConstraintKinds, DeriveDataTypeable, DeriveFoldable, DeriveFunctor,
   DeriveGeneric, DeriveLift, DeriveTraversable, EmptyCase,
   EmptyDataDecls, EmptyDataDeriving, ExplicitForAll, FlexibleContexts,
   FlexibleInstances, GADTSyntax, GeneralisedNewtypeDeriving,
   HexFloatLiterals, ImportQualifiedPost, InstanceSigs, KindSignatures,
   MultiParamTypeClasses, NamedFieldPuns, NumericUnderscores,
   PolyKinds, PostfixOperators, RankNTypes, StandaloneDeriving,
   StarIsType, TypeApplications, TypeOperators, TypeSynonymInstances

The following have 7 votes, which is the quorum based on 10 ballots:

   ExistentialQuantification, ForeignFunctionInterface, MonoLocalBinds,
   NegativeLiterals, RecordWildCards, StandaloneKindSignatures,
   TypeFamilies

And these are one vote short:

   DataKinds, DerivingStrategies, GADTs, NamedWildCards,
   ScopedTypeVariables, TupleSections, UnicodeSyntax, ViewPatterns


Not sure how useful the list of symmetric difference report is, but
here it is:

alejandro
would miss:
DataKinds, DerivingStrategies, FunctionalDependencies, GADTs,
LambdaCase, MonadFailDesugaring, NamedWildCards,
NoMonomorphismRestriction, NullaryTypeClasses, NumDecimals,
OverloadedLists, OverloadedStrings, ScopedTypeVariables, TupleSections,
UnicodeSyntax, ViewPatterns
doesn’t want:
none!

arnaud
would miss:
Arrows, DerivingStrategies, ExplicitNamespaces, FunctionalDependencies,
GADTs, MonadFailDesugaring, PartialTypeSignatures,
TypeFamilyDependencies, ViewPatterns
doesn’t want:
ExistentialQuantification, ImportQualifiedPost, InstanceSigs,
NamedFieldPuns, PolyKinds, RankNTypes, RecordWildCards,
StandaloneKindSignatures, TypeSynonymInstances

eric
would miss:
DataKinds, DefaultSignatures, DisambiguateRecordFields,
ExplicitNamespaces, FunctionalDependencies, GADTs, MonadFailDesugaring,
NamedWildCards, OverloadedLists, OverloadedStrings,
PartialTypeSignatures, PatternSynonyms, RoleAnnotations,
ScopedTypeVariables, TypeFamilyDependencies
doesn’t want:
EmptyDataDeriving, ForeignFunctionInterface

iavor
would miss:
BlockArguments, CApiFFI, MultiWayIf, NoMonomorphismRestriction,
NullaryTypeClasses, ParallelListComp, RecursiveDo, UnicodeSyntax,
UnliftedNewtypes
doesn’t want:
ConstrainedClassMethods, EmptyCase, ExplicitForAll, GADTSyntax,
GeneralisedNewtypeDeriving, InstanceSigs, KindSignatures,
MonoLocalBinds, NegativeLiterals, PolyKinds, StandaloneKindSignatures,
StarIsType, TypeApplications, TypeFamilies, TypeOperators

joachim
would miss:
DataKinds, DerivingStrategies, DerivingVia, LambdaCase, NamedWildCards,
NondecreasingIndentation, RoleAnnotations, TupleSections,
UnicodeSyntax, UnliftedFFITypes, UnliftedNewtypes
doesn’t want:
ConstrainedClassMethods, ExistentialQuantification,
TypeSynonymInstances

richard
would miss:
BlockArguments, DefaultSignatures, DerivingStrategies, DerivingVia,
DisambiguateRecordFields, ExplicitNamespaces, LexicalNegation,
NamedWildCards, NumDecimals, ParallelListComp, RoleAnnotations,
TemplateHaskellQuotes, TupleSections, UnicodeSyntax, UnliftedNewtypes,
ViewPatterns
doesn’t want:
MonoLocalBinds, NegativeLiterals, RecordWildCards, TypeFamilies

simonm
would miss:
DataKinds, DefaultSignatures, GADTs, LambdaCase, LiberalTypeSynonyms,
MultiWayIf, NoMonomorphismRestriction, NondecreasingIndentation,
NumDecimals, OverloadedStrings, PatternSynonyms, ScopedTypeVariables,
TupleSections, UnicodeSyntax
doesn’t want:
DeriveLift, NumericUnderscores, TypeApplications, TypeOperators

spj
would miss:
NoMonomorphismRestriction, NullaryTypeClasses, OverloadedLists,
OverloadedStrings, ParallelListComp, RecursiveDo, RoleAnnotations,
ScopedTypeVariables, ViewPatterns
doesn’t want:
ForeignFunctionInterface, GeneralisedNewtypeDeriving, NegativeLiterals,
RecordWildCards, TypeFamilies

tom
would miss:
BlockArguments, DataKinds, DefaultSignatures, DerivingStrategies,
DerivingVia, DisambiguateRecordFields, DuplicateRecordFields,
ExplicitNamespaces, FunctionalDependencies, GADTs, LambdaCase,
LexicalNegation, LiberalTypeSynonyms, MagicHash, MultiWayIf,
NamedWildCards, NullaryTypeClasses, NumDecimals, PackageImports,
ParallelListComp, QuasiQuotes, RoleAnnotations, ScopedTypeVariables,
TemplateHaskell, TemplateHaskellQuotes, TupleSections,
TypeFamilyDependencies, UnboxedSums, UnboxedTuples, UnicodeSyntax,
UnliftedNewtypes, ViewPatterns
doesn’t want:
ForeignFunctionInterface, MonoLocalBinds, StarIsType

vitaly
would miss:
DataKinds, DerivingStrategies, DerivingVia, GADTs, LambdaCase,
MonadFailDesugaring, NamedWildCards, OverloadedLists,
OverloadedStrings, ScopedTypeVariables, TupleSections, ViewPatterns
doesn’t want:
ExistentialQuantification, StandaloneKindSignatures

Cheers,
Joachim

--
Joachim Breitner
  mail@joachim-breitner.de
  http://www.joachim-breitner.de/


_______________________________________________
ghc-steering-committee mailing list
ghc-steering-committee@haskell.org
https://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-steering-committee