Bugfixes:

• Drops libtinfo again to avoid compatibility issues on Linux (#4266 by @JordanMartinez)

Other improvements:

• Update CI to use windows-2019 (#4278 by @JordanMartinez)

Alpha release for use in preparing for the upcoming v0.15.0 release.

Bugfixes:

• Remove libtinfo dependency again (#4266 by @JordanMartinez)

  libtinfo causes compatibility issues across different Linux distributions and versions.
  In v0.14.7, that dependency seems to have inadvertently reappeared.
  This release fixes that regression.

Alpha release for use in preparing for the upcoming v0.15.0 release.

Alpha release for use in preparing for the upcoming v0.15.0 release.

0.14.7

New features:

• Make Prim.TypeError's Quote work on all kinds, not just kind Type. (#4142 by @xgrommx)

• Display role annotations in HTML docs (#4121 by @JordanMartinez)

  Previously, the HTML docs would not indicate which types could be safely
  coerced and which could not:

  -- cannot be coerced
  data Foo1 a = Foo1 a
  type role Foo1 nominal
  
  -- can be coerced
  data Foo2 a = Foo2
  type role Foo2 phantom
  
  -- can be coerced in some contexts
  data Foo3 a = Foo3 a
  type role Foo3 representational
  

  The HTML docs now display the role annotations either explicitly
  declared by the developer or those inferred by the compiler.

  Since role annotations are an advanced feature and since most type
  parameters' roles are the representational role, the phantom and
  nominal role annotations are displayed in documentation whereas the
  representational role is not, similar to "uninteresting" kind signatures.

  Lastly, FFI declarations like below...

  foreign import data Foo :: (Type -> Type) -> Type
  type role Foo nominal
  

  ...will be rendered as though they are data declarations:

  data Foo :: (Type -> Type) -> Type
  data Foo t0
  type role Foo nominal
  

  One can distinguish FFI declarations with roles separately from normal data
  declarations that have roles based on the name of the type parameters. Since FFI declarations' type parameters are implicit and thus unnamed, the compiler will generate their name: t0, t1, ..., tN where N is a zero-based
  index of the type parameter.

  Note: the resulting documentation will display the roles, but the roles
  will not be selectable when selecting the type in case one wants to
  copy-paste the type into source code.

• Rewrite Partial optimization to be cleaner (#4208 by @rhendric)

  This feature shrinks the generated JS code for declarations that use
  empty type classes, such as Partial, but is otherwise not expected to
  have user-visible consequences.

• Add support for publishing via the purs.json manifest format (#4233 by @thomashoneyman)

  This feature expands compiler support for publishing packages with different
  manifest formats. Previously, packages had to have a bower.json manifest;
  now, packages can choose to have a purs.json manifest instead.

  This feature provides only partial support for packages published to the
  PureScript registry using the purs.json manifest format. Registry packages
  are allowed to be hosted anywhere (not just GitHub), and do not need to be
  Git repositories at all. However, purs publish and its primary consumer,
  Pursuit, both require packages to be available on GitHub and for their version
  to be a SemVer-compliant Git tag. Therefore, this feature only supports
  registry packages that are compatible with these restrictions.

Bugfixes:

• Add missing source spans to data constructors when generating docs (#4202 by @PureFunctor)

• Check role declarations arity during type checking (#4157 by @kl0tl)

• Optimize newtype applications with the ($) operator (#4205 by @PureFunctor)

• Properly deserialize unused identifiers in the CoreFn (#4221 by @sjpgarcia)

  This mostly affects downstream consumers of the CoreFn as discussed in
  #4201. This makes it so CoreFn deserialization properly reads $__unused
  into UnusedIdent instead of an Ident. This is particularly useful for
  downstream consumers of the CoreFn such as alternative backends that don't
  allow arguments to be omitted from functions.

• Fix type operators in declaration param kinds (#4220 by @rhendric)

  This fixes an internal error triggered by using a type operator in the
  kind of a type parameter of a data declaration, type synonym
  declaration, or class declaration.

• Scope type vars when type checking typed values (#4216 by @rhendric)

  When the compiler is checking an expression that is annotated with a
  type against another expected type, and the annotation introduces a type
  variable, the compiler needs to introduce that type variable to the
  scope of any types used inside the expression.

  One noteworthy case of this pattern is member signatures inside
  instances. This fix allows type variables introduced in member
  signatures to be used in the member declaration itself.

Internal:

• Bump PureScript to building with GHC-8.10.7, as well as from LTS-17 to LTS-18. (#4199 by @cdepillabout)

• Prevent hangs on internal errors (#4126 by @rhendric)

• The explicit disabling of Nix has been removed from stack.yaml. (#4198 by @cdepillabout)

  For developers on NixOS, this means that you should be able to build
  PureScript by running stack build instead of stack build --nix.
  For other developers, this shouldn't affect you.

• Build the entire latest package set in CI (#4217 by @rhendric)

  See #4128.

• Create test machinery for optimizations (#4205 by @PureFunctor)

  This adds machinery for testing code generation for optimizations.

  Partially extracted from #3915 to add tests for #4205.

0.14.6

Do not use this release. purescript-cst's version wasn't bumped when this release was made. So, tools like trypurescript cannot depend on it. See 0.14.7 for the same thing.

0.14.5

Bugfixes:

• Fix a case where kind inference inferred the wrong kind for type synonyms (#4184 by @jy14898)

• Properly rename module imports in case of conflicts with declarations (#4188 by @PureFunctor)

Internal:

• Fix command and clarify a few other requirements in release guide (#4177 by @JordanMartinez)

• Add Functor instance for Language.PureScript.CoreFn.Module. (#4186 by @cdepillabout)

Bugfixes:

• Solve Prim.Row.Union left right all constraint for left when all and right are already closed rows, (#3720 by @MonoidMusician)
  reflecting the existing functional dependency all right -> left

• Account for redundant parens when excluding uninteresting kind sigs from docs (#4137 by @JordanMartinez)

• Add a hint for errors in foreign data type declarations (#4161 by @kl0tl)

• Do not remove bindings referenced in function declarations when bundling (#4044 by @kl0tl)

• Improve row type error messages (#4159 by @rhendric)

  • Remove a redundant hint that repeats the types in the error
  • Correctly diff rows containing duplicate items
  • Erase kind applications from rows in errors (by default)

• Fix bad interaction between superclasses and type synonyms (#4164 by @rhendric)

  See #4101.

• Fix regression in row unification (#4168 by @rhendric)

• Fix backtick operator rule (#4172 by @JordanMartinez)

Other improvements:

• Add developer guide to readme (#3900 by @milesfrain)

Internal:

• Move unreleased changelog entries to CHANGELOG.d (#4132 by @rhendric)

  See CHANGELOG.d/README.md for details.

• Clarify in RELEASE_GUIDE what to do when broken releases are made (#4147 by @JordanMartinez)

• Miscellaneous updates/clarifications to the release guide (#4131 by @JordanMartinez)

• Run Weeder in CI and make it happy (#4148 by @rhendric)

• Add golden tests for self cycles in type class declarations, kind declarations and foreign data type declarations (#4162 by @kl0tl)

• Represent class dictionaries as newtypes (#4125 by @rhendric)

New features:

• Display kind signatures and their comments in documentation (#4100 and #4119 by JordanMartinez)

  The compiler now displays kind signatures for data, newtype, type
  synonym, and type class declarations in generated documentation. The
  compiler now also includes documentation-comments (i.e. those which start
  with a | character) both above and below the associated kind signature
  declaration (if any) in generated documentation, whereas previously
  documentation-comments above a kind signature declaration were ignored.

  Both explicitly declared and inferred kinds are included in documentation.
  The compiler omits including a kind signature in generated documentation
  only when the kind is considered "uninteresting". An uninteresting kind is
  defined as one where all of the declaration's type parameters have kind
  Type.

Bugfixes:

• Ensure unnamed instances appear in documentation (#4109 by @JordanMartinez)

• Allow fixity, kind, role declarations in REPL (#4046, @rhendric)

• Pin OS versions used in CI (#4107, @f-f)

• Fix UnusedName warnings for multiple non-recursive let bindings (#4114 by @nwolverson)

• Remove generated names from errors about instances (#4118 by @rhendric)

Internal:

• Fix for Haddock (#4072 by @ncaq and @JordanMartinez, #4139 by @JordanMartinez)

• Update RELEASE_GUIDE.md with more details (#4104 by @JordanMartinez)

• Use GenIdent for anonymous instances (#4096, @rhendric)

• Desugar type class instance names in type class desugaring pass (#4099 by @JordanMartinez)

New features:

• Make type class instance names optional (#4085, @JordanMartinez)

  Previously, one would be required to define a unique name for a type class
  instance. For example

  -- instance naming convention:
  -- classNameType1Type2Type3
  instance fooIntString :: Foo Int String
  

  Now, the name and :: separator characters are optional. The above instance
  could be rewritten like so:

  instance Foo Int String
  

  and the compiler will generate a unique name for the instance
  (e.g. $dollar_FooIntString_4 where 4 is a randomly-generated number
  that can change across compiler runs). This version of the instance name
  is not intended for use in FFI.

  Note: if one wrote

  instance ReallyLongClassName Int String
  

  the generated name would be something like
  $dollar_ReallyLongClassNameIntStr_87 rather than
  $dollar_ReallyLongClassNameIntString_87 as the generated part
  of the name will be truncated to 25 characters (long enough to be readable
  without being too verbose).

Bugfixes:

• Unused identifier warnings now report smaller and more relevant source spans (#4088, @nwolverson)

  Also fix incorrect warnings in cases involving a let-pattern binding shadowing
  an existing identifier.

Internal:

• Drop libtinfo dependency (#3696, @hdgarrood)

  Changes the build configuration so that by default, compiler binaries will
  not have a dynamic library dependency on libncurses/libtinfo. This should
  alleviate one of the most common pains in getting the compiler successfully
  installed, especially on Linux. The cost is a slight degradation in the REPL
  experience when editing long lines, but this can be avoided by building the
  compiler with the libtinfo dependency by setting the terminfo flag of the
  haskeline library to true.

• Migrate CI from Travis to GitHub Actions (#4077, @rhendric)

• Remove tasty from test suite and just use hspec (#4056, @hdgarrood)

• Avoid compiling tests with diagnostics twice in test suite (#4079, @hdgarrood)

• Do less work in test initialization (#4080, @rhendric)

• Follow more HLint suggestions (#4090, @rhendric)

• Export rebuildModule' to speed up Try PureScript! slightly (#4095 by @JordanMartinez)

• Merge purescript-ast into purescript-cst (#4094 by @JordanMartinez)

New features

• Support TCO for functions with tail-recursive inner functions (#3958, @rhendric)

  Adds support for optimizing functions that contain local functions which call
  the outer function in tail position, as long as those functions themselves
  are only called from tail position, either in the outer function or in other
  such functions.

  This enables hand-written mutually-tail-recursive function groups to be
  optimized, but more critically, it also means that case guards which desugar
  to use local functions don't break TCO.

• Add warnings for unused names and values (#3819, @nwolverson)

  The compiler now emits warnings when it encounters unused names in binders
  and unused value declarations. A declaration is considered to be unused if it
  is not exported and is also not reachable by any of the exported
  declarations. The compiler will not currently produce unused warnings about
  other kinds of declarations such as data and type class declarations, but we
  intend to produce warnings for these in the future as well.

Bug fixes

• Make close punctuation printable in errors (#3982, @rhendric)

• Desugar type operators in top-level kind signatures (#4027, @natefaubion)

• Use type annotation hint only when needed (#4025, @rhendric)

• Fix pretty printing of "hiding" imports (#4058, @natefaubion)

• Instantiate polymorphic kinds when unwrapping newtypes while solving Coercible constraints (#4040, @kl0tl)

• Fix row unification with shared unknown in tails (#4048, @rhendric)

• Fix kinded declaration reordering in desugaring (#4047, @rhendric)

• Fix wildly off kind unification positions (#4050, @natefaubion)

• Fix incorrect incremental builds with different --codegen options (#3911, #3914, @hdgarrood)

  This bug meant that after invoking the compiler with different --codegen
  options, it was easy to end up with (for example) an outdated docs.json or
  corefn.json file in your output directory which would be incorrectly
  considered up-to-date by the compiler.

Other improvements

• Add white outline stroke to logo in README (#4003, @ptrfrncsmrph)

  The previous logo.png was not legible against a dark background (#4001).

• Show the constraints that were being solved when encountering a type error (@nwolverson, #4004)

• Removed all shift/reduce conflicts in parser (#4063, @JordanMartinez).

  Happy defaults to using "shift" rather than "reduce" in shift/reduce
  conflicts. This change merely makes explicit what is already happening
  implicitly.

Internal

• Upgrade tests Bower dependencies (#4041, @kl0tl)
• Remove unused Data.Foldable.foldr import (#4042, @kl0tl)

Polykinds

Polymorphic kinds, based on the Kind Inference for Datatypes paper (#3779, #3831, #3929, #4007, @natefaubion, @kl0tl)

Just as types classify terms, kinds classify types. But while we have polymorphic types, kinds were previously monomorphic.

This meant that we were not able to abstract over kinds, leading for instance to a proliferation of proxy types:

data Proxy (a :: Type) = Proxy
data SProxy (a :: Symbol) = SProxy
data RProxy (row :: # Type) = RProxy
data RLProxy (row :: RowList) = RLProxy

Now we can have a single proxy type, whose parameter has a polymorphic kind.

Type :: Type

The old Kind data type and namespace is gone. Kinds and types are the same and exist in the same namespace.

Previously one could do:

foreign import kind Boolean
foreign import data True :: Boolean
foreign import data False :: Boolean

Where the kind Boolean and type Boolean were two different things. This is no longer the case. The Prim kind Boolean is now removed, and you can just use Prim type Boolean in the same way. This is a breaking change.

The compiler still supports the old foreign import kind syntax but it warns that it's deprecated.

foreign import kind Foo

Foreign kind imports are deprecated and will be removed in a future release. Use empty 'data' instead.

It is treated internally as:

data Foo

Note that foreign import data declarations are not deprecated. They are still necessary to define types with kinds other than Type since constructors are not lifted as in GHC with DataKinds.

Likewise, kind imports and exports are deprecated and treated the same as a type import or export.

Kind imports are deprecated and will be removed in a future release. Omit the 'kind' keyword instead.

The special unary # syntax for row kinds is still supported, but deprecated and will warn. There is now Prim.Row :: Type -> Type which can be used like a normal type constructor.

Unary '#' syntax for row kinds is deprecated and will be removed in a future release. Use the 'Row' kind instead.

All of these deprecations have suggested fixes in the JSON output, so tools like purescript-suggest (or your IDE plugin) can automatically apply them.

Kind Signatures

With PolyKinds, all type-level declarations are generalized.

data Proxy a = Proxy

Previously, this had the Type-defaulted kind Type -> Type. Now this will be generalized to forall k. k -> Type. Such signature can be written with a kind signature declarations, similar to standalone kind signatures in GHC.

data Proxy :: forall k. k -> Type
data Proxy a = Proxy

In GHC, all signatures use the type prefix, but we reuse the same keyword as the subsequent declaration because we already have foreign import data (rather than foreign import type) and because it makes things align nicer. Signatures have the same rule as value-level signatures, so they must always be followed by the "real" declaration.

It's better to be explicit about polymorphism by writing signatures. Since we don't really quantify over free type variables, it's also necessary in the case that two poly-kinded arguments must have the same kind. The compiler will warn about missing kind signatures when polymorphic kinds are inferred.

Classes can have signatures too, but they must end with the new Constraint kind instead of Type. For example, here's the new definition of Prim.Row.Cons:

class Cons :: forall k. Symbol -> k -> Row k -> Row k -> Constraint
class Cons label a tail row | label a tail -> row, label row -> a tail

Safe zero-cost coercions

Coercible constraints, based on the Safe Zero-cost Coercions for Haskell paper (#3351, #3810, #3896, #3873, #3860, #3905, #3893, #3909, #3931, #3906, #3881, #3878, #3937, #3930, #3955, #3927, #3999, #4000, @lunaris, @rhendric, @kl0tl, @hdgarrood)

Prim.Coerce.Coercible is a new compiler-solved class, used to relate types with the same runtime representation. One can use Safe.Coerce.coerce (from the new safe-coerce library) instead of Unsafe.Coerce.unsafeCoerce to safely turn a a into a b when Coercible a b holds.

Roles

Types parameters now have roles, which depend on how they affect the runtime representation of their type. There are three roles, from most to least restrictive:

• nominal parameters can only be coerced to themselves.

• representational parameters can only be coerced to each other when a Coercible constraint holds.

• phantom parameters can be coerced to anything.

Role annotations

The compiler infers nominal roles for foreign data types, which is safe but can be too constraining sometimes. For example this prevents the coercion of Effect Age to Effect Int, even though they have the same runtime representation.

The roles of foreign data types can thus be loosened with explicit role annotations, similar to the RoleAnnotations GHC extension.

Here's the annotation we added to Effect:

type role Effect representational

Conversely, we might want to strengthen the roles of parameters with invariants invisible to the type system. Maps are the canonical example of this: the shape of their underlying tree rely on the Ord instance of their keys, but the Ord instance of a newtype may behave differently than the one of the wrapped type so it would be unsafe to allow coercions between Map k1 a and Map k2 a, even when Coercible k1 k2 holds.

In order to forbid such unsafe coercion we added a nominal annotation to the first parameter of Map:

type role Map nominal representational

Annotated roles are compared against the roles inferred by the compiler so it is not possible to compromise safety by ascribing too permissive roles, except for foreign types.

Other changes

Breaking

• Add compiler support for Coercible based Newtype (#3975, @fsoikin)

We added a Coercible superclass to Data.Newtype.Newtype in order to implement unwrap, wrap and most newtype combinators with coerce (see https://github.com/purescript/purescript-newtype/pull/22). This is only a breaking change for non derived instances because the Newtype class has no members anymore and can now only be implemented for representationally equal types (those satisfying the new superclass constraint).

For example the instance for newtype Additive a = Additive a no longer implements unwrap and wrap:

+instance newtypeAdditive :: Newtype (Additive a) a
-instance newtypeAdditive :: Newtype (Additive a) a where
-  wrap = Additive
-  unwrap (Additive a) = a

Derived instances don't require any modifications.

• Reform handling of quote characters in raw strings (#3961, @rhendric)

Quotes behaved rather unexpectedly in various edge cases inside raw strings. This clears things up by enforcing the following specification:

'"""' '"'{0,2} ([^"]+ '"'{1,2})* [^"]* '"""'

Meaning that raw strings can contain up to two successive quotes, any number of times, but three successive quotes are not allowed inside.

• Unsupport bare negative literals as equational binders (#3956, @rhendric)

It used to be possible to match on negative literals, such as -1, but this prevented parsing matches on constructors aliased to -. The compiler will reject matches on bare negative literals, but they can still be matched by wrapping them in parentheses.

• Forbid partial data constructors exports (#3872, @kl0tl)

Exporting only some of the constructors of a type meant that changes internal to a module, such as adding or removing an unexported constructor, could cause unexhaustive pattern match errors in downstream code. Partial explicit export lists will have to be completed with the missing constructors or replaced by implicit export lists.

• Print compile errors to stdout, progress messages to stderr (#3839, @JordanMartinez)

Compiler errors and warnings arising from your code are now printed to stdout rather than stderr, and progress messages such as "Compiling Data.Array" are now printed to stderr rather than stdout. Warnings and errors arising from incorrect use of the CLI, such as specifying input files which don't exist or specifying globs which don't match any files, are still printed to stderr (as they were before). This change is useful when using the --json-errors flag, since you can now pipe JSON errors into other programs without having to perform awkward gymnastics such as 2>&1.

Fixes

• Only include direct dependencies in the output for purs graph instead of their transitive closure (#3993, @colinwahl)

• Fix the reversal of the qualifier of qualified operators (#3971, @rhendric)

Qualified operators, for instance Data.Array.(!), were interpreted with a reversed qualifier, like Array.Data.(!).

• Check all recursive paths in data binding groups (#3936, @natefaubion)

The compiler was not catching recursive type synonyms when some recursive paths were guarded by data types or newtypes.

• Desugar type operator aliases inside parens (#3935, @natefaubion)

The compiler did not accept type operators inside parens in prefix position, except (->).

• Pin language-javascript to a specific version (#3904, @hdgarrood)

Allowing the compiler to be built against various versions of language-javascript meant that multiple builds of the same version of the compiler could accept different syntaxes for JavaScript foreign modules, depending on how they were built.

Improvements

• Improves protocol errors from the IDE server (#3998, @kritzcreek)

The IDE server now respond with more descriptive error messages when failing to parse a command. This should make it easier to contribute fixes to the various clients.

• Extend IDE ImportCompletion with declarationType (#3997, @i-am-the-slime)

By exposing the declaration type (value, type, typeclass, etc.) downstream tooling can annotate imports with this info so users know what they are about to import. The info can also be mapped to a namespace filter to allow importing identifiers that appear more than once in a source file which throws an exception without such a filter.

• Improve error message when negate isn't imported (#3952, @mhmdanas)

This shows a specific message when using negative literals but Data.Ring.negate is out of scope, similar to the messages shown when using do notation if Control.Bind.bind and Control.Bind.discard are out of scope.

• Add source spans to PartiallyAppliedSynonym errors (#3951, @rhendric)

PartiallyAppliedSynonym errors were usually rethrown with the appropriate source span, but not when deriving instances. This annotates those errors with the source span of the partially applied synonyms themselves, which is more robust and accurate than rethrowing the error with an approximate source span.

• Allow type synonyms in instances heads and superclass constraints (#3539, #3966, #3965, @garyb, @kl0tl)

This allows declarations such as

type Env = { port :: Int }
newtype App a = App (ReaderT Env Aff a)
derive newtype instance monadAskApp :: MonadAsk Env App

or

class (Monad m, MonadAsk Env m) <= MonadAskEnv m

• Improve incremental rebuild times for modules with large dependencies (#3899, @milesfrain)

Other

• Warn against exported types with hidden constructors but Generic or Newtype instances (#3907, @kl0tl)

Types with hidden constructors are supposed to be opaque outside of their module of definition but Generic and Newtype instances allow to construct them with Data.Generic.Rep.to or Data.Newtype.wrap and examine their content with Data.Generic.Rep.from or Data.Newtype.unwrap, thus making void any invariant those types may witness.

• Have module re-exports appear in generated code (#3883, @citizengabe)

This is the first step towards smarter incremental rebuilds, which could skip rebuilding downstream modules when the interface of a module did not change (see #3724).

• Add a printer for CST modules (#3887, @kritzcreek)

• Deprecate constraints in foreign imports (#3829, @kl0tl)

Constrained foreign imports leak instance dictionaries, hindering the compiler ability to optimize their representation. Manipulating dictionaries in foreign code should be avoided and foreign imports should accept the class members they need as additional arguments instead of being constrained.

• Deprecate primes (the ' character) in identifiers exported from foreign modules (#3792, @kl0tl)

We are going to output ES modules instead of CommonJS in the next breaking release but named exports of ES modules, unlike CommonJS exports, have to be valid JavaScript identifiers and so cannot contain primes.

Docs

• Generate a changelog from the GitHub releases and add a pull request template (#3989, @JordanMartinez)

• Detail license related error messages and fix incorrect SPDX sample licenses (#3970, @fsoikin)

• Remove a spurious doc comment on the CoreFn Module type (#3552, @jmackie)

• Add a link to the releases page (#3920, @milesfrain)

• Update CONTRIBUTING.md (#3924, @hdgarrood)

• Add troubleshooting steps for libtinfo and EACCES errors (#3903, @milesfrain)

• Update an outdated link to the book (#3916, @sumew)

Internal

• Simplify the Ord instances of some AST types (#3902, @milesfrain)

• Update the desugaring pipeline to work on individual modules (#3944, @kl0tl)

• Remove the unmaintained and ignored core libraries tests (#3861, @kl0tl)

• Configure Travis to run hlint (#3816, #3864, @joneshf, @hdgarrood)

• Remove support for the legacy Bower resolutions format in purs publish (#3847, @kl0tl)

• Add GitHub issue templates for bugs and proposals (#3853, @joneshf)

• Add support for Happy >=1.19.10 (#3837, @arrowd)

• Use the same default extensions in all packages (#3823, #3908, @natefaubion, @i-am-the-slime)

• Relax purescript-ast dependency on microlens-platform to microlens (#3817, @joneshf)

• Extract the AST and CST types, and related functions, into their own purescript-ast and purescript-cst packages for ease of consumption by external tooling (#3793, #3821, #3826, @joneshf, @natefaubion)

• Fix various typos in documentation, comments and bindings names (#3795, @mhmdanas)

• Add golden tests for errors and warnings (#3774, #3811, #3808, #3846, @dariooddenino, @rhendric, @kl0tl)

• More descriptive protocol errors from the ide server (@kritzcreek)

Release candidate for use in preparing for the upcoming v0.14.0 release. Release notes coming soon.

Release candidate for use in preparing for the upcoming v0.14.0 release. Release notes coming soon.

Release candidate for use in preparing for the upcoming v0.14.0 release. Release notes coming soon.

Release candidate for use in preparing for the upcoming v0.14.0 release. Release notes coming soon.

Bug Fixes

• Update incremental build cache information properly on IDE rebuilds (#3789, @kritzcreek)

  Fixes a bug where triggering a rebuild via the IDE would not update the
  output/cache-db.json file, which in certain situations could lead to
  unnecessary rebuilds, as well as modules not being rebuilt when they should
  have been.

• Don't include compiler-internal declarations in IDE completions (#3850, @kritzcreek)

  IDE completions would previously include pseudo-declarations such as
  RowToList$Dict which only exist internally, due to how type class
  desugaring inside the compiler works. These declarations are now suppressed.

• Fix corefn JSON version parsing (#3877, @paulyoung)

  Fixes a bug where the parser for the functional core (or "corefn") JSON
  format would ignore all but the first component of the compiler version
  stored in the JSON. This does not affect the compiler directly, but will be
  useful for other tooling which depends on the corefn JSON parser provided by
  the compiler library.

Improvements

• Add purs graph subcommand for graphing module dependencies (#3781, @jmackie, @f-f)

  This adds a new graph subcommand which allows tools to consume information
  about which modules depend on which other modules. The format is as follows:

  { "Prelude":
      { "path": "src/Prelude.purs"
      , "depends": ["Data.Semiring", "Data.Ring", ...]
      },
    "Data.Ring":
      { "path": "src/Data/Ring.purs"
      , "depends": []
      },
    ...
  }
  

  Each property in the returned object has exactly two properties; path,
  which is a string containing the file path relative to the directory where
  the command was run, and depends, which is an array of the names of all
  directly imported modules.

• purs ide is better at reloading changes (#3799, @kritzcreek)

  The IDE would previously sometimes miss changes that were made outside of the
  editor, like building with new dependencies or recompiling larger parts of
  the project on the console.

  The IDE will now notice when this happened on the next command issued to it
  and refresh its state before processing that command. This might cause the
  first command after an external change to take a long time to execute, but
  should increase reliability in general.

• Switch to a binary encoding for externs files (#3841, @kritzcreek)

  This change should result in significant performance improvements in both IDE
  load times and incremental builds where lots of modules are already built.

• Represent module names as a single Text value internally (#3843, @kritzcreek)

  Boosts compiler performance by representing module names as a single Text
  value, rather than a list of Text values as it was previously.

• Extract documentation for type classes in purs ide (#3856, @kritzcreek)

  This changes makes documentation comments on type classes visible to the IDE.

Other

• Declare explicit upper bounds on Cabal and haskeline rather than relying on
  stack's pvp-bounds (#3777, @coot)

release withdrawn due to CI mishap