profile
viewpoint
Rob Rix robrix @GitHub http://antitypical.com Colouring outside the lines at @GitHub.

fused-effects/fused-effects 472

A fast, flexible, fused effect system for Haskell

robrix/Box 212

Swift µframework of the ubiquitous Box<T> & MutableBox<T> reference types, for recursive value types & misc. other purposes.

patrickt/fastsum 77

A fast open-union type, suitable for 100+ contained alternatives.

ocharles/effect-zoo 41

Comparing Haskell effect systems for ergonomics and speed

robrix/A-Swiftly-Tilting-Parser 19

Talk about the derivative of parser combinators in ObjC & Swift

joshvera/effects 18

An implementation of "Freer Monads, More Extensible Effects".

robrix/Delay 18

µframework for lazy evaluation in Swift.

robrix/abstract-interpretation 15

Experiments in abstracting definitional interpreters

robrix/Auspicion 15

Convenient LLVM compiler API for Objective-C.

fused-effects/diffused-effects 10

all your intentions turned to vapour

push eventrobrix/facet

Rob Rix

commit sha 0023065ddc0dc28ead017ac02e5487059d782e5b

Update both types and terms incrementally.

view details

Rob Rix

commit sha 91862643b0e94045a8cf497f1366e26b6ae1eda5

Copy fused-effects-readline in.

view details

Rob Rix

commit sha 7826a87877b859ce46a60c487c417ecd8372c84b

Complete filenames.

view details

Rob Rix

commit sha 5af116c77fe909e40be9958c463f430117a295bb

Provide Reader effects for the module and graph during elaboration.

view details

Rob Rix

commit sha 7e34a1d9702a92268fd7540ba6491c0646c6f413

Resolve names in the module and graph.

view details

Rob Rix

commit sha 4bb83da0c93f9b90f1ea1ccfe25e1a7a65096661

:fire: the requirement for an Env effect.

view details

Rob Rix

commit sha 0d5b75f4a1eea0e377efd8841adf42bef619f09b

:fire: the Env from elabWith.

view details

Rob Rix

commit sha fe38ee5d8c733c773dc3a9385bbb73add19e4c4b

:fire: the env effect in the REPL.

view details

Rob Rix

commit sha 885de83392e319eb2e65b8f2b19f1b74da72d389

:fire: the env_ lens.

view details

Rob Rix

commit sha 5194529736a1e76c045246b8d818695974393f33

:fire: the env field from the REPL state.

view details

Rob Rix

commit sha 3312e9188837994979fb93b92bede7b84b80d659

:fire: Facet.Env.

view details

Rob Rix

commit sha 20903263bed613e1212522fd25ad9af4241c6a53

Reuse the Type action for :kind.

view details

Rob Rix

commit sha a569fd6251d1ac8e564f3520b341ead46abbab2d

Move the prompt function up.

view details

Rob Rix

commit sha ca847ede65ba2f629881c9f3212d2fc96fa9e72f

Move localDefs up.

view details

Rob Rix

commit sha 6014dd9ea294bb6e5ab0ceecec73526e7790ae0e

Show variables with the names the programmer gave them.

view details

Rob Rix

commit sha 11a9fd2bf8806fb801124b690267be6a733589c6

Add a FIXME about multiple source references in a Notice.

view details

Rob Rix

commit sha 04cc84cf519754c486a57028b0a1182fa7b7ba23

Print both positions for nonempty spans.

view details

Rob Rix

commit sha 39cfea3657e3e15e1b2065193cf48a572f201d0b

Factor out the treatment of individual coords.

view details

Rob Rix

commit sha 48a4a723f9c45ce9d7b01b1b262aeda236550867

Abbreviate single-line spans.

view details

Rob Rix

commit sha 9a08204f6c0c3412524fc5773921595d8e02e947

Add a note about resolving symbols in the parser.

view details

push time in 6 hours

push eventrobrix/facet

Rob Rix

commit sha 61228196d4b1f4f8b02ef9320907ef70a8e05b86

Don’t treat : as reload.

view details

Rob Rix

commit sha aaeb87a911d364cbb39b5a62d5fc7e5ea3d0d388

Move type_ and kind_ into commands.

view details

Rob Rix

commit sha 88034cd1372b7a78fc52ab841163b83eeb2ad782

Show modules and paths.

view details

Rob Rix

commit sha 41290f929adad13919d93a1fdaacad5a1a098d6f

Add a FIXME about removing stale modules.

view details

Rob Rix

commit sha ba9bcc123f61b189f1736d17bcb5810702488644

Reintroduce a Graph type.

view details

Rob Rix

commit sha 66046d2a9b8a8880a9118912a9863cc45bec5931

Define insertion into module graphs.

view details

Rob Rix

commit sha 1f67ed9c80edabd5980c8ac26d8aa984b0ecc13e

Define a lookup on Graphs.

view details

Rob Rix

commit sha d2a13ec99e812f0a7e3db9fcfe319ddf57ef036e

Don’t return an Env from elabModule.

view details

Rob Rix

commit sha 50ef07d96d8ff664d670bcb7d69b663bed3d47c8

Add a couple of FIXMEs around preserving associativities.

view details

Rob Rix

commit sha ed216adbd197390aa61c20708d8a436f95b44fc1

Extract a helper for following edges.

view details

Rob Rix

commit sha 02ffd2a47ec91fa39a9b5f572e753be5c080929a

Re-abstract loadOrder. We can’t load from the elaborated modules because elaboration needs imports already in place.

view details

Rob Rix

commit sha 928fcbc7e091f4a186c98d964fb43941f4fe5e38

Define module' in terms of moduleHeader.

view details

Rob Rix

commit sha fd5e12dd03272bae62f9dd66f4ebb096ac125cf2

Qualify the import of Facet.Surface.

view details

Rob Rix

commit sha 2295265ef256074dde3e415a9553502ef6aaab2b

Define a helper to load just the header of a module.

view details

Rob Rix

commit sha 2ff4d4ad53181c2ade464add5b14cc5fef700b2e

Add a FIXME about enriching CyclicImport with source references.

view details

Rob Rix

commit sha 787fbc5d1ace3c864b824f94aa92f8c33ff9e81f

Resolve the load order early so it doesn’t depend on elaboration.

view details

Rob Rix

commit sha 1e485491e80dc241dbf9a414df71c454c3584be9

Don’t require as much infrastructure around elabModule.

view details

Rob Rix

commit sha ac899091ac0e4c618bf773e25754957115698632

Add paths to graphs.

view details

Rob Rix

commit sha 36339a2199f9eb1d8882b69dd30964f285e35be8

Derive Semigroup & Monoid instances for Facet.Graph.

view details

Rob Rix

commit sha ee1eac92906ea02e3c16f3ac7da3a9046d569e0a

Define Ixed & At instances for Graph.

view details

push time in 21 hours

push eventrobrix/facet

Rob Rix

commit sha 1e5a4e8e4ff1bcbcf2a1f1e5595afac5ef966aec

:memo: Facet.Elab a little.

view details

Rob Rix

commit sha 90ef8fe2e42a8db6af021c7e3dc21cb5ade85c1c

Derive Eq instances for the surface syntax.

view details

Rob Rix

commit sha 184b276d620e8b137b52272ef6a886ca9a5bc794

Define the load order for a module graph.

view details

Rob Rix

commit sha f2064b675324e13c09f8380b62f767b1f59c3367

Simplify loadOrder to operate over a list of modules.

view details

Rob Rix

commit sha 1383cbf2b7ba56dc024ce3b84ea1be643262bdd2

Define a Node datatype.

view details

Rob Rix

commit sha fe45d471f28f8b449fcdc26f88ec52910ce626b5

Give nodes a payload.

view details

Rob Rix

commit sha d2f529dcd9f444d754d6358520935112de50b8ef

Generalize Node over the key type.

view details

Rob Rix

commit sha f14ba18db20492fd1ae6bb18bd5a872f97b452dd

Generalize loadOrder to operate on Nodes.

view details

Rob Rix

commit sha 2bb77a9d30a955e6c7a951a9b00434ed24f57d88

Rework a bit to avoid -XScopedTypeVariables.

view details

Rob Rix

commit sha 004b6b11e09a733edc15ffeb99c91fac77f1f26d

Rename Target to Field.

view details

Rob Rix

commit sha 2d50fe9dc57029355ee78675929e41a586718b46

Don’t print the module on load.

view details

Rob Rix

commit sha 61c9cc6f7bc0f2f07bcf883d3780b1d51b96066d

Hard-core the src dir for now.

view details

Rob Rix

commit sha dc66ad0c0e6df086c03e7893f4911faa4cef60f2

Only print the search paths if there are any.

view details

Rob Rix

commit sha 4631e83dad16526a9a1e399520738b6a756cc457

:fire: redundant parens.

view details

Rob Rix

commit sha 35677549e7dbfa684e06434e0b44b878513e7d49

Show the cwd.

view details

Rob Rix

commit sha 7bcfb97ab51dc61022c5c502e864844704953f20

Indent the paths in each group.

view details

Rob Rix

commit sha b27255c358b95b566d131d8c33a97c1523f57f1c

Add a list of targets to the REPL state.

view details

Rob Rix

commit sha eb9138ea944928a1cca7ecd2758f423fe9d46913

Add/remove & show fields via different specifiers.

view details

Rob Rix

commit sha a8e0f173d468e6836cd49e54bef4f90947c536f3

Extract the per-command parser.

view details

Rob Rix

commit sha 9dca46b765494ce4c61b790861140b69c5c67691

Rename targets to modules.

view details

push time in a day

pull request commentghc-proposals/ghc-proposals

The GHC20xx process

Posted some notes, mostly typo fixes ☝🏻 I think this is an excellent proposal, although I’m ambivalent about the idea of GHC20xx-bundles themselves (TL;DR: it seems pragmatic but opaque and I tend to prefer semantic groupings). Specifically, I think this addresses the worry I had coming in that “uncontroversial” could be particularly difficult to satisfy for almost any extension.

Nice work!

nomeata

comment created time in a day

Pull request review commentghc-proposals/ghc-proposals

The GHC20xx process

