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.
A fast open-union type, suitable for 100+ contained alternatives.
Comparing Haskell effect systems for ergonomics and speed
robrix/A-Swiftly-Tilting-Parser 19
Talk about the derivative of parser combinators in ObjC & Swift
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
Convenient LLVM compiler API for Objective-C.
fused-effects/diffused-effects 10
all your intentions turned to vapour
push eventrobrix/facet
commit sha 0023065ddc0dc28ead017ac02e5487059d782e5b
Update both types and terms incrementally.
commit sha 91862643b0e94045a8cf497f1366e26b6ae1eda5
Copy fused-effects-readline in.
commit sha 7826a87877b859ce46a60c487c417ecd8372c84b
Complete filenames.
commit sha 5af116c77fe909e40be9958c463f430117a295bb
Provide Reader effects for the module and graph during elaboration.
commit sha 7e34a1d9702a92268fd7540ba6491c0646c6f413
Resolve names in the module and graph.
commit sha 4bb83da0c93f9b90f1ea1ccfe25e1a7a65096661
:fire: the requirement for an Env effect.
commit sha 0d5b75f4a1eea0e377efd8841adf42bef619f09b
:fire: the Env from elabWith.
commit sha fe38ee5d8c733c773dc3a9385bbb73add19e4c4b
:fire: the env effect in the REPL.
commit sha 885de83392e319eb2e65b8f2b19f1b74da72d389
:fire: the env_ lens.
commit sha 5194529736a1e76c045246b8d818695974393f33
:fire: the env field from the REPL state.
commit sha 3312e9188837994979fb93b92bede7b84b80d659
:fire: Facet.Env.
commit sha 20903263bed613e1212522fd25ad9af4241c6a53
Reuse the Type action for :kind.
commit sha a569fd6251d1ac8e564f3520b341ead46abbab2d
Move the prompt function up.
commit sha ca847ede65ba2f629881c9f3212d2fc96fa9e72f
Move localDefs up.
commit sha 6014dd9ea294bb6e5ab0ceecec73526e7790ae0e
Show variables with the names the programmer gave them.
commit sha 11a9fd2bf8806fb801124b690267be6a733589c6
Add a FIXME about multiple source references in a Notice.
commit sha 04cc84cf519754c486a57028b0a1182fa7b7ba23
Print both positions for nonempty spans.
commit sha 39cfea3657e3e15e1b2065193cf48a572f201d0b
Factor out the treatment of individual coords.
commit sha 48a4a723f9c45ce9d7b01b1b262aeda236550867
Abbreviate single-line spans.
commit sha 9a08204f6c0c3412524fc5773921595d8e02e947
Add a note about resolving symbols in the parser.
push time in 6 hours
push eventrobrix/facet
commit sha 61228196d4b1f4f8b02ef9320907ef70a8e05b86
Don’t treat : as reload.
commit sha aaeb87a911d364cbb39b5a62d5fc7e5ea3d0d388
Move type_ and kind_ into commands.
commit sha 88034cd1372b7a78fc52ab841163b83eeb2ad782
Show modules and paths.
commit sha 41290f929adad13919d93a1fdaacad5a1a098d6f
Add a FIXME about removing stale modules.
commit sha ba9bcc123f61b189f1736d17bcb5810702488644
Reintroduce a Graph type.
commit sha 66046d2a9b8a8880a9118912a9863cc45bec5931
Define insertion into module graphs.
commit sha 1f67ed9c80edabd5980c8ac26d8aa984b0ecc13e
Define a lookup on Graphs.
commit sha d2a13ec99e812f0a7e3db9fcfe319ddf57ef036e
Don’t return an Env from elabModule.
commit sha 50ef07d96d8ff664d670bcb7d69b663bed3d47c8
Add a couple of FIXMEs around preserving associativities.
commit sha ed216adbd197390aa61c20708d8a436f95b44fc1
Extract a helper for following edges.
commit sha 02ffd2a47ec91fa39a9b5f572e753be5c080929a
Re-abstract loadOrder. We can’t load from the elaborated modules because elaboration needs imports already in place.
commit sha 928fcbc7e091f4a186c98d964fb43941f4fe5e38
Define module' in terms of moduleHeader.
commit sha fd5e12dd03272bae62f9dd66f4ebb096ac125cf2
Qualify the import of Facet.Surface.
commit sha 2295265ef256074dde3e415a9553502ef6aaab2b
Define a helper to load just the header of a module.
commit sha 2ff4d4ad53181c2ade464add5b14cc5fef700b2e
Add a FIXME about enriching CyclicImport with source references.
commit sha 787fbc5d1ace3c864b824f94aa92f8c33ff9e81f
Resolve the load order early so it doesn’t depend on elaboration.
commit sha 1e485491e80dc241dbf9a414df71c454c3584be9
Don’t require as much infrastructure around elabModule.
commit sha ac899091ac0e4c618bf773e25754957115698632
Add paths to graphs.
commit sha 36339a2199f9eb1d8882b69dd30964f285e35be8
Derive Semigroup & Monoid instances for Facet.Graph.
commit sha ee1eac92906ea02e3c16f3ac7da3a9046d569e0a
Define Ixed & At instances for Graph.
push time in 21 hours
push eventrobrix/facet
commit sha 1e5a4e8e4ff1bcbcf2a1f1e5595afac5ef966aec
:memo: Facet.Elab a little.
commit sha 90ef8fe2e42a8db6af021c7e3dc21cb5ade85c1c
Derive Eq instances for the surface syntax.
commit sha 184b276d620e8b137b52272ef6a886ca9a5bc794
Define the load order for a module graph.
commit sha f2064b675324e13c09f8380b62f767b1f59c3367
Simplify loadOrder to operate over a list of modules.
commit sha 1383cbf2b7ba56dc024ce3b84ea1be643262bdd2
Define a Node datatype.
commit sha fe45d471f28f8b449fcdc26f88ec52910ce626b5
Give nodes a payload.
commit sha d2f529dcd9f444d754d6358520935112de50b8ef
Generalize Node over the key type.
commit sha f14ba18db20492fd1ae6bb18bd5a872f97b452dd
Generalize loadOrder to operate on Nodes.
commit sha 2bb77a9d30a955e6c7a951a9b00434ed24f57d88
Rework a bit to avoid -XScopedTypeVariables.
commit sha 004b6b11e09a733edc15ffeb99c91fac77f1f26d
Rename Target to Field.
commit sha 2d50fe9dc57029355ee78675929e41a586718b46
Don’t print the module on load.
commit sha 61c9cc6f7bc0f2f07bcf883d3780b1d51b96066d
Hard-core the src dir for now.
commit sha dc66ad0c0e6df086c03e7893f4911faa4cef60f2
Only print the search paths if there are any.
commit sha 4631e83dad16526a9a1e399520738b6a756cc457
:fire: redundant parens.
commit sha 35677549e7dbfa684e06434e0b44b878513e7d49
Show the cwd.
commit sha 7bcfb97ab51dc61022c5c502e864844704953f20
Indent the paths in each group.
commit sha b27255c358b95b566d131d8c33a97c1523f57f1c
Add a list of targets to the REPL state.
commit sha eb9138ea944928a1cca7ecd2758f423fe9d46913
Add/remove & show fields via different specifiers.
commit sha a8e0f173d468e6836cd49e54bef4f90947c536f3
Extract the per-command parser.
commit sha 9dca46b765494ce4c61b790861140b69c5c67691
Rename targets to modules.
push time in a day
pull request commentghc-proposals/ghc-proposals
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!
comment created time in a day
Pull request review commentghc-proposals/ghc-proposals
+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.
comment created time in a day
Pull request review commentghc-proposals/ghc-proposals
+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).
comment created time in a day
Pull request review commentghc-proposals/ghc-proposals
+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.
comment created time in a day
Pull request review commentghc-proposals/ghc-proposals
+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
comment created time in a day
Pull request review commentghc-proposals/ghc-proposals
+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)?
comment created time in a day
Pull request review commentghc-proposals/ghc-proposals
+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?
comment created time in a day
Pull request review commentghc-proposals/ghc-proposals
+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)
comment created time in a day
Pull request review commentghc-proposals/ghc-proposals
+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.
comment created time in a day
Pull request review commentghc-proposals/ghc-proposals
+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 😄
comment created time in a day
Pull request review commentghc-proposals/ghc-proposals
+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.
comment created time in a day
Pull request review commentghc-proposals/ghc-proposals
+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.
comment created time in a day
Pull request review commentghc-proposals/ghc-proposals
+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…
comment created time in a day
Pull request review commentghc-proposals/ghc-proposals
+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).
comment created time in a day
push eventrobrix/facet
commit sha 1e9fcb812a6f0fcd61a617d91bdfc4b99d827724
Fix a couple of parse errors through particularly egregious means.
commit sha 38b29a12f947904b46f7cbe226c41779668d14e9
Spacing.
commit sha 86f66b6b29664f44bde1d66415d4787d9f5b292a
Add a fixme about operator names.
commit sha 066372faad680812e0c2de987e1f0465ff91bfb7
Duplicate the module rule.
commit sha 470e9d049155eadb6550a2b3f31f54d3bc4953f7
Give module'' a continuation to give feedback on modules.
push time in 2 days
push eventrobrix/facet
commit sha 5e03de948fca455a70d25abc9c383d9b90ea6413
:fire: a fixed FIXME.
commit sha 7a6099b8111c1cb53c1ae803f65f3d8ab0dda816
Correct a comment.
commit sha 6938294e03ccb8fcd46e2ad9733072a7993ebcd7
Define associative operators.
commit sha baf8a44f48d4c072c7b9d7a2a92fe288bb561a3f
Clarify that these are operator names.
commit sha 6ed6827d3c74f5181ea059164407b01d145fe8c2
Don’t include the associativity in the name.
commit sha e69ac17d893b3708f5755b2716e83568d5e9d23c
:fire: a fixed FIXME: we shouldn’t.
commit sha ea45e76fe01c35eaf9cfa9dcda345939c2f93b68
Parse the colon after acting on the operator name.
commit sha c90647925e6f08aee33e2a95b7246e9dcc0fb6cc
Don’t include the associativity in the name.
commit sha f59bf58ca058ce1641cc2e6f5d1d358759a9f7c7
:fire: a fixed FIXME: we shouldn’t.
commit sha d7c6af3fb237fee7020200706dade5a6aa01245e
Parse fixities following infix operator declarations.
commit sha c3c6f7b8c4e54686c48528d1f1bf6901de140b91
Declare fixities for the various function composition/application operators.
push time in 2 days
push eventrobrix/dotfiles
commit sha 8619a52ad1bdf031eddcdb3fce89b0696551d30f
While we’re at it, drop who to follow.
commit sha 61ecf5b6cdb94a66d8c36a4f70bc9f5e06205a98
It’s an aside, not a div.
push time in 2 days
push eventrobrix/dotfiles
commit sha dbcaa1c593aee8ab507a6d086ffb4f9c9f3ba56c
Turn off the timeline trends on the hellsite.
push time in 2 days
push eventrobrix/facet
commit sha 1a45556bde22974d2b0a8ff728ad1ec43854f63a
Spacing.
commit sha e446f60c7e1ae0e8029ff7cfc7877087845e8bb9
Add a heading.
commit sha c69e6694d046db45697acbb602b0d256a587fb94
Define a handler interpreting Error into Either.
commit sha 319145b731a2baf788955214508cf3b6500dd0ca
Spacing.
commit sha 64636700072f601b5fbeac749e888db5ec63489e
Add a heading.
commit sha e290b6da7e6ecce3e6d70acb294daf53f6ef9f3c
Add a method for effect patterns.
commit sha a234090aa06a9cf0d8b6d5b81373fc4e8e06103e
:fire: a fixed FIXME.
commit sha 818f6aa91f0a8ed76d1747eb6f3848f69a274edd
Destructure the argument binding up front.
commit sha 6e51c9cc27cb21f0d25d9b696af8849944049602
Define effect patterns in the surface AST.
commit sha 1bec9f258d324b075646dac19c5e29f7ef1340ef
Use a lambda to match errors.
commit sha edce9596739bbf3bf82e1cdc642f5b4134524dda
We need to handle the effect in the success continuation too.
commit sha 395a788293fd5a5d84ed72f508a84cd44002667b
:fire: done TODOs.
commit sha 3aafb05d3d75d32c2adab03e561f37567ab1b1cd
Use the correct name for the Either constructors.
commit sha 3dcd2eb03879905541ac6f37972ef6f890ff6922
Define an except operation.
commit sha 2e94471c55209f86dc746efdf7da13c9af395d7b
Parse effect patterns into the surface syntax.
commit sha 912ec34e9ca02c080dbed264fa5d38fd47c04572
Bind our type variables.
commit sha 325c5d1a4d37ad1e3b30d05194ba54a397f8edf1
:fire: BadContext errors.
commit sha 3658bf2de39225787c0d9d56422553ad3a39a9dd
:fire: language extensions.
commit sha b526e93f31904a6b81ac2a3b75cca073dcc325aa
Align.
commit sha dc757cbf8991c1e8176bfc35d0601ca6c9feadd0
Define a synonym for rows.
push time in 2 days
push eventrobrix/facet
commit sha dc21b42759cfce58078589718ffcf3f4f46ef3f2
Handle any errors in the load process.
commit sha ad639f7de8eb11ff00fc6e133bca6c4c14a311fb
Implement extending the search pths.
commit sha de8d1ffd22a9b72d8f7cccf6e7a6b6b36f2d0a0c
Store a set of search paths.
commit sha 27d088522d87fef74066b7be2d30d12f29dd10bd
Remove modules & search paths.
commit sha 4d8650e920971693554999a07d19af5ff6e492fb
Factor whole around.
commit sha 2c4f7569abe37cf6b8d1c8768bf7193e1a902e4e
We already parse the whole command.
commit sha aaf337e6f163ec25d1ccbd407d08741856993dd0
Define a module for an error effect.
commit sha c9c47c85b14c25ea273fdeab33a81b11b8ab8c6b
Define an Error effect.
commit sha d6cb18280f400f5e98c6513f6f2069e319afba4b
Define a flipped catch.
commit sha a230477335ee77e5f42f39defb51cb25bf2e1af6
Define a try operator.
commit sha ddd79da20a18336aac515590465b66e843189a01
Bind our type parameters.
commit sha 94cc4a78364d3d037d6b1f9b636a35d1640a019c
Define an error handler in CPS.
commit sha 9f9388b19d32ebb6aff8decc7e9b2722902cecac
Allow wildcards to match continuations.
commit sha a8a53574d5af674f1b9f22f1947bb155b085e07b
Import Data.Function.
push time in 2 days
push eventrobrix/facet
commit sha 6e7619bca5a54f0059f8114fcb5428050eb4b9df
Keep the parsed surface module for each file.
commit sha 0b644a94cbd8d822e407e22ee02320e541674474
Don’t re-export Notice from Facet.Notice.*.
commit sha 502af334281c39e079fad662a85b517100374a7d
Keep the source on loaded files.
commit sha 52c78405d5d5ee8cd3cb3bd0bd7d9a9051d8acbc
Spacing.
commit sha c965144d2f6b89d37a68a7f7dad883e4299bd79a
Update the state incrementally.
commit sha 98cfbe7a1c845681e6ee90bbd30c895f9d6f8aec
Store the elaborated module.
commit sha 3a9e020f99dcdbdd2c74fc950749df7e11dc2c30
Get the modification time when loading modules.
commit sha 765c29d5406bc4e8318f689713623e97cc406d0c
Define a helper to rethrow IOErrors.
commit sha 0b26126486b7ce9c0a14a72b13f0ae3986383891
Fix indentation.
commit sha ebea94bf5f36d3eabd8968a2e3ce8b12c89d5d1d
Reload when the file has been modified.
commit sha d862deb06c97542ad3203245cdd04eb6215a52fa
Avoid resetting the time.
commit sha 6154bb410f218688d43af1416bd7f64bb246c50f
:fire: a fixed FIXME.
commit sha d6c2808237d5d37de535859a14713f1ddaf0d7f1
Test reloads by file contents.
push time in 2 days
push eventrobrix/facet
commit sha 8418286093f0fee5f338e22e618ce9db687fcac8
Add search paths to the REPL.
commit sha eec9add0b635365fdd7e7c948d56d4d2a5ad7aa4
:fire: a fixed FIXME.
commit sha ab3f38d25d8378b7cff56d2f4b580086a5cc192e
Close the import of Data.Semigroup.
commit sha 8794933137dc7ad3be78f3d2487e5cc19aad0abf
Add helpers to format with hard line breaks.
commit sha 7a827fd9f99ec19a750b3f456ebc4e5b66d405a0
Define an action to show REPL state. Currently this is limited to the search paths.
commit sha 8627876585a45655d97da8a66aa490e53e3e9671
Add a command to show the paths.
commit sha 1f753b1fd83e294a1d40fec43b86968801597208
Reformat the Show target parsers.
commit sha 5b9809a70bdd68eec54c1cab66bd5c23e117f1dc
Show modules.
commit sha 4368bd354831ea676b4096e758593dec4c5abc74
Add a FIXME about module names.
commit sha a764a6312b2d670831f8bdebbc0f05bb4e32511a
Add a FIXME about loading multiple packages.
push time in 2 days
push eventrobrix/facet
commit sha 6f388d6de52721109db0dcfb7e38eafa40ca96ed
Define failure & success styles.
commit sha fcd311ef3d68bcd7be9fbad2614c3b4c74b8c5c4
Highlight the failure/success message with Style.
commit sha ccf40937f217ddb551bc8419d172548dcc84dca0
Define a Progress style.
commit sha c0e48c28986c0b73167894da30372d3825abcde2
Highlight the progress message with Style.
commit sha 7d6a49d4093fdded664041b71625c15a04d1bbce
Print everything with Style.
push time in 2 days
push eventrobrix/facet
commit sha b47e18d836f6b42d9eb5d24e1478fc987deb68e6
Did these.
commit sha a267e20e9eb9c4dff76876ff009404b31105e134
Align.
commit sha 7b1d281c262b23c2fd529adf8f0913ffc291f47a
Rename state to runState.
commit sha 4c9b7013de2cdabdf9c54d79ec6169899025fdb1
Rename church to state.
commit sha c68b207db19526b30247305cdd7ea6c59702b0d6
Define an execState handler.
commit sha fe1a3b670984a1877a57bb98502c0e8d297cf95d
Add a FIXME about extending surface quantifier syntax.
commit sha 3027deeb068338addb36dd4ff22d3c338bf4d8a6
Move imports after the module type.
commit sha ce9f18152b0772a8e64273840f2539e3bcf8e24c
:fire: Quote.
commit sha e112cce09ad57f45b5335433af1acac629aebed1
Factor out the common portion of printing variables.
commit sha 86c42926370fe300db6d7a71de5c947f10e057c9
Give a type signature for printVar.
commit sha ff252a2f3dc9a63878f6893a73e46c58ab3b48ab
Define explicit as a delta on surfce.
commit sha 79edc4166bd2ab193dbe93a6b8ac7e57ce8d3c7e
Extract the body of == to the top level.
commit sha f40b6aa64c6c1463f8d70daf7114c04fcce2524b
Export eq.
commit sha ebc1a2797e53d674f2b6fc50e8f58edd6118eb16
:fire: ScopedTypeVariables.
commit sha 15950d9a1960e9ead4af73224e91c2d32b762809
Allow algebras to represent multiple bindings at a time.
commit sha 63ec952b043e365a639eb76c91054f877490da38
Add a FIXME re: lambda vars.
commit sha e0dc02d264867ce9821148bb53c18a422a2c2473
Parse imports.
commit sha 3b56c61a6bfd16fe0297e7b96ba74eb59614ffe6
Don’t wrap a result type in braces. It’s unambiguous from the signature adjustment preceding it.
commit sha 715335e0dec88f536dc0840684a58f2df6eec5ed
Rename sig to typeSig.
commit sha 790e5641a941e53bc8d272d0dcd9c44e2d86e70e
Rename spanned to anned.
push time in 2 days
push eventrobrix/facet
commit sha 6f6265d98aef6a73dac680ccaa474ff91668018a
Define a unit signature.
commit sha 2a1c8b41ab5587c777d64d80d820fde5b3fa7c72
Import Facet.Core open.
commit sha 087c85fc56d18e902c1dce747b64f87792cd01ca
Define a kernel module.
commit sha 8874074f4f0eabc1ef3d7683fba8365d41b66dfe
:fire: redundant parens.
commit sha a4d6b1375cca4c95f497154d953d8b4735920152
DNames hold UNames.
commit sha 7a7c27e2d6e142985ede2133227ce8df256468a6
:fire: EName/TName in the lexer.
commit sha 316f3c0132807ca3afe69aacfc73a5ec59bbe4da
Don’t distinguish ENames in the parser.
commit sha 7506632535515b06a8ffffc3ddcf9a0cbee27e8b
Don’t distinguish TNames in the parser.
commit sha 97fc658eaac579c82cb29650aab0c1f84f886105
:fire: TName.
commit sha bddf9e8088686ccb0867addaf0dee165e02537cd
:fire: EName.
commit sha 48b34bd370dd52b718825d26c127ab12442ae10f
Use UName in place of CName.
commit sha e0ae39c0ae958eb5bd51c7472e3b16c811725d09
:fire: CName.
commit sha d5fefde1d92865c7428363b62856a739381f5e41
Import Facet.Name open.
commit sha c066bce32e744030d0a2f5924c7f996a7cfb43d2
Add Type to the Kernel module.
commit sha c7750adde355c8fdde79624bc9acf9d4a1e24e85
Monomorphize Env.
commit sha 1ce96e74f4fd59037af81762b270154d67c8c2ac
Record the constructor functions in the module.
commit sha 1b96e9f7cba5e5069cb74bdb1cc5e1c1ae11ea22
Construct environments from modules.
commit sha ec60b347591a62d5fa7c82dea4fdab15ad8c85e7
Spacing.
commit sha a965d0ee7f63a37970b686505dfb8cfb4abc3af3
Load the kernel module into the default environment.
commit sha 1118bdd1f2c0d8cd81c63a8fa7bfacab82c6fc48
Define a Pair module.
push time in 2 days
issue commenthaskell/vscode-haskell
Duplicate hints, popups, and processes
(I suspect this is what @bubba meant by standalone, above.)
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.
comment created time in 2 days
push eventrobrix/facet
commit sha 81edd99a360a866ff7262c13932f6c0916ceaa76
Move a FIXME to where it applies.
push time in 3 days
push eventrobrix/facet
commit sha 9bdea114845966f3ed0f07eba45a3df2c578e989
Simplify |-* slightly.
commit sha ef05dff08de0e8455c2de10611436f88cb346225
:fire: QExpr.
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.
commit sha 3010f68a29cfd72edd883dae4e585850ed24cecd
Compute the set of metavariables in a term.
commit sha 45cd357fcabb5522a2d549947bf99ba2dffee4af
Collect metas’ types.
commit sha 72e9e2a89d4818fb9ee62778125029baf302e9e1
Define a helper to generalize the metas in a value.
commit sha 03b88cf5d9c0b7ebc924a910b3be2633c2056454
Always print names for implicits.
commit sha 4bab290a93c546677999d988594fec02181c6258
Generalize types and kinds when printing.
push time in 3 days
push eventrobrix/facet
commit sha 3f4fc0d2652a4bef7c023450a0040f41527ccd93
Specialize the Eq instance for Value.
commit sha 58dd24586ca24eaf98f9ef515ef492e89e5658f6
Only hide the names of explicit term binders.
push time in 3 days
push eventrobrix/facet
commit sha c9b94249914a5dea259259007c0ca9b760827567
Add a note about warning on constructor/variable name overlap.
commit sha 13d1fcf50f84bf987588b3655d63faac0e4ef18a
Add a note about signature syntax.
commit sha 67610aaaf8379ed63e1b4c676ae58d824c89521c
Add a note about scoped effects.
commit sha f42a0449989036de0b5e133933c1e56f2cf8b83c
Add a note about matching effect patterns with square brackets.
commit sha 932f4319134408cb75267dad522ffc3530094b65
Add a handler for Reader.
commit sha 2a89bf953474c61e223d148284c5c00ca98e71fa
Add some notes about docs & module syntax.
commit sha fe81a4c1219ad24763b9024e74543c75a0e7a384
Define a handler for State.
commit sha 33bad40e6a2f8d559651f66a6556ac5da0ae54ab
Rename state to evalState.
commit sha 38c5e0dd849e7e30de1ea2932efe145390e46be6
Add a normal, pairing handler for State.
commit sha f56151d976dff950dd95701130a13d5498927120
Define a CPS State handler.
commit sha 9433d287779d2720d15f5b6390ecf7293dc793d0
Define the pairing State handler in terms of the CPS one.
commit sha db93a5e745114ee7e5ecbc74a8986e2f3bd48e2d
Define evalState in terms of church.
commit sha 35cf6ee028f69a47a376f1c6f5ce00b8fb7d5282
Move all the facet sources around.
push time in 3 days
push eventrobrix/facet
commit sha a08d10f95fe1614bb81bbb085585000816b7cc2f
Got a little overzealous with the renaming there.
commit sha 254251a70f6f0e76dd943f984b7404115bf5cf70
Define a State effect module.
commit sha 5414ed661546c9a755b3d819258d753d516bb6b5
Define a State effect interface.
commit sha 23c7ba33d0dc6fe90fe528d7af911849eacca187
We need Unit in scope.
commit sha 45e8ead48f8b415e74875b6ee64343906cb6f119
Add a bunch of notes about linearity and polarity.
commit sha 20a716765560951910c9711d02a90ae3f65de3bc
Define a module for lists.
commit sha 731b83389da9b0a403ed2a313c19c10395c4e0db
Define a List datatype
commit sha 20cfb8c57cfc9ad5483d5e894106a1023e42ad40
Define map over lists.
commit sha 8ddab6a201ea56bc971a1a41597a23ea777d16e9
Add a fixme about implicits.
commit sha 593c559b4bc0d0a4e977c094f6262269c8920528
Tighten the span around constructor patterns.
commit sha 44599dce4e278872308fa15d7771890eeafd8d4c
Define a Facet.Lexer module.
commit sha db8cf96c479f303600cae854e06e83a8a7c881c9
Weaken PositionParsing’s superclass all the way to Parsing.
commit sha 65c343caa9895d80096bd718f3f1df6d0d56484c
Define token kinds.
commit sha e5b1d18dfb07c6f6018815b46280f2fdcbd35145
Define tokens.
commit sha be6626c632d1840dee712535148814710cf97818
Define a parser for line comments.
commit sha 34dc55504f5f0288a3608058ab237712bf3a581e
Define a parser for tokens.
commit sha 696ca98faec0ac71f51940b95570211abe62eb2b
Skip whitespace after tokens.
commit sha dd2047a613b435dd3ffce83005c478f1c78a0b60
Lex underscores.
commit sha 7e2ef4587415b1be8b7b90408ade156ba73e59a0
Lex colons.
commit sha b814015444e3a6c0c27002a04a2e44c04a1cd71c
Lex parens and braces.
push time in 3 days
push eventrobrix/facet
commit sha e04eb74b7edfaa0517a9e5f56b13fd35839e8ff0
Add some notes about pattern elaboration.
push time in 3 days
push eventrobrix/facet
commit sha c29476767b7313aec16f6401c59a6e7900fa2a7f
Surface constructor patterns hold a stack.
commit sha 66167aea86bf27f13fa64be14de11ed02fc56b1e
Move the quantifier expectation down.
push time in 3 days
push eventrobrix/facet
commit sha 139c04936a058512d02978a0d60bdc4669f18c89
Add headings to Facet.Algebra.
commit sha 4cba343907a633d87e2341c4141e16870452bdbd
Eliminate var patterns eagerly in case'.
commit sha b7ea28b047a689d50cc567fa420c52650a3bd0e8
Only apply var patterns at the head of the list.
commit sha dcaf8fed2760fbe8d0a9ebd31700f055abcb50c6
Wrap cases.
commit sha f5315b35724dc8bd8c695df626522034c8548ec6
Wrap cases in the surface algebra too.
commit sha c054a3954cd9c86d530ebfd7b89ac2ee3efb0821
Define boolean disjunction.
push time in 4 days
push eventrobrix/facet
commit sha 472b555b50ed742b1674b80c4606761993b34f8e
Spacing.
commit sha 1e001444e2dface017d84d84e46d87b577039bbe
Turn on a bunch of default extensions.
commit sha adf6474b13853536cc03d6940df93cab41781cb8
Turn on the same set of exceptions in the ghci-flags script.
commit sha c84b554842c9e7f179e85779bb54ad476152a1d1
:fire: pretty much all of the per-file extensions.
commit sha e5035f1e46512bc5f8935436b3269c401799f06b
:fire: some redundant extensions.
commit sha b70c68ccb352a91050c93bb396a558f256f86526
Merge pull request #4 from robrix/default-extensions Default extensions
push time in 4 days
PR merged robrix/facet
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 😅
pr closed time in 4 days
PR opened robrix/facet
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 😅
pr created time in 4 days
push eventrobrix/facet
commit sha 47ff393930406fa56b6928a95ba2b510dc8fb549
Define a Base.Map module.
commit sha 396cc68513c5805dc75d7aa9b16f47f86819bc25
Define Map.
commit sha c9544021a4e4f35803189b989e02c7a344e88236
Reformat.
commit sha 46e4a3eb357eb65ce57c036fcdbc241c481ee32f
Label the commands en masse.
commit sha 69cc6d649874f54dfa4f0f8a512a2a318f243dea
Push more into the command parser.
commit sha 457552b0151228b0e5b8afac433e554d8b574591
Define an Eval Action.
commit sha 53fec629df7bf8d321ce7267064bfe9fdb4ecb21
Spacing.
commit sha 8aa9d9bb2dfc9058faa3ade2c3745a8e1bf8ac21
Define a parser for qualified names.
commit sha 3cade2f60ad91df120e8e1849041e53bc78ea6c8
Represent holes with UNames.
commit sha 279129ac737eaf2e73e788a3abf19370c4c72b78
:fire: aeq.
commit sha 77f4f2a1c17617652c34168709701fb700697fa1
Define a Pretty instance for MName.
commit sha fb5fe538856d6126963cd84aa15db5baf3e280ff
We can just say dot.
commit sha a667ba9403145515319687c6f10ad9c5968bed24
Define a Pretty instance for QName.
commit sha ffe1497b0149dc9ddec386cbe5bf0f8d9489dbeb
:fire: prettyMName.
commit sha 265822c391e9ddf68a5debdb4e6dd6cfcc9f6ff1
FreeVariable can have a qualifier.
commit sha 5551aacf5d52b1342e7ad02cebe62c51e0793ca5
Print the qualifier, if there is one.
commit sha 50e673e41bbb1f8160c35aaa70cd92950479c0ec
Define a helper to resolve a qualified name.
commit sha 9f6ef17f6b92495085b6be392073d7327d84a9b9
global takes a resolved name.
commit sha ad1ded98c2f9a4b8f3763c638a5c56d75b04ba29
Add qualified names to the surface syntax.
commit sha 9fdfdd3cf6be348c40d83acb0d6e335468a7b489
Parse qualified expression names.
push time in 4 days
push eventrobrix/facet
commit sha bf9dc63f0c857af46e18e8194b0049fc25b3d105
:fire: the old test module.
commit sha 32e772ecf0e92f3ef6f76c4dd755464698f6e38c
Define a module for Elab notices.
commit sha bace759c908e565084318dadfa7f994d5cecdc16
Define a module for Parser notices.
commit sha d34742d2dd4050fa0f581561a30f3513e0c80b76
Copy in Span.
commit sha bf0610ff4054c913b052cbfb4ccaf9827c4abcce
Copy in Source.
commit sha 41d8d4a3150b9bc651eeb698962beaddf6a69f96
Copy in the parser.
commit sha 9baa95920e2de9ed776efe7ebfb3c04bb8464d32
Don’t use the old Span.
commit sha cec7f29ccd6fcc596103016ea89361c7b74e2c58
Allow signatures to bind explicit type variables.
commit sha e72c9614d5a7be05f8eccf2ec37424db9fb86b47
Spacing.
commit sha 8bb43330e1c03a39e21fb9c169c6060d8f3fc417
Correct a fixme.
commit sha f49faa2dd0542a8191fd4d1ec530c3dfd95c6fcc
Simplify how we bind variables in signatures.
commit sha a011cf36332a6221f85d50ed4289c1a2e94623e0
Simplify the structure of how binders are parsed.
commit sha a92691eb9780adf397382323d34ae452d50bc014
Move sig into decl.
commit sha 781ce23fb2c38830d4805bfb7cfba00c083e1410
Revert "Move sig into decl." This reverts commit a92691eb9780adf397382323d34ae452d50bc014.
commit sha 2d25869af87c442f73a7215335061d1243464c3e
Parameterize binder by the type of names.
commit sha 4ddeec4e9dacd03c2450c858de9383a1d8c8bea3
Parameter sig by the parser for names.
commit sha d2675bcd46193cf112e0994351be289d2bcea8b6
Reformat the signature for binder.
commit sha 2d03a07655529b831296a8d7294ceee2764c43ae
Parameterize binder by the constructor for its arrows.
commit sha d35f65aa6c3cb58ba53e46baeb4bffbde1bc6c40
Generalize binder over the decl type.
commit sha a55d3cdb4ec798652bc9750dd6978e1e3618ec1c
:fire: the spanned combinator.
push time in 4 days
PR merged robrix/facet
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.
pr closed time in 4 days
PR opened robrix/facet
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.
pr created time in 4 days
push eventrobrix/facet
commit sha 7696581eec68d8f74a48bf42ad153ddfa088124d
Add an Option datatype.
push time in 4 days
push eventfused-effects/fused-effects-parser
commit sha f18ea3cd59ac0983cbc100de42d9bace5b038d09
Don’t use the old span.
push time in 4 days
push eventrobrix/facet
commit sha eb9ff44dbbb331ba096874341c414f4b220acca3
Add a FIXME about checking if we need to reload a file.
commit sha b5660207cd6256b0adb72f0bd095c2cc08887327
Loading reloads.
commit sha 311b4a6f925318150fc7b167847da2593ef6dd3f
Reformat.
commit sha 68c9904604cba409021a523fe1d0468585fab8ae
Move File down.
commit sha fd1eb285fb8d53269143e869964c919637ddbb43
Spacing.
commit sha 2fb47c90d20be4ecc12ca4d72c9c93f619fc9d83
Define a lens acting on the loaded state of a File.
commit sha 4d02c0b2cf6f36761ecc31564da812988117f4df
Set the loaded state.
commit sha 6e2e0b3d4945efbc0aa4e8a2a1d0dbe599f9769f
Spacing.
commit sha 440bf555a20dd595310d085d91f09f518bf60e02
Copy in the ~> combinator from starlight.
commit sha 57ecc43e66a32d1580d630675bcdbf5d9f24c0a7
Copy in the <~> combinator from starlight.
commit sha 5551548c0af9be88880c0511756a0c983e3c4f0e
Check before loading; update after loading. Co-Authored-By: Patrick Thomson <[email protected]>
commit sha c172f36f77b5b7097ed0b8575a18d630fb1e2238
Move defaultPromptFunction down.
commit sha 7e83fc3d99f572e9a762bdb24266d58c879c5aa6
Spacing.
commit sha 141c0951aca42859e5555d32cecdb8559e80f98c
Extract the default REPL state.
commit sha 43083dee21dd8164b35b45bc1ac413be2121ca17
Get the files in one pass.
commit sha 1aa5ef9591b21c6ac5b24197707c2b183b0569fd
Rename success to heading.
commit sha 1711d632d57c39fa179a6b2303539dd2d34fb50c
Unqualify the import of Facet.Pretty.
commit sha 6cb523c330d5bce37cabe49190970699f65f21a3
Unqualify all of the symbols from Facet.Pretty.
commit sha c39e3480addb85829f3297ba2ee496cef33443f0
Unqualify System.Console.ANSI.
commit sha e1819e86b7de6994f3b8de9e3e341d68b687aac6
Move setRGB & bold to Facet.Pretty.
push time in 4 days
issue closedfused-effects/fused-effects-readline
prompt should probably work with Text instead of String.
closed time in 4 days
robrix
issue commentfused-effects/fused-effects-readline
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.
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.
comment created time in 4 days
push eventfused-effects/fused-effects-readline
commit sha c4ea2da069c9150713d76830253e961e1f8d157e
:fire: a changelog entry which doesn’t make sense any more.
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.
commit sha d8a35005ae28e827c92b4fe122f62d015a9a8e24
Add a note to the changelog.
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
commit sha 67ed2b7193d5f12b4968b94396fa807126021efc
Simplify the GHCI module by rethrowing errors.
commit sha d99a75c4aa8ecf21d8d45d074316403243777d18
Rethrow elaboration errors.
commit sha 5955ef4646e14c32295be0f046aea8cf74583677
Rename rethrowingFromParser to rethrowParseErrors.
commit sha 9d9b753497f440b24b8e0a79e39e6a98554c3c43
Move sgrStyle into Facet.Pretty.
commit sha b1dd844ea808d63216f8cad08462fb4b62e02d23
Define a Facet.Notice module.
commit sha c53de02c51f07d83136d1356d4d5bd1961c427f5
Re-export Notice.
commit sha 87955ec45f587179b88e1cb3ce85593500806a68
Re-export Notice’s fields & constructor.
commit sha 14df822bf2b13f624ffce3608bdb10fc731937d4
Use Notice unqualified.
commit sha 423761ad63b640aa359a96ae7798f8fcab591067
Define a simple prettyNotice helper.
commit sha a7be8bcc574b766bdf11e56d8f67bcf433d9c4b1
Pretty-print notices with the helper.
commit sha b145af7962576dd08d915c84fd0a7b37af7160a6
Re-export Doc from Facet.Pretty.
commit sha 55764bdb3c5022a020fe72e1209c80c0202b5088
:fire: a redundant qualifier.
commit sha d56863f7c01353cbc9912a9ea29c1a6c8012876d
Re-export layoutSmart from Facet.Pretty.
commit sha caba9ff8a984c203189f49c08c3854a5cbfd2b9e
Move rethrowParseErrors into Facet.Notice.
commit sha 96c857cf98ae80e10d39d7aac4cd3a2313772d59
Print notices with prettyNotice.
commit sha 83ae641dbeb7264a3a647d0e22c28cb8edd57662
Add headings.
commit sha 91f4432eae458018bde7b1caa6e2c8b538387385
Move elaboration error formatting to Facet.Notice.
commit sha 96c86105e00837abeeb6dfddc455fedcd044cd68
prompt returns the Source.
commit sha a6d159617b77d61ba7d54e6e890100b82530533d
Add a FIXME about factoring surface/explicit.
commit sha 5bb809e1a5d7c7fd423ff6e52ce827a582d024c6
Export ann.
push time in 4 days
push eventrobrix/dotfiles
commit sha 85d8902b5c31c29b7f403d3bf90dbc50ba5655b1
Add keybindings for navigating between errors.
commit sha 1b74f884a222555c1b36c167e5ce379c6e455c84
Turn on fancy conflict resolutions.
commit sha 78e18dce71cfed7693bf3f85ef31d9d5c1e6a712
Add a shortcut to show the hover.
commit sha e4189f914b08a5360dccbe3545af53d75df21fcc
Add a shortcut to go to def.
commit sha 67a5939b8498ac26d2bc44b23d357a4101382b25
I wish this were stable.
commit sha a082e10c67c9d460b32d72a837d14e8b026f2e96
Tweak the theme to increase contrast.
commit sha 0cd55d23221a3994a0e8368b143c8093651b29ee
Tweak suggestions.
commit sha 2a1c988ec40c1fc37b305b4c16ae2dafad8c81d5
Go back to compact pinned tabs.
commit sha d46faafd85dd60dc93a1026d201002ea68732913
Disable code lenses for now. haskell-language-server makes them unusable since the imports are always jumping around as you edit.
commit sha 210b9f359adc0d5d6fd92c20cef94a9f474b21c4
Format on save.
push time in 4 days
push eventrobrix/facet
commit sha cd5b4eb28e706c6b6a8cec271ad337de8121df58
Derive a MonadIO instance for Inject.ThrowC.
commit sha b412c168131c13f5f2d787c17f58dd92ffdd0e97
Derive a MonadIO instance for Lens.ErrorC.
commit sha 4a640c157f4168f71baa22ef5dc9ab093399beae
Derive a MonadIO instance for Lens.StateC.
commit sha 9df4b93b9312d3402be8a6b917631d433ea7079a
Use rethrowingFromParser to obviate the need for our own definition of runParserWithFile.
push time in 4 days
push eventrobrix/facet
commit sha 07d94da0296862297f74791a4681772856f053db
Define a module for an injecting Throw carrier.
commit sha 810d2afd7528c8118a0f0c3952e4107c44b10ca6
Define a Throw carrier around a function.
commit sha 0d492e6f1299dce8ac9608d4b36bda391a184d22
Add a heading.
commit sha 87b199b790000b4109624e1e2c66c3169b9a591c
Define a handler for ThrowC.
commit sha 0af5fc385a6a2bde1138612254f7c3835e4f8ae1
Derive some instances.
commit sha e76b41f75a817588fb4e1a6649f434381240dbaa
Re-export the Throw effect.
commit sha a2f7a516aafc174db167dd612022912a30f42669
Define an Algebra instance for ThrowC.
commit sha 60301255a17fa4c04371e3e075dcfa216e420045
Define a helper to rethrow errors from the parser as Notices.
commit sha e221d13ed283bcd1dbd7192976e48f3f23916dac
runParserWithString takes a line.
commit sha 9fdf5e7b3737456186f1a9f5f0302fbd93d92ac7
Spacing.
commit sha eeb6ea6e3a5cd51a23db03ca72d8e3297e1c143a
Use rethrowingFromParser to obviate the need for our own definition of runParserWithString.
push time in 4 days
push eventrobrix/facet
commit sha d7865fa599e340cb7c0ba62d2234ca2bdb461359
Define a lens for the line number.
commit sha 081a4fb42e53090f01a314fb9e3e03166067c331
Increment the line.
commit sha 02622f102ba1c93560dc3476a7bb67c39a4afe50
Bump fused-effects-parser for numbered lines.
commit sha 1bdaf472afd5e8317e6ab0a189c12afec24e4466
Style.
commit sha d96a30b562477dfb5c526ce7849ddb2ef40c729c
Extract a higher-order function.
commit sha 1209b118ed10e0d8d3fb89a0d66056d1068c5450
Command symbols must be followed by whitespace or eof.
commit sha 114e6d50075df8997abf3e486b4ea19cd82932df
Allow commands to backtrack until complete.
commit sha d6773ba47f9e743eb9849b4bfede6c571551a5f4
Parse command symbols into the void.
commit sha 50a9f38841d17fc949df671d268daa239a5abd3d
Add an env field to the repl state.
commit sha c4c3420feff0f4555891326c8cbbd003eedcba67
Define a lens for the repl’s environment.
commit sha fa5f5d372388057047b25e292ebf0666a4423066
Rename elab to runElab.
commit sha 10908305527443cb7ff3268b2efe545a9ff768df
Extract a bunch of the machinery out of elabModule.
commit sha 84991b2363e4fa16fa191ce82aff3ce72a6d49ab
Define a convenience function to run an elaborator.
commit sha 6772034856c6f66011c3ae31e3c0a2c7a422518b
Factor a runSubstWith handler out of runSubst.
commit sha 15518a34f43ef0e12066cdde17fbec68b6a88974
apply can perform effects.
commit sha 78c275048276595220199679223afb93dcc22919
Define an elab variant parameterized by a function to apply the substitution.
commit sha d441a57570188e691fe9e0c1d488aea2413d7ad5
Define elabModule in terms of elab/elabWith.
commit sha 56d55abdf49ed224be2b08a009087f499a37be92
Export apply.
commit sha 244e3aedeaaa1d99254cd48845be5a52292b5725
Rename Value to Arg.
commit sha 786e457667ed3266e180c4a70fbb0a51b741a7ed
Bump fused-effects-parser.
push time in 4 days
push eventfused-effects/fused-effects-parser
commit sha 4aa243b353362996ab3645e67efe416b4d5f284c
Source has a Span.
commit sha 761d1e9ab5cf37bd4cd411bb83bb1f7c6a16c80b
Define runParserWithString in terms of runParserWithSource.
commit sha dc80407c9082b7bae71867814fb0ee75d26009be
:fire: runParserWith.
commit sha 6ca319447647b57e375bf2327fa0952eb6b857a8
Define a lens over a Source’s Span.
commit sha b177cc965c943a547584dbc84dc985da7976d86e
Define a lens over a Source’s contents.
commit sha ce660624516bdbc35621567dc0a6863f515a3147
Tweak the :memo: for span_.
commit sha 72716de96ef42b1d904107f7f8d500d7c92ca5a1
:memo: contents_.
commit sha 1cfa7b89fe3c9650e0f03a62a5870732e3cce233
Define a lens over a Source’s lines.
commit sha 30c1c4252445b49d2618c8589cb56fc763366418
:memo: lines_.
commit sha a005371867e45612161c88c2a374600519a8ac7f
Define a lens over a Source’s path.
commit sha d8ea22619f498ff68dff7c4d3a20e1774794b3bc
Define a function to slice a source.
commit sha c0882eefab58ad69ce27fe8bac73f52edbff728d
Notice holds a Source as its excerpt.
commit sha ed15caac09b3e3cde33e5884cfe4c3879f33a19d
:fire: Control.Effect.Parser.Excerpt.
push time in 5 days
push eventfused-effects/fused-effects-parser
commit sha 3bdbde7445fd8c7beccb54383645b320a32bd39c
Give Source a field for its contents.
commit sha f13ada3cdbc39661ddbef86fd8b59a8aab540e05
Define a ParserC handler taking a Source.
commit sha a422faa93f2ffbc6f13717edfb8fba9d06b869c3
Define runParserWithFile in terms of runParserWithSource.
commit sha 653bbf5fa847d09f6707325c0319646f88cbf9fe
runParserWithSttring takes a line, not a Pos. Error reporting via Source, Excerpt, Notice, etc. is heavily line-oriented.
commit sha 9738dde5332ec6ddb6c34ce5be44662ae2350271
Add a couple of FIXMEs.
commit sha 160837e74a0f57bf1473ee8f8a1648764ac3f3e9
Add some FIXMEs about Input.
push time in 5 days
push eventfused-effects/fused-effects-parser
commit sha 6b3ff716680066496092930c541a733b5d992c7f
Define ! in terms of !...
commit sha 60a6c7045c96ba4fc8bc4dcff5e600643fdbaae1
Import the source module.
commit sha 269b215c3becb7519b643e81851962bb418af3a2
Spacing.
commit sha 3ea983f239438b87ada3ad8c6fc38fc061f1fb10
Add a start line to Source.
commit sha e4a447ccc071a83f107440558ae7c97175b21bbc
Lines are numbered.
commit sha e295775e4b68e013862428abe048b593bd332d4f
Rework slicing in terms of line numbers.
push time in 5 days
push eventrobrix/facet
commit sha 39bc1380226fbef766979c8e72b78d112652a121
Define a module for an evaluator.
commit sha 72c9e2471fb78791f3ad7a27d1c6eb318b83297b
Bump fused-effets-parser for some assertions.
commit sha 70bb19bb60054fc0223db33cfa47b69c91572520
Maintain the line as part of the REPL state.
push time in 5 days
push eventfused-effects/fused-effects-parser
commit sha bc958f5c0d5219e92c783811a872376fd592f214
Assert that the span is well-ordered.
commit sha 4ced42072167928dd514e5c0499d47e6f5f97f21
Define a helper to read Source from a file.
push time in 5 days
push eventrobrix/facet
commit sha 8290aab0bcbb900b4299c99fb622433b6ec7fbba
Add a FIXME about nested clauses being elaborated incorrectly.
commit sha 8915f563528110b3b97df448ad1a36077c424054
Rename expectQuantifiedType to expectQuantifier.
push time in 5 days
push eventrobrix/facet
commit sha 6751461e46ee4f96e81b97c8371cb85edf7ffc23
Specialize the error helpers.
commit sha ffe22c333922f25c62fc746bad6d2a833feb3c7e
Populate error contexts.
commit sha 861a309e7a69bdf092a2ef22eda0bac813892ba3
:fire: handleBinder & handleBinderP.
commit sha 9a383064ce691e1de87b8404e76a7a2362d2b2e0
Generalize |-.
commit sha e311955bbc293417c63f9fcc2e96048d9fadfcdd
Add a FIXME about correcting elabPattern.
commit sha aad44fa39c27fcc3aa36f2b082c87716d29c4f4c
Define boolean conjunction.
commit sha 374c9c5674ecd41b84ccfec335901acab5fddff8
Better rendering of cases.
push time in 5 days
push eventrobrix/facet
commit sha 851b625bcc890b50b5f13b4d7475115cd12e635b
Amend a FIXME.
commit sha 3470886714a3463e971efb431821feda19d1d147
:fire: getSubst. It’s unnecessary now that we’re monomorphic.
commit sha 42fe84e1008b95b49584d347d60c764e89e27498
:fire: some lets.
commit sha f3170d0cf9b7b87ecaf23ee8020230541bb58129
Use Head in both Value and QExpr.
commit sha ea523fa5562e2af8f918c0fa14569047664f3ca9
:fire: redundant parens.
commit sha 0968e40d6d684ed8498b309292dc82c262297c96
:fire: a fixed FIXME.
commit sha 10ef73227432960fc65b5a4478261ae227d2b103
:fire: wildcards from core.
commit sha 80efa840c4205cb431b72e77f7ed31964f37f02f
Rename the core pattern constructors.
commit sha f3f1d0cd54d6778a1fbe9ce0ec900e1d809df819
Define a Con datatype representing constructors.
commit sha eb5194a9eec4b526cc4aa939527b9e1346af53f0
Define a bunch of instances for Con.
commit sha 8c118c5149e5c76225ae9e316f9970cf3e5001c3
Define a Bifunctor instance for Con.
commit sha 041036bc2b2c4d4a91994637870f66a5b140cc32
Define a Bifoldable instance for Con.
commit sha 738ac054823db7c7e0e71cdaae4285360901f5f1
Define a BItraversable instance for Con.
commit sha 9314db4be969cc3ce8ed8437061dce82ab4ab8fa
Use default definitions of bimap and bifoldMap.
commit sha 0c80c0914ca116261958f73619e2fc421a6f8746
Add a FIXME about eliminating var patterns eagerly.
commit sha 5c7233ba205c157ce5b079327b47105f5b277473
Correct the Bitraversable instance for Con.
commit sha d0111d5edb3e55eae9439b55850b7fd15852cd76
VCon wraps Con.
commit sha 42d7f8010ee72d62f8d7416fe6a26e61862d5ff2
QCon wraps Con.
commit sha f3ae4f8f02b96eb57fa480b76158b00400da36a4
Define a Zip instance for Stack.
commit sha 964fde39b85b3111c3238927375b79509e13c214
PCon wraps Con.
push time in 5 days
push eventrobrix/facet
commit sha a15d5d4e251f75115c26b9c352958a75c35cbb75
Add a dependency on ansi-terminal.
commit sha 7a0c5af6477ae26294cdd190a6ee9cbc55512670
Render SimpleDocStreams with SGR codes.
commit sha 74515d425b8dc67e1da7217221c59e95af49efcc
Copy and adapt renderLazy.
commit sha c56cb861810d16ebe60d774f8996d351ed3f6f90
Define a function mapping AnsiStyle to [SGR].
commit sha 6c0436c4f47cf660ceafa44da551312b2d5ae727
Fix some ambiguities.
commit sha 74295028dd5b8fd54f1bb326a84fd4ab1243c31c
Bump fused-effects-parser.
commit sha 6ceb4a0fcd63544ac4dd72e5c1ebcb36bae7aa1c
:fire: ErrDoc.
commit sha c5e76cf24c0e184c64b901dac5c85fedcddeeeba
Push an initial state onto the stack.
commit sha f6f6515ea00c62f29efeb895ce86c136e7c216bb
Pretty-print using SGR codes.
commit sha de90ff2cf8e29807d641bcccfd5eebdfa2246c31
Fix colour selection.
commit sha 3e351a6d0c5ed531882d8b33bdd86e2c45570709
Pick named RGB colours for specific syntactic categories.
commit sha d3b8c4999b7a790361a806aad049618483806a39
Factor out the bold marker.
commit sha 7baa38655cbe3ab1728d4d3ae10ee93bcd0b42c9
Pick HSL colours.
commit sha b63aa43014e3032356d145f06e877d28b3340f63
Tweak metas.
commit sha 0cfe85a714241a972b204d857c5fdac43461b5e6
Take slightly smaller steps.
commit sha e8236618896d74f8d56e74bfdd42310b61679170
Fade brackets out a little.
commit sha 9e12eba0c72a017f5fbb161cc1f4a154bafe74dd
:fire: the dependency on prettyprinter-ansi-terminal.
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
push time in 5 days
PR merged robrix/facet
This PR migrates away from prettyprinter-ansi-terminal onto direct usage of ansi-terminal: annotations destined for the terminal are now [SGR].
pr closed time in 5 days
push eventrobrix/facet
commit sha 9e12eba0c72a017f5fbb161cc1f4a154bafe74dd
:fire: the dependency on prettyprinter-ansi-terminal.
push time in 5 days
PR opened robrix/facet
This PR migrates away from prettyprinter-ansi-terminal onto direct usage of ansi-terminal: annotations destined for the terminal are now [SGR].
pr created time in 5 days
push eventrobrix/facet
commit sha e8236618896d74f8d56e74bfdd42310b61679170
Fade brackets out a little.
push time in 5 days
push eventrobrix/facet
commit sha 3e351a6d0c5ed531882d8b33bdd86e2c45570709
Pick named RGB colours for specific syntactic categories.
commit sha d3b8c4999b7a790361a806aad049618483806a39
Factor out the bold marker.
commit sha 7baa38655cbe3ab1728d4d3ae10ee93bcd0b42c9
Pick HSL colours.
commit sha b63aa43014e3032356d145f06e877d28b3340f63
Tweak metas.
commit sha 0cfe85a714241a972b204d857c5fdac43461b5e6
Take slightly smaller steps.
push time in 5 days
push eventfused-effects/fused-effects-parser
commit sha aa3c6349dad5e359d7fecc5403c1c183dbd2ca1c
Generalize errToNotice over the annotation type.
push time in 5 days
push eventfused-effects/fused-effects-parser
commit sha 75b3ce4068538ccfda8322c9718b28fd2dbad1fa
Throw the source and err.
push time in 5 days
push eventfused-effects/fused-effects-parser
commit sha f9c3866b8989d0d110f7fb6dabf36e579328640e
Define a span_ lens for Excerpt.
commit sha dbbf0b1eb18ce8fe743aa3dd6f159184fc9b2dc4
Source has a non-empty list of lines.
commit sha 1b5059b06c80e6d5d3a957efb9c33d56d401307c
takeLine operates in Maybe.
commit sha c1b13cdb4511699d171f96e977a7c299f8d20167
Slightly clearer operations.
commit sha 66957cd26da382a3d8fde5f12a82098a2e86be1f
Extract a range of lines from a Source.
commit sha d2cae51edaece463862a15b8d5aea1f659c1a085
Build the excerpt with fromSourceAndSpan.
commit sha d76373d549f584c61b2d3851efc8f201957837aa
Excerpts hold a non-empty list of lines.
commit sha 431f66b13b9538e74504f7ef063f8e5d0aa006cc
Don’t allow grouping to flatten lines.
push time in 5 days
push eventfused-effects/fused-effects-parser
commit sha 18232a570d607b3e84f27943df25ae5586a56a0c
:fire: the dependency on selective.
commit sha 10571dd8863a08397293df8f8320f6d4e870e5f2
Factor Doc out of Err.
commit sha 079af9bc327f57fba8b93447c40f39b3a318dadd
Derive Eq & Ord instances for Err.
commit sha 5a1fa87cf2f0e5664ba02128fbaed4290bb07f36
Align.
commit sha c6ba55af48a32a5f548883a888039fa6503745e0
Align.
push time in 5 days
push eventfused-effects/fused-effects-parser
commit sha b0231be1c335dcb80b538d579b403721f201c851
Sort imports.
commit sha 7263883d051999d591a4a293882f2a69ea58fc15
Give Notice a parameter for the doc highlights.
commit sha 9f6bf9685e7ff375e7e6d7d975c0bde3e7e89d97
Generalize the Notice lenses.
commit sha 55f34f317238e9752fabd4e4376682b57725f976
Define a polymorphic Lens synonym.
commit sha eca9d0769a75763a2aa2ca9ef33dd6b4a5425d4f
Define monomorphic lenses in terms of polymorphic ones.
commit sha 6c7ec238e8f8449b00b85bd4640374bc253cde92
Generalize the lens constructor to polymorphic lenses.
commit sha c89b866658ceb72c3458ae9105fc990a258cb688
Generalize .~ to polymorphic update.
commit sha 161652c6e864c19dffdb12e78cc87f9a147412ba
Generalize %~ to polymorphic update.
commit sha 68b50a801924338c954e0f4c180325a82e3a94df
Define a Pretty instance for Level.
commit sha f267c8749a730c0ef2e5fce58a50c0f6edc27a8d
Define a datatype giving styling for a Notice.
commit sha 72297e738ab92fa6458c12fe6c5a623cc82a759c
Define a default ANSI style.
commit sha 2acdb9f4634cd16c2bb1e778671a2bae6850dbbc
:fire: the export of prettyLevel.
commit sha 207c47779c7e48164c56966412c17aad12c1e27d
Move prettyLine into the where clause.
commit sha c09281349d8ce0a726dc9d87b84e2ad97b8da0ab
Move prettyLevel into the where clause.
commit sha 261460ef346d5b485f5b3fab1767a515e1b74c67
Move the various colours into the where clause.
commit sha 987fd3a0d4c6218dc128e33c564707982c5fd0a6
Define a prettyNotice analogue parameterized by a Style.
commit sha f4b2252889d7ae889bbb2166b8b7fcb7913e8ead
Define prettyNotice in terms of prettyNoticeWith & ansiStyle.
commit sha 35973e35ab5609f51da2ad33827e425309f54fbc
Define an AnyDoc newtype quantified over the highlight.
commit sha bd07f78ba346c303d2905abb6edb23508c13fa86
Spacing.
commit sha f86f96a17f4dfdac3450de45b2fa6623b44751ff
Define a Show instance for AnyDoc.
push time in 5 days
push eventrobrix/facet
commit sha 72c1927fe0bbc4f212e8bca606afae5a93b8fab5
Monomorphize the surface syntax.
commit sha 61b2fc4db3b4cb30cc09dc7bf84a8a380e283296
:fire: Contextual & AValue.
commit sha 9288924d653e4fb788f9dd8b2a20c4fec6bd310d
:fire: the Val synonym.
commit sha 593cdef657fca974f01209076f9dd1e6e904678d
:fire: M.
commit sha bf8ec7b3f9746b6d1bcb78737a7a365b5d8730d9
Monomorphize core.
commit sha 2ce58028a7494b344d0bb41df3fe2e18ddd35c8c
Don’t export toNotice.
commit sha 7360c02bf95827dec759a1fce1539958b1a1a0de
Algebras carry stacks of context around.
commit sha 85b06519ca5c173dde1123496c671fc51a601eb6
Pull variables’ results from the context.
commit sha 1c94bbb5681116aa0489c48662d3f2ef5cd048c3
:fire: evar & tvar.
commit sha 12cbcb85568360d9e4c1bdec86204b82e1e1dcca
Add a note about maybe allowing parens to be dropped around constructor patterns when the constructor is qualified.
commit sha a13d63561c1d907034b9eafa193ad50e492dd560
Hole annotations take a metavar and use it to pick a colour.
commit sha 028a082104a364ae70bdee0e3df8e32413c5203a
Increment the level as we walk the bindings.
commit sha 9193ca737757d0c43d66ed64367f4048b674b214
Generalize tabulation over the annotation type.
commit sha 9846b4960a34493206b3a25e64a45c4507db4c4c
:fire: the ANSI terminal colour helpers.
push time in 6 days
push eventrobrix/facet
commit sha c8712502d847c794bc306e9376f06c97bd926e3f
:fire: a bullet.
commit sha f64feeab86dd26c79b96b89b34b8828417231529
Evaluate constructor pattern matches.
commit sha d8626a00da407f3da35d933f7804630ba34440d6
Enumerate the cases so we don’t miss more as they’re added.
commit sha bb43930c2ea2a770b6fa24f95c21b2bda4a77453
Match matching matches other matching.
commit sha 22d6d2a109aa9f78c7e91f6e69f0e2e57e5202eb
Put qvars into their own syntactic category so we can distinguish them.
commit sha 47575b815dff3f3cdb8bc39d3b5a138c2096a3f0
Return the substituted value.
commit sha 7632aeed739bf02ad53b2508c65b875ab1d015ce
Rename the Meta constructor back to Metavar.
commit sha 9bfa7fc6793aadccda061ddb2c83ee19337a67ef
Rename the Meta constructor of Algebra.Var to Metavar.
commit sha 8a3c336eff5445de41264d9bb2ef0617e0b1ed2d
Define a Meta newtype.
commit sha ed20dcedcbec7d0b62cdd58b32f9334342430231
Use Meta for metavars.
commit sha 496b8d0366b0070187553c398cd703fa8f57ec6c
Return the metavariable directly from meta.
commit sha 4f60afd84f6827ef8194a92bbe4e7c375b92c826
Use metavariable substitution to deal with |-.
commit sha 70bbdbf786b50680e07497a0b8df6a4cc24fedd3
Add a FIXME about naming metas.
commit sha 8eea41b4c55b8d1e37d0068d65fc77578aa25bda
Return the type from meta.
commit sha 385f59deb4a18833de0e63834b56d2e4a13b66ba
Handle binders in patterns using metavars.
commit sha b2af3786e1a1ff950338a0d11375a30d81972ab8
:fire: substQ.
commit sha 5bbcbbdb04ee1898db502b61b319dc738a807d7f
Spacing.
commit sha c62f98cb18421d5ef02aee75f98adc1af546082b
Merge subst & substHead.
commit sha 5990df3b8ede8af88f39c3e28850a47e31de3f10
Don’t unify if the im/explicitness doesn’t line up.
commit sha 46e9896d82b97b5ae5323b425c3a89dbe34f9ea5
Add a FIXME about tracing.
push time in 6 days
issue openedfused-effects/fused-effects-system
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
commit sha fae0e4daacacf9eca6d5cea1cf045c831da0190c
lifts upper bound on template-haskell for compatibility with ghc-8.10.2
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
push time in 6 days