+The GHC20XX process+===================++.. author:: Alejandro Serrano, Joachim Breitner+.. date-accepted:: +.. proposal-number::+.. ticket-url::+.. implemented::+.. highlight:: haskell+.. header:: This proposal is `discussed at this pull request <https://github.com/ghc-proposals/ghc-proposals/pull/372>`_.+.. sectnum::+.. contents::++This proposal sets up a process to introduce new language versions `GHC20XX`, extending `Haskell2010` as defined by the Report with several extensions that are considerd harmless, helpfun and uncontroversial.+++Motivation+----------++It has almost become a meme that any slightly-complex Haskell module starts with a dozen lines of ``{-# LANGUAGE #-}`` pragmas. This poses several problems:++- beginners often see features behind an extension as "advanced" or "obscure", even though some like ``LambdaCase`` or ``NamedFieldPuns`` are quite simple;+- some sorts of programming in Haskell – mostly type-level oriented – require enables lots of extensions (think of the usual combo ``MultiParamTypeClasses`` + ``FlexibleInstances`` + ``FlexibleContexts``). Sometimes the fact that there are different extensions, instead of a single `ExtendedTypeClasses` is mostly historical.++For that reason, it's benefitial to pack those extensions which have "graduated" in terms of stability and usefulness into a single language version.++We aim to lean on the conservative side in our selection of extensions: Not including an extension that we should have is relatively harmless (users of that extension will have to still set that manually, but they alreay have to do that, and we can add it alter), while including an extension that we should not have hurts more (any detriminal effect on developer experience now affects many users).++We also aim to have a process that is efficient. For each extension, we are all very capable of having very long discussions about the merits, up-sides and downsides, and almost anybody will have an opinion on almost any extensions. But aiming to include only _uncontroversial_ extensions, we aim to avoid much of these discussion by construction. The process deliberately does not provide room for long per-extensions deliberations, neither within the committee or with the overall community, while still involving the community.+++Proposed Change Specification+-----------------------------++We propose to introduce a process to develop new "language versions", dubbed ``GHC20XX``, which extend ``Haskell2010`` with some default extensions. This proposal does not set *which* extensions are included in the first version,, rather seeks to provide a framework to reach a conclusion in a constructive and timely manner.++Criteria+^^^^^^^^++We define a set of criteria that an extension should guide the committee members in their process of picking suitable extensions. These are not hard criteria, but often subjective, and not all need to be satisfied in all cases.++1. The extension is (mostly) *conservative*: All programs that were accepted without the extension remain accepted, and with the same meaning. We prefer to take this as a strict criteria, and grant exceptions on a case-by-case basis.+2. *New failure modes* that become possible with the extension are *rare* and/or easy to diagnose. These failure modes include new error messages, wrong inferred types, and runtime errors, for example. In other words, the *developer experience* should not get worse by adding this extension to the default mix.+3. The extensions *complement* the design of standard Haskell. For example, ``MultiParamTypeClasses`` extends what's already there, and works well with the rest of features. If we suddenly decided you can use Lisp-like syntax, that would not complement the current design.+4. The extension has been – and can reasonably be predicted to remain – *stable*.+5. The extension is one that users might plausibly want to be on all the time. This excludes experimental extensions that deliberately enable potentially-unsafe or unstable features, such as ``IncoherentInstances`` or ``MagicHash``.+6. The extension has *widespread* usage.+7. The extension is favored by the community, with many in favor, and very few opposed to its inclusion.+++Process+^^^^^^^++* 4 months before the expected GHC spring release day of 202x, the committee Secretary starts the GHC202x process.++  They inform the committe, in an email to the mailing list, of all language extensions supported by the latest released GHC that are not in GHC202(x-1), which could be added. They also list all extensions *in* GHC202(x-1), which could be removed.++  The secretary also creates a PR with a proposal saying (roughly) +   +    GHC202x contains the following extensions in addition to those in GHC202(x-1):+    +    * (none yet)+    +    and removes these extensions+   +    * (none yet)++* In order to gather data on the criterium “widespread usage”, the secretary creates a tally of which extensions are used how often on hackage.++* In order to gather data on the criterium “community spport”, the secretary runs a public poll on a suitable platform for one week where anyone+  can vote in favor or against the inclusion of a given extension.  ++* Within two weeks of the start of the process, every committee member is expected to send an initial list of which extensions they expect to be in GHC202x to the mailing list.+   +  Committe members are expected to take the Hackage statistics and the community vote into account.+   +  These mails may contain justifications for why a certain extension is or is not included, but not required (or even expected).++  After these two weeks, the PR is continuously updated by the secretary to reflect the *current* tally of votes: An extension is included if it is listed by at least ⅔ (rounded up) of committee members.++* Within four weeks of the start of the process, committee members can change their vote (by email to the list).++  It is absolutely ok to change one’s mind based on the explanations in the other members’ emails, or the general comments on the PR.+   +  Long discussions of individual extensions are discouraged at this point. If there is controversy around an extension, it is a strong sign that it should simply not be included.++* After these four weeks, the proposal with the current tally gets accepted by the secretary, and defines GHC202x++Cadence+^^^^^^^++Likely, the first iteration of this process will be vastly different from the following ones: The first one is expected to add a large number of uncontroversial extensions; so the next iteration will likely only make a smaller, but more controversial change.++Therefore, this proposal does *not* commit to a fixed cadence. Instead, 6 months after the first release of a version of GHC that supports a GHC20XX set, we evaluate the outcome, the process, and the perceived need of a next release. At that time we will refine the processes, if needed, and set a cadence.++Costs and Drawbacks+-------------------++The implementation cost seems small.++The cost of a GHC20xx extension is that, upon reading a file with ``{-# LANGUAGE GHC20xx #-}``, the reader does not immediatelly know the set of enabled extensions; this may hamper readability of code.++The costs of this process is that it binds volunteer time, and there is is risk of unpleasant, heated debates, because everybody has opinions. The process tries to err on the conversative side and rather add too few than too many extensions.
The costs of this process is that it binds volunteer time, and there is is risk of unpleasant, heated debates, because everybody has opinions. The process tries to err on the conservative side and rather add too few than too many extensions.
nomeata

comment created time in a day

PullRequestReviewEvent

Pull request review commentghc-proposals/ghc-proposals

The GHC20xx process

+The GHC20XX process+===================++.. author:: Alejandro Serrano, Joachim Breitner+.. date-accepted:: +.. proposal-number::+.. ticket-url::+.. implemented::+.. highlight:: haskell+.. header:: This proposal is `discussed at this pull request <https://github.com/ghc-proposals/ghc-proposals/pull/372>`_.+.. sectnum::+.. contents::++This proposal sets up a process to introduce new language versions `GHC20XX`, extending `Haskell2010` as defined by the Report with several extensions that are considerd harmless, helpfun and uncontroversial.+++Motivation+----------++It has almost become a meme that any slightly-complex Haskell module starts with a dozen lines of ``{-# LANGUAGE #-}`` pragmas. This poses several problems:++- beginners often see features behind an extension as "advanced" or "obscure", even though some like ``LambdaCase`` or ``NamedFieldPuns`` are quite simple;+- some sorts of programming in Haskell – mostly type-level oriented – require enables lots of extensions (think of the usual combo ``MultiParamTypeClasses`` + ``FlexibleInstances`` + ``FlexibleContexts``). Sometimes the fact that there are different extensions, instead of a single `ExtendedTypeClasses` is mostly historical.++For that reason, it's benefitial to pack those extensions which have "graduated" in terms of stability and usefulness into a single language version.++We aim to lean on the conservative side in our selection of extensions: Not including an extension that we should have is relatively harmless (users of that extension will have to still set that manually, but they alreay have to do that, and we can add it alter), while including an extension that we should not have hurts more (any detriminal effect on developer experience now affects many users).++We also aim to have a process that is efficient. For each extension, we are all very capable of having very long discussions about the merits, up-sides and downsides, and almost anybody will have an opinion on almost any extensions. But aiming to include only _uncontroversial_ extensions, we aim to avoid much of these discussion by construction. The process deliberately does not provide room for long per-extensions deliberations, neither within the committee or with the overall community, while still involving the community.+++Proposed Change Specification+-----------------------------++We propose to introduce a process to develop new "language versions", dubbed ``GHC20XX``, which extend ``Haskell2010`` with some default extensions. This proposal does not set *which* extensions are included in the first version,, rather seeks to provide a framework to reach a conclusion in a constructive and timely manner.++Criteria+^^^^^^^^++We define a set of criteria that an extension should guide the committee members in their process of picking suitable extensions. These are not hard criteria, but often subjective, and not all need to be satisfied in all cases.++1. The extension is (mostly) *conservative*: All programs that were accepted without the extension remain accepted, and with the same meaning. We prefer to take this as a strict criteria, and grant exceptions on a case-by-case basis.+2. *New failure modes* that become possible with the extension are *rare* and/or easy to diagnose. These failure modes include new error messages, wrong inferred types, and runtime errors, for example. In other words, the *developer experience* should not get worse by adding this extension to the default mix.+3. The extensions *complement* the design of standard Haskell. For example, ``MultiParamTypeClasses`` extends what's already there, and works well with the rest of features. If we suddenly decided you can use Lisp-like syntax, that would not complement the current design.+4. The extension has been – and can reasonably be predicted to remain – *stable*.+5. The extension is one that users might plausibly want to be on all the time. This excludes experimental extensions that deliberately enable potentially-unsafe or unstable features, such as ``IncoherentInstances`` or ``MagicHash``.+6. The extension has *widespread* usage.+7. The extension is favored by the community, with many in favor, and very few opposed to its inclusion.+++Process+^^^^^^^++* 4 months before the expected GHC spring release day of 202x, the committee Secretary starts the GHC202x process.++  They inform the committe, in an email to the mailing list, of all language extensions supported by the latest released GHC that are not in GHC202(x-1), which could be added. They also list all extensions *in* GHC202(x-1), which could be removed.++  The secretary also creates a PR with a proposal saying (roughly) +   +    GHC202x contains the following extensions in addition to those in GHC202(x-1):+    +    * (none yet)+    +    and removes these extensions+   +    * (none yet)++* In order to gather data on the criterium “widespread usage”, the secretary creates a tally of which extensions are used how often on hackage.++* In order to gather data on the criterium “community spport”, the secretary runs a public poll on a suitable platform for one week where anyone+  can vote in favor or against the inclusion of a given extension.  ++* Within two weeks of the start of the process, every committee member is expected to send an initial list of which extensions they expect to be in GHC202x to the mailing list.+   +  Committe members are expected to take the Hackage statistics and the community vote into account.+   +  These mails may contain justifications for why a certain extension is or is not included, but not required (or even expected).
  These mails may contain justifications for why a certain extension is or is not included, but this is not required (or even expected).
nomeata

comment created time in a day

PullRequestReviewEvent

Pull request review commentghc-proposals/ghc-proposals

The GHC20xx process

+The GHC20XX process+===================++.. author:: Alejandro Serrano, Joachim Breitner+.. date-accepted:: +.. proposal-number::+.. ticket-url::+.. implemented::+.. highlight:: haskell+.. header:: This proposal is `discussed at this pull request <https://github.com/ghc-proposals/ghc-proposals/pull/372>`_.+.. sectnum::+.. contents::++This proposal sets up a process to introduce new language versions `GHC20XX`, extending `Haskell2010` as defined by the Report with several extensions that are considerd harmless, helpfun and uncontroversial.+++Motivation+----------++It has almost become a meme that any slightly-complex Haskell module starts with a dozen lines of ``{-# LANGUAGE #-}`` pragmas. This poses several problems:++- beginners often see features behind an extension as "advanced" or "obscure", even though some like ``LambdaCase`` or ``NamedFieldPuns`` are quite simple;+- some sorts of programming in Haskell – mostly type-level oriented – require enables lots of extensions (think of the usual combo ``MultiParamTypeClasses`` + ``FlexibleInstances`` + ``FlexibleContexts``). Sometimes the fact that there are different extensions, instead of a single `ExtendedTypeClasses` is mostly historical.++For that reason, it's benefitial to pack those extensions which have "graduated" in terms of stability and usefulness into a single language version.++We aim to lean on the conservative side in our selection of extensions: Not including an extension that we should have is relatively harmless (users of that extension will have to still set that manually, but they alreay have to do that, and we can add it alter), while including an extension that we should not have hurts more (any detriminal effect on developer experience now affects many users).++We also aim to have a process that is efficient. For each extension, we are all very capable of having very long discussions about the merits, up-sides and downsides, and almost anybody will have an opinion on almost any extensions. But aiming to include only _uncontroversial_ extensions, we aim to avoid much of these discussion by construction. The process deliberately does not provide room for long per-extensions deliberations, neither within the committee or with the overall community, while still involving the community.+++Proposed Change Specification+-----------------------------++We propose to introduce a process to develop new "language versions", dubbed ``GHC20XX``, which extend ``Haskell2010`` with some default extensions. This proposal does not set *which* extensions are included in the first version,, rather seeks to provide a framework to reach a conclusion in a constructive and timely manner.++Criteria+^^^^^^^^++We define a set of criteria that an extension should guide the committee members in their process of picking suitable extensions. These are not hard criteria, but often subjective, and not all need to be satisfied in all cases.++1. The extension is (mostly) *conservative*: All programs that were accepted without the extension remain accepted, and with the same meaning. We prefer to take this as a strict criteria, and grant exceptions on a case-by-case basis.+2. *New failure modes* that become possible with the extension are *rare* and/or easy to diagnose. These failure modes include new error messages, wrong inferred types, and runtime errors, for example. In other words, the *developer experience* should not get worse by adding this extension to the default mix.+3. The extensions *complement* the design of standard Haskell. For example, ``MultiParamTypeClasses`` extends what's already there, and works well with the rest of features. If we suddenly decided you can use Lisp-like syntax, that would not complement the current design.+4. The extension has been – and can reasonably be predicted to remain – *stable*.+5. The extension is one that users might plausibly want to be on all the time. This excludes experimental extensions that deliberately enable potentially-unsafe or unstable features, such as ``IncoherentInstances`` or ``MagicHash``.+6. The extension has *widespread* usage.+7. The extension is favored by the community, with many in favor, and very few opposed to its inclusion.+++Process+^^^^^^^++* 4 months before the expected GHC spring release day of 202x, the committee Secretary starts the GHC202x process.++  They inform the committe, in an email to the mailing list, of all language extensions supported by the latest released GHC that are not in GHC202(x-1), which could be added. They also list all extensions *in* GHC202(x-1), which could be removed.++  The secretary also creates a PR with a proposal saying (roughly) +   +    GHC202x contains the following extensions in addition to those in GHC202(x-1):+    +    * (none yet)+    +    and removes these extensions+   +    * (none yet)++* In order to gather data on the criterium “widespread usage”, the secretary creates a tally of which extensions are used how often on hackage.++* In order to gather data on the criterium “community spport”, the secretary runs a public poll on a suitable platform for one week where anyone+  can vote in favor or against the inclusion of a given extension.  ++* Within two weeks of the start of the process, every committee member is expected to send an initial list of which extensions they expect to be in GHC202x to the mailing list.+   +  Committe members are expected to take the Hackage statistics and the community vote into account.
  Committee members are expected to take the Hackage statistics and the community vote into account.
nomeata

comment created time in a day

PullRequestReviewEvent

Pull request review commentghc-proposals/ghc-proposals

The GHC20xx process

+The GHC20XX process+===================++.. author:: Alejandro Serrano, Joachim Breitner+.. date-accepted:: +.. proposal-number::+.. ticket-url::+.. implemented::+.. highlight:: haskell+.. header:: This proposal is `discussed at this pull request <https://github.com/ghc-proposals/ghc-proposals/pull/372>`_.+.. sectnum::+.. contents::++This proposal sets up a process to introduce new language versions `GHC20XX`, extending `Haskell2010` as defined by the Report with several extensions that are considerd harmless, helpfun and uncontroversial.+++Motivation+----------++It has almost become a meme that any slightly-complex Haskell module starts with a dozen lines of ``{-# LANGUAGE #-}`` pragmas. This poses several problems:++- beginners often see features behind an extension as "advanced" or "obscure", even though some like ``LambdaCase`` or ``NamedFieldPuns`` are quite simple;+- some sorts of programming in Haskell – mostly type-level oriented – require enables lots of extensions (think of the usual combo ``MultiParamTypeClasses`` + ``FlexibleInstances`` + ``FlexibleContexts``). Sometimes the fact that there are different extensions, instead of a single `ExtendedTypeClasses` is mostly historical.++For that reason, it's benefitial to pack those extensions which have "graduated" in terms of stability and usefulness into a single language version.++We aim to lean on the conservative side in our selection of extensions: Not including an extension that we should have is relatively harmless (users of that extension will have to still set that manually, but they alreay have to do that, and we can add it alter), while including an extension that we should not have hurts more (any detriminal effect on developer experience now affects many users).++We also aim to have a process that is efficient. For each extension, we are all very capable of having very long discussions about the merits, up-sides and downsides, and almost anybody will have an opinion on almost any extensions. But aiming to include only _uncontroversial_ extensions, we aim to avoid much of these discussion by construction. The process deliberately does not provide room for long per-extensions deliberations, neither within the committee or with the overall community, while still involving the community.+++Proposed Change Specification+-----------------------------++We propose to introduce a process to develop new "language versions", dubbed ``GHC20XX``, which extend ``Haskell2010`` with some default extensions. This proposal does not set *which* extensions are included in the first version,, rather seeks to provide a framework to reach a conclusion in a constructive and timely manner.++Criteria+^^^^^^^^++We define a set of criteria that an extension should guide the committee members in their process of picking suitable extensions. These are not hard criteria, but often subjective, and not all need to be satisfied in all cases.++1. The extension is (mostly) *conservative*: All programs that were accepted without the extension remain accepted, and with the same meaning. We prefer to take this as a strict criteria, and grant exceptions on a case-by-case basis.+2. *New failure modes* that become possible with the extension are *rare* and/or easy to diagnose. These failure modes include new error messages, wrong inferred types, and runtime errors, for example. In other words, the *developer experience* should not get worse by adding this extension to the default mix.+3. The extensions *complement* the design of standard Haskell. For example, ``MultiParamTypeClasses`` extends what's already there, and works well with the rest of features. If we suddenly decided you can use Lisp-like syntax, that would not complement the current design.+4. The extension has been – and can reasonably be predicted to remain – *stable*.+5. The extension is one that users might plausibly want to be on all the time. This excludes experimental extensions that deliberately enable potentially-unsafe or unstable features, such as ``IncoherentInstances`` or ``MagicHash``.+6. The extension has *widespread* usage.+7. The extension is favored by the community, with many in favor, and very few opposed to its inclusion.+++Process+^^^^^^^++* 4 months before the expected GHC spring release day of 202x, the committee Secretary starts the GHC202x process.++  They inform the committe, in an email to the mailing list, of all language extensions supported by the latest released GHC that are not in GHC202(x-1), which could be added. They also list all extensions *in* GHC202(x-1), which could be removed.++  The secretary also creates a PR with a proposal saying (roughly) +   +    GHC202x contains the following extensions in addition to those in GHC202(x-1):+    +    * (none yet)+    +    and removes these extensions+   +    * (none yet)++* In order to gather data on the criterium “widespread usage”, the secretary creates a tally of which extensions are used how often on hackage.++* In order to gather data on the criterium “community spport”, the secretary runs a public poll on a suitable platform for one week where anyone
* In order to gather data on the criterium “community support”, the secretary runs a public poll on a suitable platform for one week where anyone
nomeata

comment created time in a day

PullRequestReviewEvent

Pull request review commentghc-proposals/ghc-proposals

The GHC20xx process

+The GHC20XX process+===================++.. author:: Alejandro Serrano, Joachim Breitner+.. date-accepted:: +.. proposal-number::+.. ticket-url::+.. implemented::+.. highlight:: haskell+.. header:: This proposal is `discussed at this pull request <https://github.com/ghc-proposals/ghc-proposals/pull/372>`_.+.. sectnum::+.. contents::++This proposal sets up a process to introduce new language versions `GHC20XX`, extending `Haskell2010` as defined by the Report with several extensions that are considerd harmless, helpfun and uncontroversial.+++Motivation+----------++It has almost become a meme that any slightly-complex Haskell module starts with a dozen lines of ``{-# LANGUAGE #-}`` pragmas. This poses several problems:++- beginners often see features behind an extension as "advanced" or "obscure", even though some like ``LambdaCase`` or ``NamedFieldPuns`` are quite simple;+- some sorts of programming in Haskell – mostly type-level oriented – require enables lots of extensions (think of the usual combo ``MultiParamTypeClasses`` + ``FlexibleInstances`` + ``FlexibleContexts``). Sometimes the fact that there are different extensions, instead of a single `ExtendedTypeClasses` is mostly historical.++For that reason, it's benefitial to pack those extensions which have "graduated" in terms of stability and usefulness into a single language version.++We aim to lean on the conservative side in our selection of extensions: Not including an extension that we should have is relatively harmless (users of that extension will have to still set that manually, but they alreay have to do that, and we can add it alter), while including an extension that we should not have hurts more (any detriminal effect on developer experience now affects many users).++We also aim to have a process that is efficient. For each extension, we are all very capable of having very long discussions about the merits, up-sides and downsides, and almost anybody will have an opinion on almost any extensions. But aiming to include only _uncontroversial_ extensions, we aim to avoid much of these discussion by construction. The process deliberately does not provide room for long per-extensions deliberations, neither within the committee or with the overall community, while still involving the community.+++Proposed Change Specification+-----------------------------++We propose to introduce a process to develop new "language versions", dubbed ``GHC20XX``, which extend ``Haskell2010`` with some default extensions. This proposal does not set *which* extensions are included in the first version,, rather seeks to provide a framework to reach a conclusion in a constructive and timely manner.++Criteria+^^^^^^^^++We define a set of criteria that an extension should guide the committee members in their process of picking suitable extensions. These are not hard criteria, but often subjective, and not all need to be satisfied in all cases.++1. The extension is (mostly) *conservative*: All programs that were accepted without the extension remain accepted, and with the same meaning. We prefer to take this as a strict criteria, and grant exceptions on a case-by-case basis.+2. *New failure modes* that become possible with the extension are *rare* and/or easy to diagnose. These failure modes include new error messages, wrong inferred types, and runtime errors, for example. In other words, the *developer experience* should not get worse by adding this extension to the default mix.+3. The extensions *complement* the design of standard Haskell. For example, ``MultiParamTypeClasses`` extends what's already there, and works well with the rest of features. If we suddenly decided you can use Lisp-like syntax, that would not complement the current design.+4. The extension has been – and can reasonably be predicted to remain – *stable*.+5. The extension is one that users might plausibly want to be on all the time. This excludes experimental extensions that deliberately enable potentially-unsafe or unstable features, such as ``IncoherentInstances`` or ``MagicHash``.+6. The extension has *widespread* usage.+7. The extension is favored by the community, with many in favor, and very few opposed to its inclusion.+++Process+^^^^^^^++* 4 months before the expected GHC spring release day of 202x, the committee Secretary starts the GHC202x process.++  They inform the committe, in an email to the mailing list, of all language extensions supported by the latest released GHC that are not in GHC202(x-1), which could be added. They also list all extensions *in* GHC202(x-1), which could be removed.
  They inform the committee, in an email to the mailing list, of all language extensions supported by the latest released GHC that are not in GHC202(x-1), which could be added. They also list all extensions *in* GHC202(x-1), which could be removed.

Removed from 202x, right? Not retroactively dropped from 202(x-1)?

nomeata

comment created time in a day

PullRequestReviewEvent

Pull request review commentghc-proposals/ghc-proposals

The GHC20xx process

+The GHC20XX process+===================++.. author:: Alejandro Serrano, Joachim Breitner+.. date-accepted:: +.. proposal-number::+.. ticket-url::+.. implemented::+.. highlight:: haskell+.. header:: This proposal is `discussed at this pull request <https://github.com/ghc-proposals/ghc-proposals/pull/372>`_.+.. sectnum::+.. contents::++This proposal sets up a process to introduce new language versions `GHC20XX`, extending `Haskell2010` as defined by the Report with several extensions that are considerd harmless, helpfun and uncontroversial.+++Motivation+----------++It has almost become a meme that any slightly-complex Haskell module starts with a dozen lines of ``{-# LANGUAGE #-}`` pragmas. This poses several problems:++- beginners often see features behind an extension as "advanced" or "obscure", even though some like ``LambdaCase`` or ``NamedFieldPuns`` are quite simple;+- some sorts of programming in Haskell – mostly type-level oriented – require enables lots of extensions (think of the usual combo ``MultiParamTypeClasses`` + ``FlexibleInstances`` + ``FlexibleContexts``). Sometimes the fact that there are different extensions, instead of a single `ExtendedTypeClasses` is mostly historical.++For that reason, it's benefitial to pack those extensions which have "graduated" in terms of stability and usefulness into a single language version.++We aim to lean on the conservative side in our selection of extensions: Not including an extension that we should have is relatively harmless (users of that extension will have to still set that manually, but they alreay have to do that, and we can add it alter), while including an extension that we should not have hurts more (any detriminal effect on developer experience now affects many users).++We also aim to have a process that is efficient. For each extension, we are all very capable of having very long discussions about the merits, up-sides and downsides, and almost anybody will have an opinion on almost any extensions. But aiming to include only _uncontroversial_ extensions, we aim to avoid much of these discussion by construction. The process deliberately does not provide room for long per-extensions deliberations, neither within the committee or with the overall community, while still involving the community.+++Proposed Change Specification+-----------------------------++We propose to introduce a process to develop new "language versions", dubbed ``GHC20XX``, which extend ``Haskell2010`` with some default extensions. This proposal does not set *which* extensions are included in the first version,, rather seeks to provide a framework to reach a conclusion in a constructive and timely manner.++Criteria+^^^^^^^^++We define a set of criteria that an extension should guide the committee members in their process of picking suitable extensions. These are not hard criteria, but often subjective, and not all need to be satisfied in all cases.++1. The extension is (mostly) *conservative*: All programs that were accepted without the extension remain accepted, and with the same meaning. We prefer to take this as a strict criteria, and grant exceptions on a case-by-case basis.+2. *New failure modes* that become possible with the extension are *rare* and/or easy to diagnose. These failure modes include new error messages, wrong inferred types, and runtime errors, for example. In other words, the *developer experience* should not get worse by adding this extension to the default mix.+3. The extensions *complement* the design of standard Haskell. For example, ``MultiParamTypeClasses`` extends what's already there, and works well with the rest of features. If we suddenly decided you can use Lisp-like syntax, that would not complement the current design.+4. The extension has been – and can reasonably be predicted to remain – *stable*.+5. The extension is one that users might plausibly want to be on all the time. This excludes experimental extensions that deliberately enable potentially-unsafe or unstable features, such as ``IncoherentInstances`` or ``MagicHash``.+6. The extension has *widespread* usage.

…as measured by code on e.g. hackage, presumably?

nomeata

comment created time in a day

PullRequestReviewEvent

Pull request review commentghc-proposals/ghc-proposals

The GHC20xx process

+The GHC20XX process+===================++.. author:: Alejandro Serrano, Joachim Breitner+.. date-accepted:: +.. proposal-number::+.. ticket-url::+.. implemented::+.. highlight:: haskell+.. header:: This proposal is `discussed at this pull request <https://github.com/ghc-proposals/ghc-proposals/pull/372>`_.+.. sectnum::+.. contents::++This proposal sets up a process to introduce new language versions `GHC20XX`, extending `Haskell2010` as defined by the Report with several extensions that are considerd harmless, helpfun and uncontroversial.+++Motivation+----------++It has almost become a meme that any slightly-complex Haskell module starts with a dozen lines of ``{-# LANGUAGE #-}`` pragmas. This poses several problems:++- beginners often see features behind an extension as "advanced" or "obscure", even though some like ``LambdaCase`` or ``NamedFieldPuns`` are quite simple;+- some sorts of programming in Haskell – mostly type-level oriented – require enables lots of extensions (think of the usual combo ``MultiParamTypeClasses`` + ``FlexibleInstances`` + ``FlexibleContexts``). Sometimes the fact that there are different extensions, instead of a single `ExtendedTypeClasses` is mostly historical.++For that reason, it's benefitial to pack those extensions which have "graduated" in terms of stability and usefulness into a single language version.++We aim to lean on the conservative side in our selection of extensions: Not including an extension that we should have is relatively harmless (users of that extension will have to still set that manually, but they alreay have to do that, and we can add it alter), while including an extension that we should not have hurts more (any detriminal effect on developer experience now affects many users).++We also aim to have a process that is efficient. For each extension, we are all very capable of having very long discussions about the merits, up-sides and downsides, and almost anybody will have an opinion on almost any extensions. But aiming to include only _uncontroversial_ extensions, we aim to avoid much of these discussion by construction. The process deliberately does not provide room for long per-extensions deliberations, neither within the committee or with the overall community, while still involving the community.+++Proposed Change Specification+-----------------------------++We propose to introduce a process to develop new "language versions", dubbed ``GHC20XX``, which extend ``Haskell2010`` with some default extensions. This proposal does not set *which* extensions are included in the first version,, rather seeks to provide a framework to reach a conclusion in a constructive and timely manner.++Criteria+^^^^^^^^++We define a set of criteria that an extension should guide the committee members in their process of picking suitable extensions. These are not hard criteria, but often subjective, and not all need to be satisfied in all cases.++1. The extension is (mostly) *conservative*: All programs that were accepted without the extension remain accepted, and with the same meaning. We prefer to take this as a strict criteria, and grant exceptions on a case-by-case basis.+2. *New failure modes* that become possible with the extension are *rare* and/or easy to diagnose. These failure modes include new error messages, wrong inferred types, and runtime errors, for example. In other words, the *developer experience* should not get worse by adding this extension to the default mix.

Is it worth giving an example? e.g. something that changes the semantics of existing programs (e.g. how -XScopedTypeVariables can cause type variables to start unifying in e.g. a where clause in an instance declaration)

nomeata

comment created time in a day

PullRequestReviewEvent

Pull request review commentghc-proposals/ghc-proposals

The GHC20xx process

+The GHC20XX process+===================++.. author:: Alejandro Serrano, Joachim Breitner+.. date-accepted:: +.. proposal-number::+.. ticket-url::+.. implemented::+.. highlight:: haskell+.. header:: This proposal is `discussed at this pull request <https://github.com/ghc-proposals/ghc-proposals/pull/372>`_.+.. sectnum::+.. contents::++This proposal sets up a process to introduce new language versions `GHC20XX`, extending `Haskell2010` as defined by the Report with several extensions that are considerd harmless, helpfun and uncontroversial.+++Motivation+----------++It has almost become a meme that any slightly-complex Haskell module starts with a dozen lines of ``{-# LANGUAGE #-}`` pragmas. This poses several problems:++- beginners often see features behind an extension as "advanced" or "obscure", even though some like ``LambdaCase`` or ``NamedFieldPuns`` are quite simple;+- some sorts of programming in Haskell – mostly type-level oriented – require enables lots of extensions (think of the usual combo ``MultiParamTypeClasses`` + ``FlexibleInstances`` + ``FlexibleContexts``). Sometimes the fact that there are different extensions, instead of a single `ExtendedTypeClasses` is mostly historical.++For that reason, it's benefitial to pack those extensions which have "graduated" in terms of stability and usefulness into a single language version.++We aim to lean on the conservative side in our selection of extensions: Not including an extension that we should have is relatively harmless (users of that extension will have to still set that manually, but they alreay have to do that, and we can add it alter), while including an extension that we should not have hurts more (any detriminal effect on developer experience now affects many users).++We also aim to have a process that is efficient. For each extension, we are all very capable of having very long discussions about the merits, up-sides and downsides, and almost anybody will have an opinion on almost any extensions. But aiming to include only _uncontroversial_ extensions, we aim to avoid much of these discussion by construction. The process deliberately does not provide room for long per-extensions deliberations, neither within the committee or with the overall community, while still involving the community.+++Proposed Change Specification+-----------------------------++We propose to introduce a process to develop new "language versions", dubbed ``GHC20XX``, which extend ``Haskell2010`` with some default extensions. This proposal does not set *which* extensions are included in the first version,, rather seeks to provide a framework to reach a conclusion in a constructive and timely manner.
We propose to introduce a process to develop new "language versions", dubbed ``GHC20XX``, which extend ``Haskell2010`` with some default extensions. This proposal does not set *which* extensions are included in the first version, but rather seeks to provide a framework to reach a conclusion in a constructive and timely manner.
nomeata

comment created time in a day

PullRequestReviewEvent

Pull request review commentghc-proposals/ghc-proposals

The GHC20xx process

+The GHC20XX process+===================++.. author:: Alejandro Serrano, Joachim Breitner+.. date-accepted:: +.. proposal-number::+.. ticket-url::+.. implemented::+.. highlight:: haskell+.. header:: This proposal is `discussed at this pull request <https://github.com/ghc-proposals/ghc-proposals/pull/372>`_.+.. sectnum::+.. contents::++This proposal sets up a process to introduce new language versions `GHC20XX`, extending `Haskell2010` as defined by the Report with several extensions that are considerd harmless, helpfun and uncontroversial.+++Motivation+----------++It has almost become a meme that any slightly-complex Haskell module starts with a dozen lines of ``{-# LANGUAGE #-}`` pragmas. This poses several problems:++- beginners often see features behind an extension as "advanced" or "obscure", even though some like ``LambdaCase`` or ``NamedFieldPuns`` are quite simple;+- some sorts of programming in Haskell – mostly type-level oriented – require enables lots of extensions (think of the usual combo ``MultiParamTypeClasses`` + ``FlexibleInstances`` + ``FlexibleContexts``). Sometimes the fact that there are different extensions, instead of a single `ExtendedTypeClasses` is mostly historical.++For that reason, it's benefitial to pack those extensions which have "graduated" in terms of stability and usefulness into a single language version.++We aim to lean on the conservative side in our selection of extensions: Not including an extension that we should have is relatively harmless (users of that extension will have to still set that manually, but they alreay have to do that, and we can add it alter), while including an extension that we should not have hurts more (any detriminal effect on developer experience now affects many users).++We also aim to have a process that is efficient. For each extension, we are all very capable of having very long discussions about the merits, up-sides and downsides, and almost anybody will have an opinion on almost any extensions. But aiming to include only _uncontroversial_ extensions, we aim to avoid much of these discussion by construction. The process deliberately does not provide room for long per-extensions deliberations, neither within the committee or with the overall community, while still involving the community.

I’m curious what “uncontroversial” means, but haven’t finished reading yet. I don’t know if that suggests the doc should discuss this more up front or that it’s working well as a hook, tho 😄

nomeata

comment created time in a day

PullRequestReviewEvent

Pull request review commentghc-proposals/ghc-proposals

The GHC20xx process

+The GHC20XX process+===================++.. author:: Alejandro Serrano, Joachim Breitner+.. date-accepted:: +.. proposal-number::+.. ticket-url::+.. implemented::+.. highlight:: haskell+.. header:: This proposal is `discussed at this pull request <https://github.com/ghc-proposals/ghc-proposals/pull/372>`_.+.. sectnum::+.. contents::++This proposal sets up a process to introduce new language versions `GHC20XX`, extending `Haskell2010` as defined by the Report with several extensions that are considerd harmless, helpfun and uncontroversial.+++Motivation+----------++It has almost become a meme that any slightly-complex Haskell module starts with a dozen lines of ``{-# LANGUAGE #-}`` pragmas. This poses several problems:++- beginners often see features behind an extension as "advanced" or "obscure", even though some like ``LambdaCase`` or ``NamedFieldPuns`` are quite simple;+- some sorts of programming in Haskell – mostly type-level oriented – require enables lots of extensions (think of the usual combo ``MultiParamTypeClasses`` + ``FlexibleInstances`` + ``FlexibleContexts``). Sometimes the fact that there are different extensions, instead of a single `ExtendedTypeClasses` is mostly historical.++For that reason, it's benefitial to pack those extensions which have "graduated" in terms of stability and usefulness into a single language version.
For that reason, it's beneficial to pack those extensions which have "graduated" in terms of stability and usefulness into a single language version.

FWIW I think this idea of a feature “graduating” is an excellent litmus test.

nomeata

comment created time in a day

PullRequestReviewEvent

Pull request review commentghc-proposals/ghc-proposals

The GHC20xx process

+The GHC20XX process+===================++.. author:: Alejandro Serrano, Joachim Breitner+.. date-accepted:: +.. proposal-number::+.. ticket-url::+.. implemented::+.. highlight:: haskell+.. header:: This proposal is `discussed at this pull request <https://github.com/ghc-proposals/ghc-proposals/pull/372>`_.+.. sectnum::+.. contents::++This proposal sets up a process to introduce new language versions `GHC20XX`, extending `Haskell2010` as defined by the Report with several extensions that are considerd harmless, helpfun and uncontroversial.
This proposal sets up a process to introduce new language versions `GHC20XX`, extending `Haskell2010` as defined by the Report with several extensions that are considerd harmless, helpful and uncontroversial.
nomeata

comment created time in a day

PullRequestReviewEvent

Pull request review commentghc-proposals/ghc-proposals

The GHC20xx process

+The GHC20XX process+===================++.. author:: Alejandro Serrano, Joachim Breitner+.. date-accepted:: +.. proposal-number::+.. ticket-url::+.. implemented::+.. highlight:: haskell+.. header:: This proposal is `discussed at this pull request <https://github.com/ghc-proposals/ghc-proposals/pull/372>`_.+.. sectnum::+.. contents::++This proposal sets up a process to introduce new language versions `GHC20XX`, extending `Haskell2010` as defined by the Report with several extensions that are considerd harmless, helpfun and uncontroversial.+++Motivation+----------++It has almost become a meme that any slightly-complex Haskell module starts with a dozen lines of ``{-# LANGUAGE #-}`` pragmas. This poses several problems:++- beginners often see features behind an extension as "advanced" or "obscure", even though some like ``LambdaCase`` or ``NamedFieldPuns`` are quite simple;+- some sorts of programming in Haskell – mostly type-level oriented – require enables lots of extensions (think of the usual combo ``MultiParamTypeClasses`` + ``FlexibleInstances`` + ``FlexibleContexts``). Sometimes the fact that there are different extensions, instead of a single `ExtendedTypeClasses` is mostly historical.++For that reason, it's benefitial to pack those extensions which have "graduated" in terms of stability and usefulness into a single language version.++We aim to lean on the conservative side in our selection of extensions: Not including an extension that we should have is relatively harmless (users of that extension will have to still set that manually, but they alreay have to do that, and we can add it alter), while including an extension that we should not have hurts more (any detriminal effect on developer experience now affects many users).

This is a bit of a run-on sentence, and I found it a bit hard to parse. Maybe breaking it up after the first parenthetical:

…we can add it later). Conversely, including an extension which we shouldn’t have hurts more…

nomeata

comment created time in a day

PullRequestReviewEvent

Pull request review commentghc-proposals/ghc-proposals

The GHC20xx process

+The GHC20XX process+===================++.. author:: Alejandro Serrano, Joachim Breitner+.. date-accepted:: +.. proposal-number::+.. ticket-url::+.. implemented::+.. highlight:: haskell+.. header:: This proposal is `discussed at this pull request <https://github.com/ghc-proposals/ghc-proposals/pull/372>`_.+.. sectnum::+.. contents::++This proposal sets up a process to introduce new language versions `GHC20XX`, extending `Haskell2010` as defined by the Report with several extensions that are considerd harmless, helpfun and uncontroversial.+++Motivation+----------++It has almost become a meme that any slightly-complex Haskell module starts with a dozen lines of ``{-# LANGUAGE #-}`` pragmas. This poses several problems:++- beginners often see features behind an extension as "advanced" or "obscure", even though some like ``LambdaCase`` or ``NamedFieldPuns`` are quite simple;+- some sorts of programming in Haskell – mostly type-level oriented – require enables lots of extensions (think of the usual combo ``MultiParamTypeClasses`` + ``FlexibleInstances`` + ``FlexibleContexts``). Sometimes the fact that there are different extensions, instead of a single `ExtendedTypeClasses` is mostly historical.++For that reason, it's benefitial to pack those extensions which have "graduated" in terms of stability and usefulness into a single language version.++We aim to lean on the conservative side in our selection of extensions: Not including an extension that we should have is relatively harmless (users of that extension will have to still set that manually, but they alreay have to do that, and we can add it alter), while including an extension that we should not have hurts more (any detriminal effect on developer experience now affects many users).
We aim to lean on the conservative side in our selection of extensions: Not including an extension that we should have is relatively harmless (users of that extension will have to still set that manually, but they alreay have to do that, and we can add it later), while including an extension that we should not have hurts more (any detriminal effect on developer experience now affects many users).
nomeata

comment created time in a day

PullRequestReviewEvent

push eventrobrix/facet

Rob Rix

commit sha 1e9fcb812a6f0fcd61a617d91bdfc4b99d827724

Fix a couple of parse errors through particularly egregious means.

view details

Rob Rix

commit sha 38b29a12f947904b46f7cbe226c41779668d14e9

Spacing.

view details

Rob Rix

commit sha 86f66b6b29664f44bde1d66415d4787d9f5b292a

Add a fixme about operator names.

view details

Rob Rix

commit sha 066372faad680812e0c2de987e1f0465ff91bfb7

Duplicate the module rule.

view details

Rob Rix

commit sha 470e9d049155eadb6550a2b3f31f54d3bc4953f7

Give module'' a continuation to give feedback on modules.

view details

push time in 2 days

push eventrobrix/facet

Rob Rix

commit sha 5e03de948fca455a70d25abc9c383d9b90ea6413

:fire: a fixed FIXME.

view details

Rob Rix

commit sha 7a6099b8111c1cb53c1ae803f65f3d8ab0dda816

Correct a comment.

view details

Rob Rix

commit sha 6938294e03ccb8fcd46e2ad9733072a7993ebcd7

Define associative operators.

view details

Rob Rix

commit sha baf8a44f48d4c072c7b9d7a2a92fe288bb561a3f

Clarify that these are operator names.

view details

Rob Rix

commit sha 6ed6827d3c74f5181ea059164407b01d145fe8c2

Don’t include the associativity in the name.

view details

Rob Rix

commit sha e69ac17d893b3708f5755b2716e83568d5e9d23c

:fire: a fixed FIXME: we shouldn’t.

view details

Rob Rix

commit sha ea45e76fe01c35eaf9cfa9dcda345939c2f93b68

Parse the colon after acting on the operator name.

view details

Rob Rix

commit sha c90647925e6f08aee33e2a95b7246e9dcc0fb6cc

Don’t include the associativity in the name.

view details

Rob Rix

commit sha f59bf58ca058ce1641cc2e6f5d1d358759a9f7c7

:fire: a fixed FIXME: we shouldn’t.

view details

Rob Rix

commit sha d7c6af3fb237fee7020200706dade5a6aa01245e

Parse fixities following infix operator declarations.

view details

Rob Rix

commit sha c3c6f7b8c4e54686c48528d1f1bf6901de140b91

Declare fixities for the various function composition/application operators.

view details

push time in 2 days

push eventrobrix/dotfiles

Rob Rix

commit sha 8619a52ad1bdf031eddcdb3fce89b0696551d30f

While we’re at it, drop who to follow.

view details

Rob Rix

commit sha 61ecf5b6cdb94a66d8c36a4f70bc9f5e06205a98

It’s an aside, not a div.

view details

push time in 2 days

push eventrobrix/dotfiles

Rob Rix

commit sha dbcaa1c593aee8ab507a6d086ffb4f9c9f3ba56c

Turn off the timeline trends on the hellsite.

view details

push time in 2 days

push eventrobrix/facet

Rob Rix

commit sha 1a45556bde22974d2b0a8ff728ad1ec43854f63a

Spacing.

view details

Rob Rix

commit sha e446f60c7e1ae0e8029ff7cfc7877087845e8bb9

Add a heading.

view details

Rob Rix

commit sha c69e6694d046db45697acbb602b0d256a587fb94

Define a handler interpreting Error into Either.

view details

Rob Rix

commit sha 319145b731a2baf788955214508cf3b6500dd0ca

Spacing.

view details

Rob Rix

commit sha 64636700072f601b5fbeac749e888db5ec63489e

Add a heading.

view details

Rob Rix

commit sha e290b6da7e6ecce3e6d70acb294daf53f6ef9f3c

Add a method for effect patterns.

view details

Rob Rix

commit sha a234090aa06a9cf0d8b6d5b81373fc4e8e06103e

:fire: a fixed FIXME.

view details

Rob Rix

commit sha 818f6aa91f0a8ed76d1747eb6f3848f69a274edd

Destructure the argument binding up front.

view details

Rob Rix

commit sha 6e51c9cc27cb21f0d25d9b696af8849944049602

Define effect patterns in the surface AST.

view details

Rob Rix

commit sha 1bec9f258d324b075646dac19c5e29f7ef1340ef

Use a lambda to match errors.

view details

Rob Rix

commit sha edce9596739bbf3bf82e1cdc642f5b4134524dda

We need to handle the effect in the success continuation too.

view details

Rob Rix

commit sha 395a788293fd5a5d84ed72f508a84cd44002667b

:fire: done TODOs.

view details

Rob Rix

commit sha 3aafb05d3d75d32c2adab03e561f37567ab1b1cd

Use the correct name for the Either constructors.

view details

Rob Rix

commit sha 3dcd2eb03879905541ac6f37972ef6f890ff6922

Define an except operation.

view details

Rob Rix

commit sha 2e94471c55209f86dc746efdf7da13c9af395d7b

Parse effect patterns into the surface syntax.

view details

Rob Rix

commit sha 912ec34e9ca02c080dbed264fa5d38fd47c04572

Bind our type variables.

view details

Rob Rix

commit sha 325c5d1a4d37ad1e3b30d05194ba54a397f8edf1

:fire: BadContext errors.

view details

Rob Rix

commit sha 3658bf2de39225787c0d9d56422553ad3a39a9dd

:fire: language extensions.

view details

Rob Rix

commit sha b526e93f31904a6b81ac2a3b75cca073dcc325aa

Align.

view details

Rob Rix

commit sha dc757cbf8991c1e8176bfc35d0601ca6c9feadd0

Define a synonym for rows.

view details

push time in 2 days

push eventrobrix/facet

Rob Rix

commit sha dc21b42759cfce58078589718ffcf3f4f46ef3f2

Handle any errors in the load process.

view details

Rob Rix

commit sha ad639f7de8eb11ff00fc6e133bca6c4c14a311fb

Implement extending the search pths.

view details

Rob Rix

commit sha de8d1ffd22a9b72d8f7cccf6e7a6b6b36f2d0a0c

Store a set of search paths.

view details

Rob Rix

commit sha 27d088522d87fef74066b7be2d30d12f29dd10bd

Remove modules & search paths.

view details

Rob Rix

commit sha 4d8650e920971693554999a07d19af5ff6e492fb

Factor whole around.

view details

Rob Rix

commit sha 2c4f7569abe37cf6b8d1c8768bf7193e1a902e4e

We already parse the whole command.

view details

Rob Rix

commit sha aaf337e6f163ec25d1ccbd407d08741856993dd0

Define a module for an error effect.

view details

Rob Rix

commit sha c9c47c85b14c25ea273fdeab33a81b11b8ab8c6b

Define an Error effect.

view details

Rob Rix

commit sha d6cb18280f400f5e98c6513f6f2069e319afba4b

Define a flipped catch.

view details

Rob Rix

commit sha a230477335ee77e5f42f39defb51cb25bf2e1af6

Define a try operator.

view details

Rob Rix

commit sha ddd79da20a18336aac515590465b66e843189a01

Bind our type parameters.

view details

Rob Rix

commit sha 94cc4a78364d3d037d6b1f9b636a35d1640a019c

Define an error handler in CPS.

view details

Rob Rix

commit sha 9f9388b19d32ebb6aff8decc7e9b2722902cecac

Allow wildcards to match continuations.

view details

Rob Rix

commit sha a8a53574d5af674f1b9f22f1947bb155b085e07b

Import Data.Function.

view details

push time in 2 days

push eventrobrix/facet

Rob Rix

commit sha 6e7619bca5a54f0059f8114fcb5428050eb4b9df

Keep the parsed surface module for each file.

view details

Rob Rix

commit sha 0b644a94cbd8d822e407e22ee02320e541674474

Don’t re-export Notice from Facet.Notice.*.

view details

Rob Rix

commit sha 502af334281c39e079fad662a85b517100374a7d

Keep the source on loaded files.

view details

Rob Rix

commit sha 52c78405d5d5ee8cd3cb3bd0bd7d9a9051d8acbc

Spacing.

view details

Rob Rix

commit sha c965144d2f6b89d37a68a7f7dad883e4299bd79a

Update the state incrementally.

view details

Rob Rix

commit sha 98cfbe7a1c845681e6ee90bbd30c895f9d6f8aec

Store the elaborated module.

view details

Rob Rix

commit sha 3a9e020f99dcdbdd2c74fc950749df7e11dc2c30

Get the modification time when loading modules.

view details

Rob Rix

commit sha 765c29d5406bc4e8318f689713623e97cc406d0c

Define a helper to rethrow IOErrors.

view details

Rob Rix

commit sha 0b26126486b7ce9c0a14a72b13f0ae3986383891

Fix indentation.

view details

Rob Rix

commit sha ebea94bf5f36d3eabd8968a2e3ce8b12c89d5d1d

Reload when the file has been modified.

view details

Rob Rix

commit sha d862deb06c97542ad3203245cdd04eb6215a52fa

Avoid resetting the time.

view details

Rob Rix

commit sha 6154bb410f218688d43af1416bd7f64bb246c50f

:fire: a fixed FIXME.

view details

Rob Rix

commit sha d6c2808237d5d37de535859a14713f1ddaf0d7f1

Test reloads by file contents.

view details

push time in 2 days

push eventrobrix/facet

Rob Rix

commit sha 8418286093f0fee5f338e22e618ce9db687fcac8

Add search paths to the REPL.

view details

Rob Rix

commit sha eec9add0b635365fdd7e7c948d56d4d2a5ad7aa4

:fire: a fixed FIXME.

view details

Rob Rix

commit sha ab3f38d25d8378b7cff56d2f4b580086a5cc192e

Close the import of Data.Semigroup.

view details

Rob Rix

commit sha 8794933137dc7ad3be78f3d2487e5cc19aad0abf

Add helpers to format with hard line breaks.

view details

Rob Rix

commit sha 7a827fd9f99ec19a750b3f456ebc4e5b66d405a0

Define an action to show REPL state. Currently this is limited to the search paths.

view details

Rob Rix

commit sha 8627876585a45655d97da8a66aa490e53e3e9671

Add a command to show the paths.

view details

Rob Rix

commit sha 1f753b1fd83e294a1d40fec43b86968801597208

Reformat the Show target parsers.

view details

Rob Rix

commit sha 5b9809a70bdd68eec54c1cab66bd5c23e117f1dc

Show modules.

view details

Rob Rix

commit sha 4368bd354831ea676b4096e758593dec4c5abc74

Add a FIXME about module names.

view details

Rob Rix

commit sha a764a6312b2d670831f8bdebbc0f05bb4e32511a

Add a FIXME about loading multiple packages.

view details

push time in 2 days

push eventrobrix/facet

Rob Rix

commit sha 6f388d6de52721109db0dcfb7e38eafa40ca96ed

Define failure & success styles.

view details

Rob Rix

commit sha fcd311ef3d68bcd7be9fbad2614c3b4c74b8c5c4

Highlight the failure/success message with Style.

view details

Rob Rix

commit sha ccf40937f217ddb551bc8419d172548dcc84dca0

Define a Progress style.

view details

Rob Rix

commit sha c0e48c28986c0b73167894da30372d3825abcde2

Highlight the progress message with Style.

view details

Rob Rix

commit sha 7d6a49d4093fdded664041b71625c15a04d1bbce

Print everything with Style.

view details

push time in 2 days

push eventrobrix/facet

Rob Rix

commit sha b47e18d836f6b42d9eb5d24e1478fc987deb68e6

Did these.

view details

Rob Rix

commit sha a267e20e9eb9c4dff76876ff009404b31105e134

Align.

view details

Rob Rix

commit sha 7b1d281c262b23c2fd529adf8f0913ffc291f47a

Rename state to runState.

view details

Rob Rix

commit sha 4c9b7013de2cdabdf9c54d79ec6169899025fdb1

Rename church to state.

view details

Rob Rix

commit sha c68b207db19526b30247305cdd7ea6c59702b0d6

Define an execState handler.

view details

Rob Rix

commit sha fe1a3b670984a1877a57bb98502c0e8d297cf95d

Add a FIXME about extending surface quantifier syntax.

view details

Rob Rix

commit sha 3027deeb068338addb36dd4ff22d3c338bf4d8a6

Move imports after the module type.

view details

Rob Rix

commit sha ce9f18152b0772a8e64273840f2539e3bcf8e24c

:fire: Quote.

view details

Rob Rix

commit sha e112cce09ad57f45b5335433af1acac629aebed1

Factor out the common portion of printing variables.

view details

Rob Rix

commit sha 86c42926370fe300db6d7a71de5c947f10e057c9

Give a type signature for printVar.

view details

Rob Rix

commit sha ff252a2f3dc9a63878f6893a73e46c58ab3b48ab

Define explicit as a delta on surfce.

view details

Rob Rix

commit sha 79edc4166bd2ab193dbe93a6b8ac7e57ce8d3c7e

Extract the body of == to the top level.

view details

Rob Rix

commit sha f40b6aa64c6c1463f8d70daf7114c04fcce2524b

Export eq.

view details

Rob Rix

commit sha ebc1a2797e53d674f2b6fc50e8f58edd6118eb16

:fire: ScopedTypeVariables.

view details

Rob Rix

commit sha 15950d9a1960e9ead4af73224e91c2d32b762809

Allow algebras to represent multiple bindings at a time.

view details

Rob Rix

commit sha 63ec952b043e365a639eb76c91054f877490da38

Add a FIXME re: lambda vars.

view details

Rob Rix

commit sha e0dc02d264867ce9821148bb53c18a422a2c2473

Parse imports.

view details

Rob Rix

commit sha 3b56c61a6bfd16fe0297e7b96ba74eb59614ffe6

Don’t wrap a result type in braces. It’s unambiguous from the signature adjustment preceding it.

view details

Rob Rix

commit sha 715335e0dec88f536dc0840684a58f2df6eec5ed

Rename sig to typeSig.

view details

Rob Rix

commit sha 790e5641a941e53bc8d272d0dcd9c44e2d86e70e

Rename spanned to anned.

view details

push time in 2 days

push eventrobrix/facet

Rob Rix

commit sha 6f6265d98aef6a73dac680ccaa474ff91668018a

Define a unit signature.

view details

Rob Rix

commit sha 2a1c8b41ab5587c777d64d80d820fde5b3fa7c72

Import Facet.Core open.

view details

Rob Rix

commit sha 087c85fc56d18e902c1dce747b64f87792cd01ca

Define a kernel module.

view details

Rob Rix

commit sha 8874074f4f0eabc1ef3d7683fba8365d41b66dfe

:fire: redundant parens.

view details

Rob Rix

commit sha a4d6b1375cca4c95f497154d953d8b4735920152

DNames hold UNames.

view details

Rob Rix

commit sha 7a7c27e2d6e142985ede2133227ce8df256468a6

:fire: EName/TName in the lexer.

view details

Rob Rix

commit sha 316f3c0132807ca3afe69aacfc73a5ec59bbe4da

Don’t distinguish ENames in the parser.

view details

Rob Rix

commit sha 7506632535515b06a8ffffc3ddcf9a0cbee27e8b

Don’t distinguish TNames in the parser.

view details

Rob Rix

commit sha 97fc658eaac579c82cb29650aab0c1f84f886105

:fire: TName.

view details

Rob Rix

commit sha bddf9e8088686ccb0867addaf0dee165e02537cd

:fire: EName.

view details

Rob Rix

commit sha 48b34bd370dd52b718825d26c127ab12442ae10f

Use UName in place of CName.

view details

Rob Rix

commit sha e0ae39c0ae958eb5bd51c7472e3b16c811725d09

:fire: CName.

view details

Rob Rix

commit sha d5fefde1d92865c7428363b62856a739381f5e41

Import Facet.Name open.

view details

Rob Rix

commit sha c066bce32e744030d0a2f5924c7f996a7cfb43d2

Add Type to the Kernel module.

view details

Rob Rix

commit sha c7750adde355c8fdde79624bc9acf9d4a1e24e85

Monomorphize Env.

view details

Rob Rix

commit sha 1ce96e74f4fd59037af81762b270154d67c8c2ac

Record the constructor functions in the module.

view details

Rob Rix

commit sha 1b96e9f7cba5e5069cb74bdb1cc5e1c1ae11ea22

Construct environments from modules.

view details

Rob Rix

commit sha ec60b347591a62d5fa7c82dea4fdab15ad8c85e7

Spacing.

view details

Rob Rix

commit sha a965d0ee7f63a37970b686505dfb8cfb4abc3af3

Load the kernel module into the default environment.

view details

Rob Rix

commit sha 1118bdd1f2c0d8cd81c63a8fa7bfacab82c6fc48

Define a Pair module.

view details

push time in 2 days

issue commenthaskell/vscode-haskell

Duplicate hints, popups, and processes

(I suspect this is what @bubba meant by standalone, above.)

robrix

comment created time in 2 days

issue commenthaskell/vscode-haskell

Duplicate hints, popups, and processes

I think I’ve isolated the cause: when you copy some code from one file, make a new empty buffer, and immediately paste that code in, VS Code changes the new (unsaved) buffer’s language mode to the language of the code you copied in. So if you copy some Haskell code into an empty buffer temporarily, you have an (unsaved) Haskell file, which the extension then tries to work with; but (presumably because it doesn’t actually exist as a file within the project) it doesn’t use the existing hls process but rather spins up a new one.

I don’t know why that causes the Haskell files which are actually in the project to ask for & disply results from both hls processes—it really does seem like the new process loads the whole project and not just the one file cos its memory usage is disproportionate for just a single buffer—but since I’ve started being careful about my empty buffers, I’ve stopped having duplicate processes & results, which was otherwise a daily occurrence.

robrix

comment created time in 2 days

push eventrobrix/facet

Rob Rix

commit sha 81edd99a360a866ff7262c13932f6c0916ceaa76

Move a FIXME to where it applies.

view details

push time in 3 days

push eventrobrix/facet

Rob Rix

commit sha 9bdea114845966f3ed0f07eba45a3df2c578e989

Simplify |-* slightly.

view details

Rob Rix

commit sha ef05dff08de0e8455c2de10611436f88cb346225

:fire: QExpr.

view details

Rob Rix

commit sha d249e889c88449f1e99f24e1add2bb47281432f5

Define a helper to traverse a pattern, filling it with local variables. It can do a lot of other things too but that’s what I need it for.

view details

Rob Rix

commit sha 3010f68a29cfd72edd883dae4e585850ed24cecd

Compute the set of metavariables in a term.

view details

Rob Rix

commit sha 45cd357fcabb5522a2d549947bf99ba2dffee4af

Collect metas’ types.

view details

Rob Rix

commit sha 72e9e2a89d4818fb9ee62778125029baf302e9e1

Define a helper to generalize the metas in a value.

view details

Rob Rix

commit sha 03b88cf5d9c0b7ebc924a910b3be2633c2056454

Always print names for implicits.

view details

Rob Rix

commit sha 4bab290a93c546677999d988594fec02181c6258

Generalize types and kinds when printing.

view details

push time in 3 days

push eventrobrix/facet

Rob Rix

commit sha 3f4fc0d2652a4bef7c023450a0040f41527ccd93

Specialize the Eq instance for Value.

view details

Rob Rix

commit sha 58dd24586ca24eaf98f9ef515ef492e89e5658f6

Only hide the names of explicit term binders.

view details

push time in 3 days

push eventrobrix/facet

Rob Rix

commit sha c9b94249914a5dea259259007c0ca9b760827567

Add a note about warning on constructor/variable name overlap.

view details

Rob Rix

commit sha 13d1fcf50f84bf987588b3655d63faac0e4ef18a

Add a note about signature syntax.

view details

Rob Rix

commit sha 67610aaaf8379ed63e1b4c676ae58d824c89521c

Add a note about scoped effects.

view details

Rob Rix

commit sha f42a0449989036de0b5e133933c1e56f2cf8b83c

Add a note about matching effect patterns with square brackets.

view details

Rob Rix

commit sha 932f4319134408cb75267dad522ffc3530094b65

Add a handler for Reader.

view details

Rob Rix

commit sha 2a89bf953474c61e223d148284c5c00ca98e71fa

Add some notes about docs & module syntax.

view details

Rob Rix

commit sha fe81a4c1219ad24763b9024e74543c75a0e7a384

Define a handler for State.

view details

Rob Rix

commit sha 33bad40e6a2f8d559651f66a6556ac5da0ae54ab

Rename state to evalState.

view details

Rob Rix

commit sha 38c5e0dd849e7e30de1ea2932efe145390e46be6

Add a normal, pairing handler for State.

view details

Rob Rix

commit sha f56151d976dff950dd95701130a13d5498927120

Define a CPS State handler.

view details

Rob Rix

commit sha 9433d287779d2720d15f5b6390ecf7293dc793d0

Define the pairing State handler in terms of the CPS one.

view details

Rob Rix

commit sha db93a5e745114ee7e5ecbc74a8986e2f3bd48e2d

Define evalState in terms of church.

view details

Rob Rix

commit sha 35cf6ee028f69a47a376f1c6f5ce00b8fb7d5282

Move all the facet sources around.

view details

push time in 3 days

push eventrobrix/facet

Rob Rix

commit sha a08d10f95fe1614bb81bbb085585000816b7cc2f

Got a little overzealous with the renaming there.

view details

Rob Rix

commit sha 254251a70f6f0e76dd943f984b7404115bf5cf70

Define a State effect module.

view details

Rob Rix

commit sha 5414ed661546c9a755b3d819258d753d516bb6b5

Define a State effect interface.

view details

Rob Rix

commit sha 23c7ba33d0dc6fe90fe528d7af911849eacca187

We need Unit in scope.

view details

Rob Rix

commit sha 45e8ead48f8b415e74875b6ee64343906cb6f119

Add a bunch of notes about linearity and polarity.

view details

Rob Rix

commit sha 20a716765560951910c9711d02a90ae3f65de3bc

Define a module for lists.

view details

Rob Rix

commit sha 731b83389da9b0a403ed2a313c19c10395c4e0db

Define a List datatype

view details

Rob Rix

commit sha 20cfb8c57cfc9ad5483d5e894106a1023e42ad40

Define map over lists.

view details

Rob Rix

commit sha 8ddab6a201ea56bc971a1a41597a23ea777d16e9

Add a fixme about implicits.

view details

Rob Rix

commit sha 593c559b4bc0d0a4e977c094f6262269c8920528

Tighten the span around constructor patterns.

view details

Rob Rix

commit sha 44599dce4e278872308fa15d7771890eeafd8d4c

Define a Facet.Lexer module.

view details

Rob Rix

commit sha db8cf96c479f303600cae854e06e83a8a7c881c9

Weaken PositionParsing’s superclass all the way to Parsing.

view details

Rob Rix

commit sha 65c343caa9895d80096bd718f3f1df6d0d56484c

Define token kinds.

view details

Rob Rix

commit sha e5b1d18dfb07c6f6018815b46280f2fdcbd35145

Define tokens.

view details

Rob Rix

commit sha be6626c632d1840dee712535148814710cf97818

Define a parser for line comments.

view details

Rob Rix

commit sha 34dc55504f5f0288a3608058ab237712bf3a581e

Define a parser for tokens.

view details

Rob Rix

commit sha 696ca98faec0ac71f51940b95570211abe62eb2b

Skip whitespace after tokens.

view details

Rob Rix

commit sha dd2047a613b435dd3ffce83005c478f1c78a0b60

Lex underscores.

view details

Rob Rix

commit sha 7e2ef4587415b1be8b7b90408ade156ba73e59a0

Lex colons.

view details

Rob Rix

commit sha b814015444e3a6c0c27002a04a2e44c04a1cd71c

Lex parens and braces.

view details

push time in 3 days

push eventrobrix/facet

Rob Rix

commit sha e04eb74b7edfaa0517a9e5f56b13fd35839e8ff0

Add some notes about pattern elaboration.

view details

push time in 3 days

push eventrobrix/facet

Rob Rix

commit sha c29476767b7313aec16f6401c59a6e7900fa2a7f

Surface constructor patterns hold a stack.

view details

Rob Rix

commit sha 66167aea86bf27f13fa64be14de11ed02fc56b1e

Move the quantifier expectation down.

view details

push time in 3 days

push eventrobrix/facet

Rob Rix

commit sha 139c04936a058512d02978a0d60bdc4669f18c89

Add headings to Facet.Algebra.

view details

Rob Rix

commit sha 4cba343907a633d87e2341c4141e16870452bdbd

Eliminate var patterns eagerly in case'.

view details

Rob Rix

commit sha b7ea28b047a689d50cc567fa420c52650a3bd0e8

Only apply var patterns at the head of the list.

view details

Rob Rix

commit sha dcaf8fed2760fbe8d0a9ebd31700f055abcb50c6

Wrap cases.

view details

Rob Rix

commit sha f5315b35724dc8bd8c695df626522034c8548ec6

Wrap cases in the surface algebra too.

view details

Rob Rix

commit sha c054a3954cd9c86d530ebfd7b89ac2ee3efb0821

Define boolean disjunction.

view details

push time in 4 days

push eventrobrix/facet

Rob Rix

commit sha 472b555b50ed742b1674b80c4606761993b34f8e

Spacing.

view details

Rob Rix

commit sha 1e001444e2dface017d84d84e46d87b577039bbe

Turn on a bunch of default extensions.

view details

Rob Rix

commit sha adf6474b13853536cc03d6940df93cab41781cb8

Turn on the same set of exceptions in the ghci-flags script.

view details

Rob Rix

commit sha c84b554842c9e7f179e85779bb54ad476152a1d1

:fire: pretty much all of the per-file extensions.

view details

Rob Rix

commit sha e5035f1e46512bc5f8935436b3269c401799f06b

:fire: some redundant extensions.

view details

Rob Rix

commit sha b70c68ccb352a91050c93bb396a558f256f86526

Merge pull request #4 from robrix/default-extensions Default extensions

view details

push time in 4 days

delete branch robrix/facet

delete branch : default-extensions

delete time in 4 days

PR merged robrix/facet

Default extensions

This PR uses the default-extensions field to eliminate a bunch of the file-by-file extensions. I don’t normally do this sort of thing, because it can break tooling, but tooling is better than ever now and so I’m taking it for a spin.

Dedicated to @lexi-lambda, @mbbx6spp, & @chshersh 😅

+35 -112

0 comment

28 changed files

robrix

pr closed time in 4 days

PR opened robrix/facet

Default extensions

This PR uses the default-extensions field to eliminate a bunch of the file-by-file extensions. I don’t normally do this sort of thing, because it can break tooling, but tooling is better than ever now and so I’m taking it for a spin.

Dedicated to @lexi-lambda, @mbbx6spp, & @chshersh 😅

+35 -112

0 comment

28 changed files

pr created time in 4 days

create barnchrobrix/facet

branch : default-extensions

created branch time in 4 days

push eventrobrix/facet

Rob Rix

commit sha 47ff393930406fa56b6928a95ba2b510dc8fb549

Define a Base.Map module.

view details

Rob Rix

commit sha 396cc68513c5805dc75d7aa9b16f47f86819bc25

Define Map.

view details

Rob Rix

commit sha c9544021a4e4f35803189b989e02c7a344e88236

Reformat.

view details

Rob Rix

commit sha 46e4a3eb357eb65ce57c036fcdbc241c481ee32f

Label the commands en masse.

view details

Rob Rix

commit sha 69cc6d649874f54dfa4f0f8a512a2a318f243dea

Push more into the command parser.

view details

Rob Rix

commit sha 457552b0151228b0e5b8afac433e554d8b574591

Define an Eval Action.

view details

Rob Rix

commit sha 53fec629df7bf8d321ce7267064bfe9fdb4ecb21

Spacing.

view details

Rob Rix

commit sha 8aa9d9bb2dfc9058faa3ade2c3745a8e1bf8ac21

Define a parser for qualified names.

view details

Rob Rix

commit sha 3cade2f60ad91df120e8e1849041e53bc78ea6c8

Represent holes with UNames.

view details

Rob Rix

commit sha 279129ac737eaf2e73e788a3abf19370c4c72b78

:fire: aeq.

view details

Rob Rix

commit sha 77f4f2a1c17617652c34168709701fb700697fa1

Define a Pretty instance for MName.

view details

Rob Rix

commit sha fb5fe538856d6126963cd84aa15db5baf3e280ff

We can just say dot.

view details

Rob Rix

commit sha a667ba9403145515319687c6f10ad9c5968bed24

Define a Pretty instance for QName.

view details

Rob Rix

commit sha ffe1497b0149dc9ddec386cbe5bf0f8d9489dbeb

:fire: prettyMName.

view details

Rob Rix

commit sha 265822c391e9ddf68a5debdb4e6dd6cfcc9f6ff1

FreeVariable can have a qualifier.

view details

Rob Rix

commit sha 5551aacf5d52b1342e7ad02cebe62c51e0793ca5

Print the qualifier, if there is one.

view details

Rob Rix

commit sha 50e673e41bbb1f8160c35aaa70cd92950479c0ec

Define a helper to resolve a qualified name.

view details

Rob Rix

commit sha 9f6ef17f6b92495085b6be392073d7327d84a9b9

global takes a resolved name.

view details

Rob Rix

commit sha ad1ded98c2f9a4b8f3763c638a5c56d75b04ba29

Add qualified names to the surface syntax.

view details

Rob Rix

commit sha 9fdfdd3cf6be348c40d83acb0d6e335468a7b489

Parse qualified expression names.

view details

push time in 4 days

push eventrobrix/facet

Rob Rix

commit sha bf9dc63f0c857af46e18e8194b0049fc25b3d105

:fire: the old test module.

view details

Rob Rix

commit sha 32e772ecf0e92f3ef6f76c4dd755464698f6e38c

Define a module for Elab notices.

view details

Rob Rix

commit sha bace759c908e565084318dadfa7f994d5cecdc16

Define a module for Parser notices.

view details

Rob Rix

commit sha d34742d2dd4050fa0f581561a30f3513e0c80b76

Copy in Span.

view details

Rob Rix

commit sha bf0610ff4054c913b052cbfb4ccaf9827c4abcce

Copy in Source.

view details

Rob Rix

commit sha 41d8d4a3150b9bc651eeb698962beaddf6a69f96

Copy in the parser.

view details

Rob Rix

commit sha 9baa95920e2de9ed776efe7ebfb3c04bb8464d32

Don’t use the old Span.

view details

Rob Rix

commit sha cec7f29ccd6fcc596103016ea89361c7b74e2c58

Allow signatures to bind explicit type variables.

view details

Rob Rix

commit sha e72c9614d5a7be05f8eccf2ec37424db9fb86b47

Spacing.

view details

Rob Rix

commit sha 8bb43330e1c03a39e21fb9c169c6060d8f3fc417

Correct a fixme.

view details

Rob Rix

commit sha f49faa2dd0542a8191fd4d1ec530c3dfd95c6fcc

Simplify how we bind variables in signatures.

view details

Rob Rix

commit sha a011cf36332a6221f85d50ed4289c1a2e94623e0

Simplify the structure of how binders are parsed.

view details

Rob Rix

commit sha a92691eb9780adf397382323d34ae452d50bc014

Move sig into decl.

view details

Rob Rix

commit sha 781ce23fb2c38830d4805bfb7cfba00c083e1410

Revert "Move sig into decl." This reverts commit a92691eb9780adf397382323d34ae452d50bc014.

view details

Rob Rix

commit sha 2d25869af87c442f73a7215335061d1243464c3e

Parameterize binder by the type of names.

view details

Rob Rix

commit sha 4ddeec4e9dacd03c2450c858de9383a1d8c8bea3

Parameter sig by the parser for names.

view details

Rob Rix

commit sha d2675bcd46193cf112e0994351be289d2bcea8b6

Reformat the signature for binder.

view details

Rob Rix

commit sha 2d03a07655529b831296a8d7294ceee2764c43ae

Parameterize binder by the constructor for its arrows.

view details

Rob Rix

commit sha d35f65aa6c3cb58ba53e46baeb4bffbde1bc6c40

Generalize binder over the decl type.

view details

Rob Rix

commit sha a55d3cdb4ec798652bc9750dd6978e1e3618ec1c

:fire: the spanned combinator.

view details

push time in 4 days

delete branch robrix/facet

delete branch : parse-in-house

delete time in 4 days

PR merged robrix/facet

Parse in house

This PR brings the parser in so we can iterate on it locally; I want to explore a backtracking-by-default-with-explicit-cuts grammar and see how that feels instead.

I also went pretty deep into changing the surface syntax so we can elaborate parametric datatypes properly.

+957 -220

0 comment

24 changed files

robrix

pr closed time in 4 days

PR opened robrix/facet

Parse in house

This PR brings the parser in so we can iterate on it locally; I want to explore a backtracking-by-default-with-explicit-cuts grammar and see how that feels instead.

I also went pretty deep into changing the surface syntax so we can elaborate parametric datatypes properly.

+957 -220

0 comment

24 changed files

pr created time in 4 days

push eventrobrix/facet

Rob Rix

commit sha 7696581eec68d8f74a48bf42ad153ddfa088124d

Add an Option datatype.

view details

push time in 4 days

create barnchrobrix/facet

branch : parse-in-house

created branch time in 4 days

push eventfused-effects/fused-effects-parser

Rob Rix

commit sha f18ea3cd59ac0983cbc100de42d9bace5b038d09

Don’t use the old span.

view details

push time in 4 days

push eventrobrix/facet

Rob Rix

commit sha eb9ff44dbbb331ba096874341c414f4b220acca3

Add a FIXME about checking if we need to reload a file.

view details

Rob Rix

commit sha b5660207cd6256b0adb72f0bd095c2cc08887327

Loading reloads.

view details

Rob Rix

commit sha 311b4a6f925318150fc7b167847da2593ef6dd3f

Reformat.

view details

Rob Rix

commit sha 68c9904604cba409021a523fe1d0468585fab8ae

Move File down.

view details

Rob Rix

commit sha fd1eb285fb8d53269143e869964c919637ddbb43

Spacing.

view details

Rob Rix

commit sha 2fb47c90d20be4ecc12ca4d72c9c93f619fc9d83

Define a lens acting on the loaded state of a File.

view details

Rob Rix

commit sha 4d02c0b2cf6f36761ecc31564da812988117f4df

Set the loaded state.

view details

Rob Rix

commit sha 6e2e0b3d4945efbc0aa4e8a2a1d0dbe599f9769f

Spacing.

view details

Rob Rix

commit sha 440bf555a20dd595310d085d91f09f518bf60e02

Copy in the ~> combinator from starlight.

view details

Rob Rix

commit sha 57ecc43e66a32d1580d630675bcdbf5d9f24c0a7

Copy in the <~> combinator from starlight.

view details

Rob Rix

commit sha 5551548c0af9be88880c0511756a0c983e3c4f0e

Check before loading; update after loading. Co-Authored-By: Patrick Thomson <2498+patrickt@users.noreply.github.com>

view details

Rob Rix

commit sha c172f36f77b5b7097ed0b8575a18d630fb1e2238

Move defaultPromptFunction down.

view details

Rob Rix

commit sha 7e83fc3d99f572e9a762bdb24266d58c879c5aa6

Spacing.

view details

Rob Rix

commit sha 141c0951aca42859e5555d32cecdb8559e80f98c

Extract the default REPL state.

view details

Rob Rix

commit sha 43083dee21dd8164b35b45bc1ac413be2121ca17

Get the files in one pass.

view details

Rob Rix

commit sha 1aa5ef9591b21c6ac5b24197707c2b183b0569fd

Rename success to heading.

view details

Rob Rix

commit sha 1711d632d57c39fa179a6b2303539dd2d34fb50c

Unqualify the import of Facet.Pretty.

view details

Rob Rix

commit sha 6cb523c330d5bce37cabe49190970699f65f21a3

Unqualify all of the symbols from Facet.Pretty.

view details

Rob Rix

commit sha c39e3480addb85829f3297ba2ee496cef33443f0

Unqualify System.Console.ANSI.

view details

Rob Rix

commit sha e1819e86b7de6994f3b8de9e3e341d68b687aac6

Move setRGB & bold to Facet.Pretty.

view details

push time in 4 days

issue closedfused-effects/fused-effects-readline

Text

prompt should probably work with Text instead of String.

closed time in 4 days

robrix

issue commentfused-effects/fused-effects-readline

Text

That should probably apply to every constructor, but I’m actually pretty disinclined to vary too much from haskeline here. fused-effects-readline is primarily lifting, rather than abstracting, haskeline’s API, so consistency with it is a virtue.

robrix

comment created time in 4 days

issue commentfused-effects/fused-effects-readline

Can't Lift IO through ReadlineC

Heads up that this is fixed on master so long as you’re able to use haskeline 0.8.1 or more recent.

remexre

comment created time in 4 days

push eventfused-effects/fused-effects-readline

Rob Rix

commit sha c4ea2da069c9150713d76830253e961e1f8d157e

:fire: a changelog entry which doesn’t make sense any more.

view details

Rob Rix

commit sha 6aed6d0c7ddb06d44bdc72bfcb14b92b98ac78df

Pass effects through to underlying carriers. This is only available with haskeline-0.8.1 because we don’t otherwise have withRunInBase. Fixes #3.

view details

Rob Rix

commit sha d8a35005ae28e827c92b4fe122f62d015a9a8e24

Add a note to the changelog.

view details

push time in 4 days

issue closedfused-effects/fused-effects-readline

Can't Lift IO through ReadlineC

This might not be possible unless/until InputT gets MonadBaseControl?

closed time in 4 days

remexre

push eventrobrix/facet

Rob Rix

commit sha 67ed2b7193d5f12b4968b94396fa807126021efc

Simplify the GHCI module by rethrowing errors.

view details

Rob Rix

commit sha d99a75c4aa8ecf21d8d45d074316403243777d18

Rethrow elaboration errors.

view details

Rob Rix

commit sha 5955ef4646e14c32295be0f046aea8cf74583677

Rename rethrowingFromParser to rethrowParseErrors.

view details

Rob Rix

commit sha 9d9b753497f440b24b8e0a79e39e6a98554c3c43

Move sgrStyle into Facet.Pretty.

view details

Rob Rix

commit sha b1dd844ea808d63216f8cad08462fb4b62e02d23

Define a Facet.Notice module.

view details

Rob Rix

commit sha c53de02c51f07d83136d1356d4d5bd1961c427f5

Re-export Notice.

view details

Rob Rix

commit sha 87955ec45f587179b88e1cb3ce85593500806a68

Re-export Notice’s fields & constructor.

view details

Rob Rix

commit sha 14df822bf2b13f624ffce3608bdb10fc731937d4

Use Notice unqualified.

view details

Rob Rix

commit sha 423761ad63b640aa359a96ae7798f8fcab591067

Define a simple prettyNotice helper.

view details

Rob Rix

commit sha a7be8bcc574b766bdf11e56d8f67bcf433d9c4b1

Pretty-print notices with the helper.

view details

Rob Rix

commit sha b145af7962576dd08d915c84fd0a7b37af7160a6

Re-export Doc from Facet.Pretty.

view details

Rob Rix

commit sha 55764bdb3c5022a020fe72e1209c80c0202b5088

:fire: a redundant qualifier.

view details

Rob Rix

commit sha d56863f7c01353cbc9912a9ea29c1a6c8012876d

Re-export layoutSmart from Facet.Pretty.

view details

Rob Rix

commit sha caba9ff8a984c203189f49c08c3854a5cbfd2b9e

Move rethrowParseErrors into Facet.Notice.

view details

Rob Rix

commit sha 96c857cf98ae80e10d39d7aac4cd3a2313772d59

Print notices with prettyNotice.

view details

Rob Rix

commit sha 83ae641dbeb7264a3a647d0e22c28cb8edd57662

Add headings.

view details

Rob Rix

commit sha 91f4432eae458018bde7b1caa6e2c8b538387385

Move elaboration error formatting to Facet.Notice.

view details

Rob Rix

commit sha 96c86105e00837abeeb6dfddc455fedcd044cd68

prompt returns the Source.

view details

Rob Rix

commit sha a6d159617b77d61ba7d54e6e890100b82530533d

Add a FIXME about factoring surface/explicit.

view details

Rob Rix

commit sha 5bb809e1a5d7c7fd423ff6e52ce827a582d024c6

Export ann.

view details

push time in 4 days

push eventrobrix/dotfiles

Rob Rix

commit sha 85d8902b5c31c29b7f403d3bf90dbc50ba5655b1

Add keybindings for navigating between errors.

view details

Rob Rix

commit sha 1b74f884a222555c1b36c167e5ce379c6e455c84

Turn on fancy conflict resolutions.

view details

Rob Rix

commit sha 78e18dce71cfed7693bf3f85ef31d9d5c1e6a712

Add a shortcut to show the hover.

view details

Rob Rix

commit sha e4189f914b08a5360dccbe3545af53d75df21fcc

Add a shortcut to go to def.

view details

Rob Rix

commit sha 67a5939b8498ac26d2bc44b23d357a4101382b25

I wish this were stable.

view details

Rob Rix

commit sha a082e10c67c9d460b32d72a837d14e8b026f2e96

Tweak the theme to increase contrast.

view details

Rob Rix

commit sha 0cd55d23221a3994a0e8368b143c8093651b29ee

Tweak suggestions.

view details

Rob Rix

commit sha 2a1c988ec40c1fc37b305b4c16ae2dafad8c81d5

Go back to compact pinned tabs.

view details

Rob Rix

commit sha d46faafd85dd60dc93a1026d201002ea68732913

Disable code lenses for now. haskell-language-server makes them unusable since the imports are always jumping around as you edit.

view details

Rob Rix

commit sha 210b9f359adc0d5d6fd92c20cef94a9f474b21c4

Format on save.

view details

push time in 4 days

push eventrobrix/facet

Rob Rix

commit sha cd5b4eb28e706c6b6a8cec271ad337de8121df58

Derive a MonadIO instance for Inject.ThrowC.

view details

Rob Rix

commit sha b412c168131c13f5f2d787c17f58dd92ffdd0e97

Derive a MonadIO instance for Lens.ErrorC.

view details

Rob Rix

commit sha 4a640c157f4168f71baa22ef5dc9ab093399beae

Derive a MonadIO instance for Lens.StateC.

view details

Rob Rix

commit sha 9df4b93b9312d3402be8a6b917631d433ea7079a

Use rethrowingFromParser to obviate the need for our own definition of runParserWithFile.

view details

push time in 4 days

push eventrobrix/facet

Rob Rix

commit sha 07d94da0296862297f74791a4681772856f053db

Define a module for an injecting Throw carrier.

view details

Rob Rix

commit sha 810d2afd7528c8118a0f0c3952e4107c44b10ca6

Define a Throw carrier around a function.

view details

Rob Rix

commit sha 0d492e6f1299dce8ac9608d4b36bda391a184d22

Add a heading.

view details

Rob Rix

commit sha 87b199b790000b4109624e1e2c66c3169b9a591c

Define a handler for ThrowC.

view details

Rob Rix

commit sha 0af5fc385a6a2bde1138612254f7c3835e4f8ae1

Derive some instances.

view details

Rob Rix

commit sha e76b41f75a817588fb4e1a6649f434381240dbaa

Re-export the Throw effect.

view details

Rob Rix

commit sha a2f7a516aafc174db167dd612022912a30f42669

Define an Algebra instance for ThrowC.

view details

Rob Rix

commit sha 60301255a17fa4c04371e3e075dcfa216e420045

Define a helper to rethrow errors from the parser as Notices.

view details

Rob Rix

commit sha e221d13ed283bcd1dbd7192976e48f3f23916dac

runParserWithString takes a line.

view details

Rob Rix

commit sha 9fdf5e7b3737456186f1a9f5f0302fbd93d92ac7

Spacing.

view details

Rob Rix

commit sha eeb6ea6e3a5cd51a23db03ca72d8e3297e1c143a

Use rethrowingFromParser to obviate the need for our own definition of runParserWithString.

view details

push time in 4 days

push eventrobrix/facet

Rob Rix

commit sha d7865fa599e340cb7c0ba62d2234ca2bdb461359

Define a lens for the line number.

view details

Rob Rix

commit sha 081a4fb42e53090f01a314fb9e3e03166067c331

Increment the line.

view details

Rob Rix

commit sha 02622f102ba1c93560dc3476a7bb67c39a4afe50

Bump fused-effects-parser for numbered lines.

view details

Rob Rix

commit sha 1bdaf472afd5e8317e6ab0a189c12afec24e4466

Style.

view details

Rob Rix

commit sha d96a30b562477dfb5c526ce7849ddb2ef40c729c

Extract a higher-order function.

view details

Rob Rix

commit sha 1209b118ed10e0d8d3fb89a0d66056d1068c5450

Command symbols must be followed by whitespace or eof.

view details

Rob Rix

commit sha 114e6d50075df8997abf3e486b4ea19cd82932df

Allow commands to backtrack until complete.

view details

Rob Rix

commit sha d6773ba47f9e743eb9849b4bfede6c571551a5f4

Parse command symbols into the void.

view details

Rob Rix

commit sha 50a9f38841d17fc949df671d268daa239a5abd3d

Add an env field to the repl state.

view details

Rob Rix

commit sha c4c3420feff0f4555891326c8cbbd003eedcba67

Define a lens for the repl’s environment.

view details

Rob Rix

commit sha fa5f5d372388057047b25e292ebf0666a4423066

Rename elab to runElab.

view details

Rob Rix

commit sha 10908305527443cb7ff3268b2efe545a9ff768df

Extract a bunch of the machinery out of elabModule.

view details

Rob Rix

commit sha 84991b2363e4fa16fa191ce82aff3ce72a6d49ab

Define a convenience function to run an elaborator.

view details

Rob Rix

commit sha 6772034856c6f66011c3ae31e3c0a2c7a422518b

Factor a runSubstWith handler out of runSubst.

view details

Rob Rix

commit sha 15518a34f43ef0e12066cdde17fbec68b6a88974

apply can perform effects.

view details

Rob Rix

commit sha 78c275048276595220199679223afb93dcc22919

Define an elab variant parameterized by a function to apply the substitution.

view details

Rob Rix

commit sha d441a57570188e691fe9e0c1d488aea2413d7ad5

Define elabModule in terms of elab/elabWith.

view details

Rob Rix

commit sha 56d55abdf49ed224be2b08a009087f499a37be92

Export apply.

view details

Rob Rix

commit sha 244e3aedeaaa1d99254cd48845be5a52292b5725

Rename Value to Arg.

view details

Rob Rix

commit sha 786e457667ed3266e180c4a70fbb0a51b741a7ed

Bump fused-effects-parser.

view details

push time in 4 days

push eventfused-effects/fused-effects-parser

Rob Rix

commit sha 4aa243b353362996ab3645e67efe416b4d5f284c

Source has a Span.

view details

Rob Rix

commit sha 761d1e9ab5cf37bd4cd411bb83bb1f7c6a16c80b

Define runParserWithString in terms of runParserWithSource.

view details

Rob Rix

commit sha dc80407c9082b7bae71867814fb0ee75d26009be

:fire: runParserWith.

view details

Rob Rix

commit sha 6ca319447647b57e375bf2327fa0952eb6b857a8

Define a lens over a Source’s Span.

view details

Rob Rix

commit sha b177cc965c943a547584dbc84dc985da7976d86e

Define a lens over a Source’s contents.

view details

Rob Rix

commit sha ce660624516bdbc35621567dc0a6863f515a3147

Tweak the :memo: for span_.

view details

Rob Rix

commit sha 72716de96ef42b1d904107f7f8d500d7c92ca5a1

:memo: contents_.

view details

Rob Rix

commit sha 1cfa7b89fe3c9650e0f03a62a5870732e3cce233

Define a lens over a Source’s lines.

view details

Rob Rix

commit sha 30c1c4252445b49d2618c8589cb56fc763366418

:memo: lines_.

view details

Rob Rix

commit sha a005371867e45612161c88c2a374600519a8ac7f

Define a lens over a Source’s path.

view details

Rob Rix

commit sha d8ea22619f498ff68dff7c4d3a20e1774794b3bc

Define a function to slice a source.

view details

Rob Rix

commit sha c0882eefab58ad69ce27fe8bac73f52edbff728d

Notice holds a Source as its excerpt.

view details

Rob Rix

commit sha ed15caac09b3e3cde33e5884cfe4c3879f33a19d

:fire: Control.Effect.Parser.Excerpt.

view details

push time in 5 days

push eventfused-effects/fused-effects-parser

Rob Rix

commit sha 3bdbde7445fd8c7beccb54383645b320a32bd39c

Give Source a field for its contents.

view details

Rob Rix

commit sha f13ada3cdbc39661ddbef86fd8b59a8aab540e05

Define a ParserC handler taking a Source.

view details

Rob Rix

commit sha a422faa93f2ffbc6f13717edfb8fba9d06b869c3

Define runParserWithFile in terms of runParserWithSource.

view details

Rob Rix

commit sha 653bbf5fa847d09f6707325c0319646f88cbf9fe

runParserWithSttring takes a line, not a Pos. Error reporting via Source, Excerpt, Notice, etc. is heavily line-oriented.

view details

Rob Rix

commit sha 9738dde5332ec6ddb6c34ce5be44662ae2350271

Add a couple of FIXMEs.

view details

Rob Rix

commit sha 160837e74a0f57bf1473ee8f8a1648764ac3f3e9

Add some FIXMEs about Input.

view details

push time in 5 days

push eventfused-effects/fused-effects-parser

Rob Rix

commit sha 6b3ff716680066496092930c541a733b5d992c7f

Define ! in terms of !...

view details

Rob Rix

commit sha 60a6c7045c96ba4fc8bc4dcff5e600643fdbaae1

Import the source module.

view details

Rob Rix

commit sha 269b215c3becb7519b643e81851962bb418af3a2

Spacing.

view details

Rob Rix

commit sha 3ea983f239438b87ada3ad8c6fc38fc061f1fb10

Add a start line to Source.

view details

Rob Rix

commit sha e4a447ccc071a83f107440558ae7c97175b21bbc

Lines are numbered.

view details

Rob Rix

commit sha e295775e4b68e013862428abe048b593bd332d4f

Rework slicing in terms of line numbers.

view details

push time in 5 days

push eventrobrix/facet

Rob Rix

commit sha 39bc1380226fbef766979c8e72b78d112652a121

Define a module for an evaluator.

view details

Rob Rix

commit sha 72c9e2471fb78791f3ad7a27d1c6eb318b83297b

Bump fused-effets-parser for some assertions.

view details

Rob Rix

commit sha 70bb19bb60054fc0223db33cfa47b69c91572520

Maintain the line as part of the REPL state.

view details

push time in 5 days

push eventfused-effects/fused-effects-parser

Rob Rix

commit sha bc958f5c0d5219e92c783811a872376fd592f214

Assert that the span is well-ordered.

view details

Rob Rix

commit sha 4ced42072167928dd514e5c0499d47e6f5f97f21

Define a helper to read Source from a file.

view details

push time in 5 days

push eventrobrix/facet

Rob Rix

commit sha 8290aab0bcbb900b4299c99fb622433b6ec7fbba

Add a FIXME about nested clauses being elaborated incorrectly.

view details

Rob Rix

commit sha 8915f563528110b3b97df448ad1a36077c424054

Rename expectQuantifiedType to expectQuantifier.

view details

push time in 5 days

push eventrobrix/facet

Rob Rix

commit sha 6751461e46ee4f96e81b97c8371cb85edf7ffc23

Specialize the error helpers.

view details

Rob Rix

commit sha ffe22c333922f25c62fc746bad6d2a833feb3c7e

Populate error contexts.

view details

Rob Rix

commit sha 861a309e7a69bdf092a2ef22eda0bac813892ba3

:fire: handleBinder & handleBinderP.

view details

Rob Rix

commit sha 9a383064ce691e1de87b8404e76a7a2362d2b2e0

Generalize |-.

view details

Rob Rix

commit sha e311955bbc293417c63f9fcc2e96048d9fadfcdd

Add a FIXME about correcting elabPattern.

view details

Rob Rix

commit sha aad44fa39c27fcc3aa36f2b082c87716d29c4f4c

Define boolean conjunction.

view details

Rob Rix

commit sha 374c9c5674ecd41b84ccfec335901acab5fddff8

Better rendering of cases.

view details

push time in 5 days

push eventrobrix/facet

Rob Rix

commit sha 851b625bcc890b50b5f13b4d7475115cd12e635b

Amend a FIXME.

view details

Rob Rix

commit sha 3470886714a3463e971efb431821feda19d1d147

:fire: getSubst. It’s unnecessary now that we’re monomorphic.

view details

Rob Rix

commit sha 42fe84e1008b95b49584d347d60c764e89e27498

:fire: some lets.

view details

Rob Rix

commit sha f3170d0cf9b7b87ecaf23ee8020230541bb58129

Use Head in both Value and QExpr.

view details

Rob Rix

commit sha ea523fa5562e2af8f918c0fa14569047664f3ca9

:fire: redundant parens.

view details

Rob Rix

commit sha 0968e40d6d684ed8498b309292dc82c262297c96

:fire: a fixed FIXME.

view details

Rob Rix

commit sha 10ef73227432960fc65b5a4478261ae227d2b103

:fire: wildcards from core.

view details

Rob Rix

commit sha 80efa840c4205cb431b72e77f7ed31964f37f02f

Rename the core pattern constructors.

view details

Rob Rix

commit sha f3f1d0cd54d6778a1fbe9ce0ec900e1d809df819

Define a Con datatype representing constructors.

view details

Rob Rix

commit sha eb5194a9eec4b526cc4aa939527b9e1346af53f0

Define a bunch of instances for Con.

view details

Rob Rix

commit sha 8c118c5149e5c76225ae9e316f9970cf3e5001c3

Define a Bifunctor instance for Con.

view details

Rob Rix

commit sha 041036bc2b2c4d4a91994637870f66a5b140cc32

Define a Bifoldable instance for Con.

view details

Rob Rix

commit sha 738ac054823db7c7e0e71cdaae4285360901f5f1

Define a BItraversable instance for Con.

view details

Rob Rix

commit sha 9314db4be969cc3ce8ed8437061dce82ab4ab8fa

Use default definitions of bimap and bifoldMap.

view details

Rob Rix

commit sha 0c80c0914ca116261958f73619e2fc421a6f8746

Add a FIXME about eliminating var patterns eagerly.

view details

Rob Rix

commit sha 5c7233ba205c157ce5b079327b47105f5b277473

Correct the Bitraversable instance for Con.

view details

Rob Rix

commit sha d0111d5edb3e55eae9439b55850b7fd15852cd76

VCon wraps Con.

view details

Rob Rix

commit sha 42d7f8010ee72d62f8d7416fe6a26e61862d5ff2

QCon wraps Con.

view details

Rob Rix

commit sha f3ae4f8f02b96eb57fa480b76158b00400da36a4

Define a Zip instance for Stack.

view details

Rob Rix

commit sha 964fde39b85b3111c3238927375b79509e13c214

PCon wraps Con.

view details

push time in 5 days

push eventrobrix/facet

Rob Rix

commit sha a15d5d4e251f75115c26b9c352958a75c35cbb75

Add a dependency on ansi-terminal.

view details

Rob Rix

commit sha 7a0c5af6477ae26294cdd190a6ee9cbc55512670

Render SimpleDocStreams with SGR codes.

view details

Rob Rix

commit sha 74515d425b8dc67e1da7217221c59e95af49efcc

Copy and adapt renderLazy.

view details

Rob Rix

commit sha c56cb861810d16ebe60d774f8996d351ed3f6f90

Define a function mapping AnsiStyle to [SGR].

view details

Rob Rix

commit sha 6c0436c4f47cf660ceafa44da551312b2d5ae727

Fix some ambiguities.

view details

Rob Rix

commit sha 74295028dd5b8fd54f1bb326a84fd4ab1243c31c

Bump fused-effects-parser.

view details

Rob Rix

commit sha 6ceb4a0fcd63544ac4dd72e5c1ebcb36bae7aa1c

:fire: ErrDoc.

view details

Rob Rix

commit sha c5e76cf24c0e184c64b901dac5c85fedcddeeeba

Push an initial state onto the stack.

view details

Rob Rix

commit sha f6f6515ea00c62f29efeb895ce86c136e7c216bb

Pretty-print using SGR codes.

view details

Rob Rix

commit sha de90ff2cf8e29807d641bcccfd5eebdfa2246c31

Fix colour selection.

view details

Rob Rix

commit sha 3e351a6d0c5ed531882d8b33bdd86e2c45570709

Pick named RGB colours for specific syntactic categories.

view details

Rob Rix

commit sha d3b8c4999b7a790361a806aad049618483806a39

Factor out the bold marker.

view details

Rob Rix

commit sha 7baa38655cbe3ab1728d4d3ae10ee93bcd0b42c9

Pick HSL colours.

view details

Rob Rix

commit sha b63aa43014e3032356d145f06e877d28b3340f63

Tweak metas.

view details

Rob Rix

commit sha 0cfe85a714241a972b204d857c5fdac43461b5e6

Take slightly smaller steps.

view details

Rob Rix

commit sha e8236618896d74f8d56e74bfdd42310b61679170

Fade brackets out a little.

view details

Rob Rix

commit sha 9e12eba0c72a017f5fbb161cc1f4a154bafe74dd

:fire: the dependency on prettyprinter-ansi-terminal.

view details

Rob Rix

commit sha 578f2ac5c08f3e3f43040886be5b28664ba17250

Merge pull request #2 from robrix/twenty-more-bits-of-c-o-l-o-u-r Twenty more bits of c o l o u r

view details

push time in 5 days

delete branch robrix/facet

delete branch : twenty-more-bits-of-c-o-l-o-u-r

delete time in 5 days

PR merged robrix/facet

Twenty more bits of c o l o u r

This PR migrates away from prettyprinter-ansi-terminal onto direct usage of ansi-terminal: annotations destined for the terminal are now [SGR].

+185 -62

0 comment

7 changed files

robrix

pr closed time in 5 days

push eventrobrix/facet

Rob Rix

commit sha 9e12eba0c72a017f5fbb161cc1f4a154bafe74dd

:fire: the dependency on prettyprinter-ansi-terminal.

view details

push time in 5 days

PR opened robrix/facet

Twenty more bits of c o l o u r

This PR migrates away from prettyprinter-ansi-terminal onto direct usage of ansi-terminal: annotations destined for the terminal are now [SGR].

+185 -61

0 comment

7 changed files

pr created time in 5 days

push eventrobrix/facet

Rob Rix

commit sha e8236618896d74f8d56e74bfdd42310b61679170

Fade brackets out a little.

view details

push time in 5 days

push eventrobrix/facet

Rob Rix

commit sha 3e351a6d0c5ed531882d8b33bdd86e2c45570709

Pick named RGB colours for specific syntactic categories.

view details

Rob Rix

commit sha d3b8c4999b7a790361a806aad049618483806a39

Factor out the bold marker.

view details

Rob Rix

commit sha 7baa38655cbe3ab1728d4d3ae10ee93bcd0b42c9

Pick HSL colours.

view details

Rob Rix

commit sha b63aa43014e3032356d145f06e877d28b3340f63

Tweak metas.

view details

Rob Rix

commit sha 0cfe85a714241a972b204d857c5fdac43461b5e6

Take slightly smaller steps.

view details

push time in 5 days

create barnchrobrix/facet

branch : twenty-more-bits-of-c-o-l-o-u-r

created branch time in 5 days

push eventfused-effects/fused-effects-parser

Rob Rix

commit sha aa3c6349dad5e359d7fecc5403c1c183dbd2ca1c

Generalize errToNotice over the annotation type.

view details

push time in 5 days

push eventfused-effects/fused-effects-parser

Rob Rix

commit sha 75b3ce4068538ccfda8322c9718b28fd2dbad1fa

Throw the source and err.

view details

push time in 5 days

push eventfused-effects/fused-effects-parser

Rob Rix

commit sha f9c3866b8989d0d110f7fb6dabf36e579328640e

Define a span_ lens for Excerpt.

view details

Rob Rix

commit sha dbbf0b1eb18ce8fe743aa3dd6f159184fc9b2dc4

Source has a non-empty list of lines.

view details

Rob Rix

commit sha 1b5059b06c80e6d5d3a957efb9c33d56d401307c

takeLine operates in Maybe.

view details

Rob Rix

commit sha c1b13cdb4511699d171f96e977a7c299f8d20167

Slightly clearer operations.

view details

Rob Rix

commit sha 66957cd26da382a3d8fde5f12a82098a2e86be1f

Extract a range of lines from a Source.

view details

Rob Rix

commit sha d2cae51edaece463862a15b8d5aea1f659c1a085

Build the excerpt with fromSourceAndSpan.

view details

Rob Rix

commit sha d76373d549f584c61b2d3851efc8f201957837aa

Excerpts hold a non-empty list of lines.

view details

Rob Rix

commit sha 431f66b13b9538e74504f7ef063f8e5d0aa006cc

Don’t allow grouping to flatten lines.

view details

push time in 5 days

push eventfused-effects/fused-effects-parser

Rob Rix

commit sha 18232a570d607b3e84f27943df25ae5586a56a0c

:fire: the dependency on selective.

view details

Rob Rix

commit sha 10571dd8863a08397293df8f8320f6d4e870e5f2

Factor Doc out of Err.

view details

Rob Rix

commit sha 079af9bc327f57fba8b93447c40f39b3a318dadd

Derive Eq & Ord instances for Err.

view details

Rob Rix

commit sha 5a1fa87cf2f0e5664ba02128fbaed4290bb07f36

Align.

view details

Rob Rix

commit sha c6ba55af48a32a5f548883a888039fa6503745e0

Align.

view details

push time in 5 days

push eventfused-effects/fused-effects-parser

Rob Rix

commit sha b0231be1c335dcb80b538d579b403721f201c851

Sort imports.

view details

Rob Rix

commit sha 7263883d051999d591a4a293882f2a69ea58fc15

Give Notice a parameter for the doc highlights.

view details

Rob Rix

commit sha 9f6bf9685e7ff375e7e6d7d975c0bde3e7e89d97

Generalize the Notice lenses.

view details

Rob Rix

commit sha 55f34f317238e9752fabd4e4376682b57725f976

Define a polymorphic Lens synonym.

view details

Rob Rix

commit sha eca9d0769a75763a2aa2ca9ef33dd6b4a5425d4f

Define monomorphic lenses in terms of polymorphic ones.

view details

Rob Rix

commit sha 6c7ec238e8f8449b00b85bd4640374bc253cde92

Generalize the lens constructor to polymorphic lenses.

view details

Rob Rix

commit sha c89b866658ceb72c3458ae9105fc990a258cb688

Generalize .~ to polymorphic update.

view details

Rob Rix

commit sha 161652c6e864c19dffdb12e78cc87f9a147412ba

Generalize %~ to polymorphic update.

view details

Rob Rix

commit sha 68b50a801924338c954e0f4c180325a82e3a94df

Define a Pretty instance for Level.

view details

Rob Rix

commit sha f267c8749a730c0ef2e5fce58a50c0f6edc27a8d

Define a datatype giving styling for a Notice.

view details

Rob Rix

commit sha 72297e738ab92fa6458c12fe6c5a623cc82a759c

Define a default ANSI style.

view details

Rob Rix

commit sha 2acdb9f4634cd16c2bb1e778671a2bae6850dbbc

:fire: the export of prettyLevel.

view details

Rob Rix

commit sha 207c47779c7e48164c56966412c17aad12c1e27d

Move prettyLine into the where clause.

view details

Rob Rix

commit sha c09281349d8ce0a726dc9d87b84e2ad97b8da0ab

Move prettyLevel into the where clause.

view details

Rob Rix

commit sha 261460ef346d5b485f5b3fab1767a515e1b74c67

Move the various colours into the where clause.

view details

Rob Rix

commit sha 987fd3a0d4c6218dc128e33c564707982c5fd0a6

Define a prettyNotice analogue parameterized by a Style.

view details

Rob Rix

commit sha f4b2252889d7ae889bbb2166b8b7fcb7913e8ead

Define prettyNotice in terms of prettyNoticeWith & ansiStyle.

view details

Rob Rix

commit sha 35973e35ab5609f51da2ad33827e425309f54fbc

Define an AnyDoc newtype quantified over the highlight.

view details

Rob Rix

commit sha bd07f78ba346c303d2905abb6edb23508c13fa86

Spacing.

view details

Rob Rix

commit sha f86f96a17f4dfdac3450de45b2fa6623b44751ff

Define a Show instance for AnyDoc.

view details

push time in 5 days

push eventrobrix/facet

Rob Rix

commit sha 72c1927fe0bbc4f212e8bca606afae5a93b8fab5

Monomorphize the surface syntax.

view details

Rob Rix

commit sha 61b2fc4db3b4cb30cc09dc7bf84a8a380e283296

:fire: Contextual & AValue.

view details

Rob Rix

commit sha 9288924d653e4fb788f9dd8b2a20c4fec6bd310d

:fire: the Val synonym.

view details

Rob Rix

commit sha 593cdef657fca974f01209076f9dd1e6e904678d

:fire: M.

view details

Rob Rix

commit sha bf8ec7b3f9746b6d1bcb78737a7a365b5d8730d9

Monomorphize core.

view details

Rob Rix

commit sha 2ce58028a7494b344d0bb41df3fe2e18ddd35c8c

Don’t export toNotice.

view details

Rob Rix

commit sha 7360c02bf95827dec759a1fce1539958b1a1a0de

Algebras carry stacks of context around.

view details

Rob Rix

commit sha 85b06519ca5c173dde1123496c671fc51a601eb6

Pull variables’ results from the context.

view details

Rob Rix

commit sha 1c94bbb5681116aa0489c48662d3f2ef5cd048c3

:fire: evar & tvar.

view details

Rob Rix

commit sha 12cbcb85568360d9e4c1bdec86204b82e1e1dcca

Add a note about maybe allowing parens to be dropped around constructor patterns when the constructor is qualified.

view details

Rob Rix

commit sha a13d63561c1d907034b9eafa193ad50e492dd560

Hole annotations take a metavar and use it to pick a colour.

view details

Rob Rix

commit sha 028a082104a364ae70bdee0e3df8e32413c5203a

Increment the level as we walk the bindings.

view details

Rob Rix

commit sha 9193ca737757d0c43d66ed64367f4048b674b214

Generalize tabulation over the annotation type.

view details

Rob Rix

commit sha 9846b4960a34493206b3a25e64a45c4507db4c4c

:fire: the ANSI terminal colour helpers.

view details

push time in 6 days

push eventrobrix/facet

Rob Rix

commit sha c8712502d847c794bc306e9376f06c97bd926e3f

:fire: a bullet.

view details

Rob Rix

commit sha f64feeab86dd26c79b96b89b34b8828417231529

Evaluate constructor pattern matches.

view details

Rob Rix

commit sha d8626a00da407f3da35d933f7804630ba34440d6

Enumerate the cases so we don’t miss more as they’re added.

view details

Rob Rix

commit sha bb43930c2ea2a770b6fa24f95c21b2bda4a77453

Match matching matches other matching.

view details

Rob Rix

commit sha 22d6d2a109aa9f78c7e91f6e69f0e2e57e5202eb

Put qvars into their own syntactic category so we can distinguish them.

view details

Rob Rix

commit sha 47575b815dff3f3cdb8bc39d3b5a138c2096a3f0

Return the substituted value.

view details

Rob Rix

commit sha 7632aeed739bf02ad53b2508c65b875ab1d015ce

Rename the Meta constructor back to Metavar.

view details

Rob Rix

commit sha 9bfa7fc6793aadccda061ddb2c83ee19337a67ef

Rename the Meta constructor of Algebra.Var to Metavar.

view details

Rob Rix

commit sha 8a3c336eff5445de41264d9bb2ef0617e0b1ed2d

Define a Meta newtype.

view details

Rob Rix

commit sha ed20dcedcbec7d0b62cdd58b32f9334342430231

Use Meta for metavars.

view details

Rob Rix

commit sha 496b8d0366b0070187553c398cd703fa8f57ec6c

Return the metavariable directly from meta.

view details

Rob Rix

commit sha 4f60afd84f6827ef8194a92bbe4e7c375b92c826

Use metavariable substitution to deal with |-.

view details

Rob Rix

commit sha 70bbdbf786b50680e07497a0b8df6a4cc24fedd3

Add a FIXME about naming metas.

view details

Rob Rix

commit sha 8eea41b4c55b8d1e37d0068d65fc77578aa25bda

Return the type from meta.

view details

Rob Rix

commit sha 385f59deb4a18833de0e63834b56d2e4a13b66ba

Handle binders in patterns using metavars.

view details

Rob Rix

commit sha b2af3786e1a1ff950338a0d11375a30d81972ab8

:fire: substQ.

view details

Rob Rix

commit sha 5bbcbbdb04ee1898db502b61b319dc738a807d7f

Spacing.

view details

Rob Rix

commit sha c62f98cb18421d5ef02aee75f98adc1af546082b

Merge subst & substHead.

view details

Rob Rix

commit sha 5990df3b8ede8af88f39c3e28850a47e31de3f10

Don’t unify if the im/explicitness doesn’t line up.

view details

Rob Rix

commit sha 46e9896d82b97b5ae5323b425c3a89dbe34f9ea5

Add a FIXME about tracing.

view details

push time in 6 days

issue openedfused-effects/fused-effects-system

Trace categorization

In addition to #19, I want a system for categorizing traces to make it easy to filter on them.

created time in 6 days

push eventpatrickt/fastsum

Keagan McClelland

commit sha fae0e4daacacf9eca6d5cea1cf045c831da0190c

lifts upper bound on template-haskell for compatibility with ghc-8.10.2

view details

Rob Rix

commit sha 818067daa9568a9488af40b6bf11aace6687659a

Merge pull request #18 from ProofOfKeags/ghc-8.10.2 lifts upper bound on template-haskell for compatibility with ghc-8.10.2

view details

push time in 6 days

more