This is the place where the core teams that power the language and its ecosystem communicate about their progress, innovations,
+and new releases. These teams are:
The Haskell.org Committee is the publisher of this website. Please contact us at committee <at> haskell <dot> org if you wish to
+signal content that goes against our Guidelines For Respectful Communication.
+
+
+
+
diff --git a/atom.xml b/atom.xml
new file mode 100644
index 0000000..11a70cd
--- /dev/null
+++ b/atom.xml
@@ -0,0 +1,189 @@
+
+
+ The Haskell Programming Language's blog
+
+
+ Zola
+ 2024-12-23T00:00:00+00:00
+ https://blog.haskell.org/atom.xml
+
+ How to collect performance statistics with Cabal
+ 2024-12-23T00:00:00+00:00
+ 2024-12-23T00:00:00+00:00
+
+
+
+
+ Unknown
+
+
+
+
+
+ https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/
+
+ <p>The <a rel="noopener" target="_blank" href="https://cabal.readthedocs.io/en/latest/">Cabal Manual</a> now has a guide on how to collect performance statistics of Haskell applications.</p>
+
+
+
+
+ GHC 9.12 & Cabal 3.14 releases
+ 2024-12-22T00:00:00+00:00
+ 2024-12-22T00:00:00+00:00
+
+
+
+
+ Unknown
+
+
+
+
+
+ https://blog.haskell.org/ghc-9-12-cabal-3-14/
+
+ <p>To conclude the year 2024, the GHC and Cabal teams are happy to announce the releases of GHC 9.12 and cabal 3.14.</p>
+
+
+
+
+ Google Summer of Code 2024 Wrap-up
+ 2024-11-21T00:00:00+00:00
+ 2024-11-21T00:00:00+00:00
+
+
+
+
+ Unknown
+
+
+
+
+
+ https://blog.haskell.org/gsoc-2024/
+
+ <p>The Haskell.org committee is pleased to present the results of Haskell's
+participation in the Google Summer of Code 2024. This marks our 13th time
+taking part in GSoC!</p>
+
+
+
+
+ Haskell.org and the Haskell Foundation Join Forces
+ 2024-09-25T00:00:00+00:00
+ 2024-09-25T00:00:00+00:00
+
+
+
+
+ Unknown
+
+
+
+
+
+ https://blog.haskell.org/haskell-foundation-and-committee-merger/
+
+ <p>The members of the Haskell.org Committee (the Committee) and the directors of the Haskell Foundation (the Foundation) are pleased to announce that we have joined forces, with the aim (subject to regulatory approval) of merging Haskell.org, Inc. and Haskell Foundation, Inc. into a single not-for-profit corporation. Together we continue our common mission to advance functional programming and to advocate for the Haskell language, its ecosystem, and its community.</p>
+<h2 id="the-committee">The Committee</h2>
+<p>The Committee has a long history of supporting the Haskell community and ecosystem, supervising the resources under the "haskell.org" domain, including the www.haskell.org website, Hackage, Discourse, and the Haskell mailing lists, as well as organizing events such as Haskell.org’s participation in Google Summer of Code and the Haskell Summer of Code.</p>
+<h2 id="the-foundation">The Foundation</h2>
+<p>The Foundation is a newer organization, dedicated to broadening the adoption of Haskell by supporting its ecosystem of tools, libraries, education, and research. It has had similar goals to Haskell.org, and been engaged in complementary activities. Amongst its activities, it facilitates cross-team collaboration on fundamental tooling (e.g. Cabal, Stack, GHCup and the Haskell Language Server), hosts Stackage, financially supports the development of essential ecosystem components (e.g. the GHCup project and Botan bindings), runs workshops that help new contributors to fundamental tooling, and actively seeks financial sponsorship to help fund these efforts.</p>
+<p>Both corporations are Not-for-Profit corporations and Haskell.org Inc. has also been recognised as exempt from taxation in the USA. For that reason, most of the transactions of the Foundation are conducted by Haskell.org, Inc. One of the biggest factors in the desire to merge corporate entities is to make it easier to manage the legal and financial responsibilities around non-profit status and holding funds. Having only one corporation would also address a source of confusion for donors and sponsors.</p>
+<h2 id="what-next">What Next?</h2>
+<p>The Committee will continue to serve the community as an important committee of the Foundation. The Committee will retain all its current responsibilities, including independent editorial control of the Haskell.org website. It will also continue to oversee much of the Haskell community infrastructure and manage Haskell's participation in Google Summer of Code.</p>
+<p>Joining forces allows us to better share resources and work together while at the same time allowing the Committee (as part of the Foundation) to retain its independence over its domain.</p>
+<p>The Committee members and the directors of the Foundation remain deeply grateful for the opportunity to serve the Haskell community. We look forward to continuing this support with greater effectiveness and efficiency as a single unified organization.</p>
+<p>Sincerely,<br />
+The Haskell.org Committee and The Haskell Foundation</p>
+
+
+
+
+ Documentation Best Practices in 2024
+ 2024-09-15T00:00:00+00:00
+ 2024-09-15T00:00:00+00:00
+
+
+
+
+ Unknown
+
+
+
+
+
+ https://blog.haskell.org/documentation-best-practices-in-2024/
+
+ <p>In the Haddock team, part of our mission is to help with writing documentation, and promoting best practices. This article will help you write the best documentation you can!</p>
+
+
+
+
+ JavaScript Code Minification Report
+ 2024-09-15T00:00:00+00:00
+ 2024-09-15T00:00:00+00:00
+
+
+
+
+ Unknown
+
+
+
+
+
+ https://blog.haskell.org/report-of-js-code-minification/
+
+ <p>The JavaScript world has been battling for low bundle size from the very beginning.
+It is now our turn to enter the battle</p>
+
+
+
+
+ The Haskell Playground
+ 2024-09-15T00:00:00+00:00
+ 2024-09-15T00:00:00+00:00
+
+
+
+
+ Unknown
+
+
+
+
+
+ https://blog.haskell.org/the-haskell-playground/
+
+ <p>The playground (<a rel="noopener" target="_blank" href="https://play.haskell.org">play.haskell.org</a>) allows you to run single-file Haskell programs right from your browser, and share them with others.
+In this post, I will introduce the playground and give some implementation details.</p>
+
+
+
+
+ Welcome
+ 2024-09-14T00:00:00+00:00
+ 2024-09-14T00:00:00+00:00
+
+
+
+
+ Unknown
+
+
+
+
+
+ https://blog.haskell.org/intro/
+
+ <p>The Haskell Ecosystem plays host to some amazing projects. Talented developers spend significant amounts of time, often their free time, helping develop, maintain, and support this ecosystem that all Haskell developers use. This space is for all of the developer teams that work on Haskell core infrastructure and power the Haskell Ecosystem.</p>
+<p>This blog will provide a space for these efforts to communicate with the wider Haskell community. Things you might see here: calls for volunteers, project updates, requests for comments/feedback.</p>
+<p>Blogs also form a key part of an ecosystem’s documentation. We’d like to take this idea to its conclusion in the Haskell ecosystem and provide a place for this high-value documentation to live and be maintained. In addition to helping out with editing, by hosting the posts here we’ll also have shared responsibility for maintaining the blog posts, helping prevent the all-too-common bit-rot that occurs on blog posts.</p>
+<p>There are already a few posts to get the ball rolling. We’re really excited to share these thoughts with you all.</p>
+<p>Happy Hacking,</p>
+<p>José Manuel Calderón Trilla</p>
+
+
+
+
diff --git a/authors/aaron-allen/index.html b/authors/aaron-allen/index.html
new file mode 100644
index 0000000..fe8b658
--- /dev/null
+++ b/authors/aaron-allen/index.html
@@ -0,0 +1,91 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Aaron Allen | The Haskell Programming Language's blog
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/categories/community/atom.xml b/categories/community/atom.xml
new file mode 100644
index 0000000..71477cd
--- /dev/null
+++ b/categories/community/atom.xml
@@ -0,0 +1,34 @@
+
+
+ The Haskell Programming Language's blog - community
+
+
+ Zola
+ 2024-09-14T00:00:00+00:00
+ https://blog.haskell.org/categories/community/atom.xml
+
+ Welcome
+ 2024-09-14T00:00:00+00:00
+ 2024-09-14T00:00:00+00:00
+
+
+
+
+ Unknown
+
+
+
+
+
+ https://blog.haskell.org/intro/
+
+ <p>The Haskell Ecosystem plays host to some amazing projects. Talented developers spend significant amounts of time, often their free time, helping develop, maintain, and support this ecosystem that all Haskell developers use. This space is for all of the developer teams that work on Haskell core infrastructure and power the Haskell Ecosystem.</p>
+<p>This blog will provide a space for these efforts to communicate with the wider Haskell community. Things you might see here: calls for volunteers, project updates, requests for comments/feedback.</p>
+<p>Blogs also form a key part of an ecosystem’s documentation. We’d like to take this idea to its conclusion in the Haskell ecosystem and provide a place for this high-value documentation to live and be maintained. In addition to helping out with editing, by hosting the posts here we’ll also have shared responsibility for maintaining the blog posts, helping prevent the all-too-common bit-rot that occurs on blog posts.</p>
+<p>There are already a few posts to get the ball rolling. We’re really excited to share these thoughts with you all.</p>
+<p>Happy Hacking,</p>
+<p>José Manuel Calderón Trilla</p>
+
+
+
+
diff --git a/categories/community/index.html b/categories/community/index.html
new file mode 100644
index 0000000..e923fdb
--- /dev/null
+++ b/categories/community/index.html
@@ -0,0 +1,91 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ community category | The Haskell Programming Language's blog
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/categories/haskell-foundation/atom.xml b/categories/haskell-foundation/atom.xml
new file mode 100644
index 0000000..d3da3e9
--- /dev/null
+++ b/categories/haskell-foundation/atom.xml
@@ -0,0 +1,40 @@
+
+
+ The Haskell Programming Language's blog - Haskell Foundation
+
+
+ Zola
+ 2024-09-25T00:00:00+00:00
+ https://blog.haskell.org/categories/haskell-foundation/atom.xml
+
+ Haskell.org and the Haskell Foundation Join Forces
+ 2024-09-25T00:00:00+00:00
+ 2024-09-25T00:00:00+00:00
+
+
+
+
+ Unknown
+
+
+
+
+
+ https://blog.haskell.org/haskell-foundation-and-committee-merger/
+
+ <p>The members of the Haskell.org Committee (the Committee) and the directors of the Haskell Foundation (the Foundation) are pleased to announce that we have joined forces, with the aim (subject to regulatory approval) of merging Haskell.org, Inc. and Haskell Foundation, Inc. into a single not-for-profit corporation. Together we continue our common mission to advance functional programming and to advocate for the Haskell language, its ecosystem, and its community.</p>
+<h2 id="the-committee">The Committee</h2>
+<p>The Committee has a long history of supporting the Haskell community and ecosystem, supervising the resources under the "haskell.org" domain, including the www.haskell.org website, Hackage, Discourse, and the Haskell mailing lists, as well as organizing events such as Haskell.org’s participation in Google Summer of Code and the Haskell Summer of Code.</p>
+<h2 id="the-foundation">The Foundation</h2>
+<p>The Foundation is a newer organization, dedicated to broadening the adoption of Haskell by supporting its ecosystem of tools, libraries, education, and research. It has had similar goals to Haskell.org, and been engaged in complementary activities. Amongst its activities, it facilitates cross-team collaboration on fundamental tooling (e.g. Cabal, Stack, GHCup and the Haskell Language Server), hosts Stackage, financially supports the development of essential ecosystem components (e.g. the GHCup project and Botan bindings), runs workshops that help new contributors to fundamental tooling, and actively seeks financial sponsorship to help fund these efforts.</p>
+<p>Both corporations are Not-for-Profit corporations and Haskell.org Inc. has also been recognised as exempt from taxation in the USA. For that reason, most of the transactions of the Foundation are conducted by Haskell.org, Inc. One of the biggest factors in the desire to merge corporate entities is to make it easier to manage the legal and financial responsibilities around non-profit status and holding funds. Having only one corporation would also address a source of confusion for donors and sponsors.</p>
+<h2 id="what-next">What Next?</h2>
+<p>The Committee will continue to serve the community as an important committee of the Foundation. The Committee will retain all its current responsibilities, including independent editorial control of the Haskell.org website. It will also continue to oversee much of the Haskell community infrastructure and manage Haskell's participation in Google Summer of Code.</p>
+<p>Joining forces allows us to better share resources and work together while at the same time allowing the Committee (as part of the Foundation) to retain its independence over its domain.</p>
+<p>The Committee members and the directors of the Foundation remain deeply grateful for the opportunity to serve the Haskell community. We look forward to continuing this support with greater effectiveness and efficiency as a single unified organization.</p>
+<p>Sincerely,<br />
+The Haskell.org Committee and The Haskell Foundation</p>
+
+
+
+
diff --git a/categories/haskell-foundation/index.html b/categories/haskell-foundation/index.html
new file mode 100644
index 0000000..f02612c
--- /dev/null
+++ b/categories/haskell-foundation/index.html
@@ -0,0 +1,91 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Haskell Foundation category | The Haskell Programming Language's blog
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
In the Haddock team, part of our mission is to help with writing documentation, and promoting best practices. This article will help you write the best documentation you can!
+
+
We adapt documentation outside practices to our ecosystem, and leverage our own technologies to empower Haskell users with their documentation work.
+
Let us see some of these techniques, and how the Haddock team can be of help.
+
Writing documentation for your software project
+
Justify yourself
+
When you create software, there is a pipeline from your brain straight to your code. Your decisions — such as the libraries you’ve used,
+or your program architecture — shape how your code is structured and written.
+
Unfortunately, simply writing the code isn’t enough.The reasoning behind the decisions you made is as important as the decisions themselves. In the short term, solving a problem may let you move ahead immediately, but what keeps you on the correct path is understanding what
+brought you to that solution.
+
Indeed, your choices may not be as popular as you think they are! Of course, you decided on them because you already convinced yourself
+that they’re best. But you have a user base to convince as well, and they may not see things the same way you do.
+
As such, it is vitally important to document which decisions you made and to justify why you made them. If it’s not immediately obvious
+why a behaviour or a pattern exists, future maintainers might be tempted to drop it — only to discover too late why it was needed.
+
The reference flow of documentation
+
Not all types of documentation have the same life cycle. Different pieces of documentation are more or less stable, and this determines
+which can act as a conceptual and theoretical foundation for your project.
+
Stable documentation
+
+
A README without code
+
A vision statement
+
The value proposition and the core domain
+
+
These ought not to change much, because they describe the basic problems that your code aims to address, solve or support in the long run.
+While it is normal to fiddle around with the boundaries of your project at the beginning, in general these should change infrequently.
+
Volatile documentation
+
+
Documentation generated at runtime
+
Code examples
+
Tests
+
Configuration
+
+
These are expected to change frequently, as your project changes, your API evolves, and you change configuration options.
+Volatile documentation is expensive to maintain, but also very valuable, as it shows in a concrete way how the user can interact with
+your project.
+
+
“When you refer to something, make sure the direction of the reference is from the more volatile to the more stable elements”
+
-- Cyrille Martraire, Living Documentation, 2019
+
+
Documentation cascade
+
Here is a simplified model of the documentation cascade for a typical Haskell project, from the most volatile to the most stable
+sources:
+
+Code for this diagram
+
flowchart TD
+ A[Docs of your project]
+ B[Architecture document]
+ C[Official specs for your domain]
+ D["Docs of a core library (base, text, containers, etc)"]
+ E[GHC Manual]
+ F[Official specs for what the core libraries provide]
+ G[Papers]
+
+ A --> B
+ A --> D
+ A --> C
+
+ D --> E
+ D --> F
+ D --> G
+
+
+
This can be read as:
+
+
The Haddocks of your library or a third-party library have a dependency on the official specs for the domain, on an architecture document,
+and on haddocks from the core libraries (base, text, containers, etc.).
+The haddocks of these core libraries depend on the GHC manual, official specs for their own domain, and papers.
+
+
Keep in mind that while the Haddocks of a project can refer to the project specs, or to an architecture document, these documents should
+never refer to the project's current implementation. If you must refer to the code, point to where it's located.
+The (current, volatile) code cannot be the justification for the (planned, stable) architecture.
+
The GHC manual is much more stable than the haddocks of a Core library, which is why documentation should flow from
+the library to the manual.
+
Finally, papers serve the same purpose as architecture documents, where they describe techniques that may be implemented,
+but they should not point to code that is subject to change – lest they point to a library that has evolved so much
+that it no longer relates to the paper.
+
Example: The Set data structure
+
The Haddocks for the Set datatype
+(from the containers library) are an example of documentation which follows this model well:
+
+
They point to an overview of the API (here: volatile)
+
They refer to the papers that have informed the design of its implementation (stable)
+
+
Understand for whom you write
+
+
+
-- Diátaxis Framework, by Daniele Procida, diataxis.fr
+
+
It is of utmost importance that documentation answers the needs of the users, and for that we must understand these needs.
+Users need specific kinds of documentation depending on the situation they are in.
+
The above quadrant is the Diátaxis Framework, which maps out the entire life cycle of one’s interaction with a system, a program or a library.
+It defines four types of documentation where each are a combination of Acquisition or Application, and Action or Cognition.
+
Tutorials
+
If a new user in need of actively acquiring some practice with the project, they can safely be pointed to the "Tutorials" part
+of your documentation: it is the part that focuses on "Acquisition" of knowledge through "Action".
+The focus of the tutorial is to make a prospective user acquire basic competence in handling the software: It is an ice-breaker.
+
How-to Guides
+
Someone who needs to perform a task that new to them, but well-known to their group or organisation, will be best served by "How-to Guides",
+which helps a user get something done in a safe and correct manner. As opposed to Tutorials, How-to Guides are directions that take into account the complexity of the environment
+surrounding the the user and the action, instead of providing a single path from point A to point B.
+
Explanations
+
However someone who is in need of a deeper – but perhaps less immediately applicable understanding of the project –
+will be better served by the "Explanation", which serves the need for thought (or Cognition)
+
Explanations bring historical and technical context to the current state of affairs.
+
Reference
+
Finally, a "Reference" is a description of the interfaces and mechanisms of the software.
+It aims to provide factual informations that is authoritative, with no space for doubt or ambiguity or design questions.
+The best way to obtain reference is to make the system aware of its inner workings, and have it spit the reference from its own code.
+
Through the lens of Diátaxis, the module API documentation produced by Haddock is a Reference.
+
The OpenAPI standard for documenting REST APIs is also a Reference, although some less fortunate systems find themselves
+with no ability to understand their own mechanisms, and thus must rely on manually-written specifications.
+In Haskell, packages like openapi3 help with rendering an OpenAPI specification,
+whereas companion libraries for web servers like servant-openapi3
+provide you with a way of declaring REST APIs that can be rendered, even at run-time.
+
Do Not Write The One Documentation
+
It is not just about filling out all the quadrants like a checklist (although they are all good to have!).
+Instead, it is about understanding how each section focuses on a particular combination of user needs and situations.
+
The message of Diátaxis is that you are not meant to write The One Documentation that covers everything —
+inevitably, this produces documentation which is shallow due to its breadth. Instead, focus on the strategic aspects of your documentation,
+and you will produce documentation of better quality, with a clear purpose that it can fulfill more easily.
+
Reach Out
+
Should you need any help in writing or proof-reading documentation, please stop by the Matrix chatroom of the Haddock team,
+or ping us with the @haddock group tag on the
+Haskell Gitlab. We would be more than happy to lend you a hand and discuss how to best serve your users,
+you included.
To conclude the year 2024, the GHC and Cabal teams are happy to announce the releases of GHC 9.12 and cabal 3.14.
+
+
Here are some highlights:
+
GHC 9.12
+
Language Extensions
+
This release brings many new and exciting extensions:
+
+
Multiline string literals to write string literals with newlines kept verbatim,
+enabling multiline strings without the need for string gaps and literal \n characters";
+
Or-Patterns, allowing you to match on several patterns in a single case branch:
NamedDefaults allows you to create type defaulting declarations for literals other than for the Num class. This mechanism is used to make sure that in the expression print (6 + 7), the multiplication gets a concrete type like Integer, Int or Double, instead of the vague Num a => a.
+You can now apply this mechanism to other typeclasses, like:
+
+
defaultIsString (Text,String)
+
+
Which means that in a module with OverloadedStrings, string literals "like this" will default to Text
+instead of triggering an error about a polymorphic type.
+
Base Library
+
+
Improvements to backtraces and exceptions. Lots of them.
+
+
⚠️ Deprecations
+
+
The deprecation cycle of GHC.Pack has reached its conclusion and the module has been removed.
SIMD! In the x86: Most floating-point operations and some integer vector operations are supported 128-bit vectors without LLVM. Get in touch to help with this effort
+
You can try the new experimental -fobject-determinism flag to enable deterministic object code generation.
+
+
⚠️ Deprecations
+
+
Support 32-bit Windows & macOS/iOS has been dropped;
+
As a result, the stdcall calling convention for FFI has been dropped, ccall should be used instead.
(Spec v3.14 only) New field: extra-files allows you to bundle files in the source distribution (sdist) of your cabal package. It serves as an alternative when the files you want to bundle do not fit in the existing data-files (for runtime data), extra-source-files (built by cabal) or extra-doc-files (shipped with Haddocks). This field has no inherent meaning, to avoid misuse of the already existing fields. For instance, you can use extra-files to ship stack.yaml files, which are not used either by the program at run-time, nor by Cabal or Haddock.
+
+
+
You can now compile projects dynamically with profiling enabled. The following options are now available:
+
+
cabal.project: profiling-shared: <Boolean>;
+
cabal file: ghc-prof-shared-options for passing options when building in profiling dynamic way;
New build type: Hooks. This build type, intended to eventually replace the Custom build type, integrates better with the rest of the ecosystem (cabal-install, Haskell Language Server).
+
+
+
The experimental haddock-project command supports sub-components.
+
+
+
Changed
+
+
+
cabal init remembers the chosen language within current session (Haskell2010, GHC2021, etc.).
+
+
+
cabal check will raise an error about the insecure git:// protocol in source-repository.
+
+
+
Enable recompilation avoidance during Haddock generation.
+
+
+
Clarify error message when pkg-config is not found.
+
+
+
Print out which project file(s) we are using.
+
+
+
Fixed
+
+
+
The --promised-dependency flag now accepts the version of a package in the package name. Previously you could only call it with an argument like void=void-0.5.8.
+Now, it is possible to write: --promised-dependency=void-0.5.8=void-0.5.8.
+
+
+
Always pass ghc-options to GHC.
+
+
+
Enhance error detection for cabal root project files, including broken symlinks.
+
+
+
Don't pass --coverage-for for non-dependency libs of a testsuite.
+
+
+
Fix a bug that causes cabal init to crash if git is not installed.
+
+
+
Unresolved
+
+
Recompilation avoidance during Haddock generation sometimes does not work on Windows (haskell/cabal#9177).
As always, the Cabal team is always welcoming of new contributors. We have a nice back catalogue of bugs, oddities and feature requests. Stop by our matrix channel!
The Haskell.org committee is pleased to present the results of Haskell's
+participation in the Google Summer of Code 2024. This marks our 13th time
+taking part in GSoC!
Congratulations to all the contributors and a huge thank you to our wonderful mentors!
+
+
+
+
+
HLS Cabal Plugin Continuation
+
Contributor: Georgii Gerasev
+Mentor: Fendor
+
For this project Georgii implemented a number of additions and fixes for the
+HLS Cabal plugin, improving the developer experience around working with cabal
+files.
Abhinav's project was aimed at assisting developers in analyzing large CI test
+logs, particularly for rare intermittent failures, by creating a web-based
+tool. This tool extends an existing service (Spuriobot) to collect CI log data
+and store it in a full-text search database. It also includes the
+development of an improved web UI, offering advanced search capabilities and
+automatic log integration from GitHub workflows.
Karim contributed an enhancement to the Happy parser generater, namely an
+error recovery mechanism. GHC's parser was then extended to make use of this
+new feature. This will allow GHC to report multiple parse errors from a single
+compilation run and in turn improve how parse errors are presented in tooling
+such as HLS.
The members of the Haskell.org Committee (the Committee) and the directors of the Haskell Foundation (the Foundation) are pleased to announce that we have joined forces, with the aim (subject to regulatory approval) of merging Haskell.org, Inc. and Haskell Foundation, Inc. into a single not-for-profit corporation. Together we continue our common mission to advance functional programming and to advocate for the Haskell language, its ecosystem, and its community.
+
The Committee
+
The Committee has a long history of supporting the Haskell community and ecosystem, supervising the resources under the "haskell.org" domain, including the www.haskell.org website, Hackage, Discourse, and the Haskell mailing lists, as well as organizing events such as Haskell.org’s participation in Google Summer of Code and the Haskell Summer of Code.
+
The Foundation
+
The Foundation is a newer organization, dedicated to broadening the adoption of Haskell by supporting its ecosystem of tools, libraries, education, and research. It has had similar goals to Haskell.org, and been engaged in complementary activities. Amongst its activities, it facilitates cross-team collaboration on fundamental tooling (e.g. Cabal, Stack, GHCup and the Haskell Language Server), hosts Stackage, financially supports the development of essential ecosystem components (e.g. the GHCup project and Botan bindings), runs workshops that help new contributors to fundamental tooling, and actively seeks financial sponsorship to help fund these efforts.
+
Both corporations are Not-for-Profit corporations and Haskell.org Inc. has also been recognised as exempt from taxation in the USA. For that reason, most of the transactions of the Foundation are conducted by Haskell.org, Inc. One of the biggest factors in the desire to merge corporate entities is to make it easier to manage the legal and financial responsibilities around non-profit status and holding funds. Having only one corporation would also address a source of confusion for donors and sponsors.
+
What Next?
+
The Committee will continue to serve the community as an important committee of the Foundation. The Committee will retain all its current responsibilities, including independent editorial control of the Haskell.org website. It will also continue to oversee much of the Haskell community infrastructure and manage Haskell's participation in Google Summer of Code.
+
Joining forces allows us to better share resources and work together while at the same time allowing the Committee (as part of the Foundation) to retain its independence over its domain.
+
The Committee members and the directors of the Foundation remain deeply grateful for the opportunity to serve the Haskell community. We look forward to continuing this support with greater effectiveness and efficiency as a single unified organization.
+
Sincerely,
+The Haskell.org Committee and The Haskell Foundation
The Cabal Manual now has a guide on how to collect performance statistics of Haskell applications.
+
+
This guide was very generously contributed by Malte Neuss. It describes the various options you can set in your cabal.project file in order to get a time or space profile of your application.
+
Project Configuration Guide
+
It is the recommended entry point for newcomers into the world of Haskell performance analysis.
+As you progress through it, you will be pointed to other resources like the Profiling section of the GHC Users Guide
+and the Haskell Optimization Handbook, which present you with more in-depth techniques and configuration options.
+
Moreover, you will be shown how to produce time and space profiles that can be rendered and analysed with third-party tools like Speedscope.
The manual follows the documentation best practices of the Haddock team,
+and the Cabal team is eager to receive more contributions to improve the life of our users.
+Do not hesitate to open a pull request at https://github.com/haskell/cabal.
+
Cheers!
+
+
+
+
+
+
+
diff --git a/how-to-collect-performance-statistics-with-cabal/speedscope.png b/how-to-collect-performance-statistics-with-cabal/speedscope.png
new file mode 100644
index 0000000..7f8964e
Binary files /dev/null and b/how-to-collect-performance-statistics-with-cabal/speedscope.png differ
diff --git a/images/haskell-opengraph.png b/images/haskell-opengraph.png
new file mode 100644
index 0000000..29b4a75
Binary files /dev/null and b/images/haskell-opengraph.png differ
diff --git a/images/haskell.svg b/images/haskell.svg
new file mode 100644
index 0000000..d7b1862
--- /dev/null
+++ b/images/haskell.svg
@@ -0,0 +1,6 @@
+
+
\ No newline at end of file
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..3ed2e43
--- /dev/null
+++ b/index.html
@@ -0,0 +1,225 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The Haskell Programming Language's blog | Fast & Lightweight Zola Theme
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The Haskell.org committee is pleased to present the results of Haskell's
+participation in the Google Summer of Code 2024. This marks our 13th time
+taking part in GSoC!
+
+ ...more
+
+
+ The members of the Haskell.org Committee (the Committee) and the directors of the Haskell Foundation (the Foundation) are pleased to announce that we …
+
+ ...more
+
+
+ In the Haddock team, part of our mission is to help with writing documentation, and promoting best practices. This article will help you write the best documentation you can!
+
+ ...more
+
+
+ The playground (play.haskell.org) allows you to run single-file Haskell programs right from your browser, and share them with others.
+In this post, I will introduce the playground and give some implementation details.
+
+ ...more
+
+
+ The Haskell Ecosystem plays host to some amazing projects. Talented developers spend significant amounts of time, often their free time, helping devel…
+
+ ...more
+
+
The Haskell Ecosystem plays host to some amazing projects. Talented developers spend significant amounts of time, often their free time, helping develop, maintain, and support this ecosystem that all Haskell developers use. This space is for all of the developer teams that work on Haskell core infrastructure and power the Haskell Ecosystem.
+
This blog will provide a space for these efforts to communicate with the wider Haskell community. Things you might see here: calls for volunteers, project updates, requests for comments/feedback.
+
Blogs also form a key part of an ecosystem’s documentation. We’d like to take this idea to its conclusion in the Haskell ecosystem and provide a place for this high-value documentation to live and be maintained. In addition to helping out with editing, by hosting the posts here we’ll also have shared responsibility for maintaining the blog posts, helping prevent the all-too-common bit-rot that occurs on blog posts.
+
There are already a few posts to get the ball rolling. We’re really excited to share these thoughts with you all.
+
Happy Hacking,
+
José Manuel Calderón Trilla
+
+
+
+
+
+
+
diff --git a/js/abridge.min.js b/js/abridge.min.js
new file mode 100644
index 0000000..b3d44fe
--- /dev/null
+++ b/js/abridge.min.js
@@ -0,0 +1 @@
+let items=document.querySelectorAll(".preStyle"),changeIcon=(items.forEach(e=>{e.rel="stylesheet"}),(()=>{for(var e=document.getElementsByClassName("m-protected"),t=0;t{e.classList.add(t),setTimeout(()=>e.classList.remove(t),2500)}),copyCodeAndChangeIcon=async(t,e)=>{e=(e.querySelector("table")?getTableCode:getNonTableCode)(e);try{await navigator.clipboard.writeText(e),changeIcon(t,"yes")}catch(e){changeIcon(t,"err")}},getNonTableCode=e=>[...e.querySelectorAll("code")].map(e=>e.textContent).join(""),getTableCode=e=>[...e.querySelectorAll("tr")].map(e=>e.querySelector("td:last-child")?.innerText??"").join("");document.querySelectorAll("pre").forEach(e=>{let t=document.createElement("div");t.className="cc svgs svgh copy",t.innerHTML=" ",e.prepend(t),t.addEventListener("click",()=>copyCodeAndChangeIcon(t,e))}),function(){function g(e){var t=new g.Index;return t.pipeline.add(g.trimmer,g.stopWordFilter,g.stemmer),e&&e.call(t,t),t}var a,c,e,t,d,h,f,p,m,v,y,S,x,b,w,I,E,C,D,F,k,_,N,L,n;g.version="0.9.5",((lunr=g).utils={}).warn=(n=this,function(e){n.console}),g.utils.toString=function(e){return null==e?"":e.toString()},(g.EventEmitter=function(){this.events={}}).prototype.addListener=function(){var e=[].slice.call(arguments),t=e.pop();if("function"!=typeof t)throw new TypeError("last argument must be a function");e.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},g.EventEmitter.prototype.removeListener=function(e,t){this.hasHandler(e)&&-1!=(t=this.events[e].indexOf(t))&&(this.events[e].splice(t,1),0==this.events[e].length)&&delete this.events[e]},g.EventEmitter.prototype.emit=function(e){var t;this.hasHandler(e)&&(t=[].slice.call(arguments,1),this.events[e].forEach(function(e){e.apply(void 0,t)},this))},g.EventEmitter.prototype.hasHandler=function(e){return e in this.events},(g.tokenizer=function(e){var t,n;return arguments.length&&null!=e?Array.isArray(e)?(t=(t=e.filter(function(e){return null!=e})).map(function(e){return g.utils.toString(e).toLowerCase()}),n=[],t.forEach(function(e){e=e.split(g.tokenizer.seperator);n=n.concat(e)},this),n):e.toString().trim().toLowerCase().split(g.tokenizer.seperator):[]}).defaultSeperator=/[\s\-]+/,g.tokenizer.seperator=g.tokenizer.defaultSeperator,g.tokenizer.setSeperator=function(e){null!=e&&"object"==typeof e&&(g.tokenizer.seperator=e)},g.tokenizer.resetSeperator=function(){g.tokenizer.seperator=g.tokenizer.defaultSeperator},g.tokenizer.getSeperator=function(){return g.tokenizer.seperator},(g.Pipeline=function(){this._queue=[]}).registeredFunctions={},g.Pipeline.registerFunction=function(e,t){t in g.Pipeline.registeredFunctions&&g.utils.warn("Overwriting existing registered function: "+t),e.label=t,g.Pipeline.registeredFunctions[t]=e},g.Pipeline.getRegisteredFunction=function(e){return e in g.Pipeline.registeredFunctions!=1?null:g.Pipeline.registeredFunctions[e]},g.Pipeline.warnIfFunctionNotRegistered=function(e){e.label&&e.label in this.registeredFunctions||g.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},g.Pipeline.load=function(e){var n=new g.Pipeline;return e.forEach(function(e){var t=g.Pipeline.getRegisteredFunction(e);if(!t)throw Error("Cannot load un-registered function: "+e);n.add(t)}),n},g.Pipeline.prototype.add=function(){[].slice.call(arguments).forEach(function(e){g.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},g.Pipeline.prototype.after=function(e,t){g.Pipeline.warnIfFunctionNotRegistered(t);e=this._queue.indexOf(e);if(-1==e)throw Error("Cannot find existingFn");this._queue.splice(1+e,0,t)},g.Pipeline.prototype.before=function(e,t){g.Pipeline.warnIfFunctionNotRegistered(t);e=this._queue.indexOf(e);if(-1==e)throw Error("Cannot find existingFn");this._queue.splice(e,0,t)},g.Pipeline.prototype.remove=function(e){e=this._queue.indexOf(e);-1!=e&&this._queue.splice(e,1)},g.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,o=this._queue.length,i=0;i{if(null===e||"object"!=typeof e)return e;var t,n=e.constructor();for(t in e)e.hasOwnProperty(t)&&(n[t]=e[t]);return n})(t):null},g.DocumentStore.prototype.getDoc=function(e){return!1===this.hasDoc(e)?null:this.docs[e]},g.DocumentStore.prototype.hasDoc=function(e){return e in this.docs},g.DocumentStore.prototype.removeDoc=function(e){this.hasDoc(e)&&(delete this.docs[e],delete this.docInfo[e],this.length--)},g.DocumentStore.prototype.addFieldLength=function(e,t,n){null!=e&&0!=this.hasDoc(e)&&(this.docInfo[e]||(this.docInfo[e]={}),this.docInfo[e][t]=n)},g.DocumentStore.prototype.updateFieldLength=function(e,t,n){null!=e&&0!=this.hasDoc(e)&&this.addFieldLength(e,t,n)},g.DocumentStore.prototype.getFieldLength=function(e,t){return null!=e&&e in this.docs&&t in this.docInfo[e]?this.docInfo[e][t]:0},g.DocumentStore.prototype.toJSON=function(){return{docs:this.docs,docInfo:this.docInfo,length:this.length,save:this._save}},a={ational:"ate",tional:"tion",enci:"ence",anci:"ance",izer:"ize",bli:"ble",alli:"al",entli:"ent",eli:"e",ousli:"ous",ization:"ize",ation:"ate",ator:"ate",alism:"al",iveness:"ive",fulness:"ful",ousness:"ous",aliti:"al",iviti:"ive",biliti:"ble",logi:"log"},c={icate:"ic",ative:"",alize:"al",iciti:"ic",ical:"ic",ful:"",ness:""},d=/^([^aeiou][^aeiouy]*)?[aeiouy][aeiou]*[^aeiou][^aeiouy]*/,h=/^([^aeiou][^aeiouy]*)?[aeiouy][aeiou]*[^aeiou][^aeiouy]*[aeiouy][aeiou]*[^aeiou][^aeiouy]*/,f=/^([^aeiou][^aeiouy]*)?[aeiouy][aeiou]*[^aeiou][^aeiouy]*([aeiouy][aeiou]*)?$/,p=/^([^aeiou][^aeiouy]*)?[aeiouy]/,m=/^(.+?)(ss|i)es$/,v=/^(.+?)([^s])s$/,y=/^(.+?)eed$/,S=/^(.+?)(ed|ing)$/,x=/.$/,b=/(at|bl|iz)$/,w=/([^aeiouylsz])\1$/,I=RegExp("^"+(t="[^aeiou][^aeiouy]*")+(e="[aeiouy]")+"[^aeiouwxy]$"),E=/^(.+?[^aeiou])y$/,C=/^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/,D=/^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/,F=/^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/,k=/^(.+?)(s|t)(ion)$/,_=/^(.+?)e$/,N=/ll$/,L=RegExp("^"+t+e+"[^aeiouwxy]$"),g.Pipeline.registerFunction(g.stemmer=function(e){var t,n,o,i,r,s,u,l;return e.length<3||("y"==(n=e.substr(0,1))&&(e=n.toUpperCase()+e.substr(1)),u=v,(r=m).test(e)?e=e.replace(r,"$1$2"):u.test(e)&&(e=e.replace(u,"$1$2")),u=S,(r=y).test(e)?(l=r.exec(e),(r=d).test(l[1])&&(e=e.replace(r=x,""))):u.test(e)&&(s=(l=u.exec(e))[1],(u=p).test(s))&&(e=s,o=w,i=I,(u=b).test(e)?e+="e":o.test(e)?e=e.replace(r=x,""):i.test(e)&&(e+="e")),(r=E).test(e)&&(e=(s=(l=r.exec(e))[1])+"i"),(r=C).test(e)&&(s=(l=r.exec(e))[1],t=l[2],(r=d).test(s))&&(e=s+a[t]),(r=D).test(e)&&(s=(l=r.exec(e))[1],t=l[2],(r=d).test(s))&&(e=s+c[t]),u=k,(r=F).test(e)?(s=(l=r.exec(e))[1],(r=h).test(s)&&(e=s)):u.test(e)&&(s=(l=u.exec(e))[1]+l[2],(u=h).test(s))&&(e=s),(r=_).test(e)&&(s=(l=r.exec(e))[1],u=f,o=L,(r=h).test(s)||u.test(s)&&!o.test(s))&&(e=s),u=h,(r=N).test(e)&&u.test(e)&&(e=e.replace(r=x,"")),"y"==n&&(e=n.toLowerCase()+e.substr(1))),e},"stemmer"),g.stopWordFilter=function(e){return e&&!0!==g.stopWordFilter.stopWords[e]?e:void 0},g.clearStopWords=function(){g.stopWordFilter.stopWords={}},g.addStopWords=function(e){null!=e&&!1!==Array.isArray(e)&&e.forEach(function(e){g.stopWordFilter.stopWords[e]=!0},this)},g.resetStopWords=function(){g.stopWordFilter.stopWords=g.defaultStopWords},g.stopWordFilter.stopWords=g.defaultStopWords={"":!0,a:!0,able:!0,about:!0,across:!0,after:!0,all:!0,almost:!0,also:!0,am:!0,among:!0,an:!0,and:!0,any:!0,are:!0,as:!0,at:!0,be:!0,because:!0,been:!0,but:!0,by:!0,can:!0,cannot:!0,could:!0,dear:!0,did:!0,do:!0,does:!0,either:!0,else:!0,ever:!0,every:!0,for:!0,from:!0,get:!0,got:!0,had:!0,has:!0,have:!0,he:!0,her:!0,hers:!0,him:!0,his:!0,how:!0,however:!0,i:!0,if:!0,in:!0,into:!0,is:!0,it:!0,its:!0,just:!0,least:!0,let:!0,like:!0,likely:!0,may:!0,me:!0,might:!0,most:!0,must:!0,my:!0,neither:!0,no:!0,nor:!0,not:!0,of:!0,off:!0,often:!0,on:!0,only:!0,or:!0,other:!0,our:!0,own:!0,rather:!0,said:!0,say:!0,says:!0,she:!0,should:!0,since:!0,so:!0,some:!0,than:!0,that:!0,the:!0,their:!0,them:!0,then:!0,there:!0,these:!0,they:!0,this:!0,tis:!0,to:!0,too:!0,twas:!0,us:!0,wants:!0,was:!0,we:!0,were:!0,what:!0,when:!0,where:!0,which:!0,while:!0,who:!0,whom:!0,why:!0,will:!0,with:!0,would:!0,yet:!0,you:!0,your:!0},g.Pipeline.registerFunction(g.stopWordFilter,"stopWordFilter"),g.Pipeline.registerFunction(g.trimmer=function(e){if(null==e)throw Error("token should not be undefined");return e.replace(/^\W+/,"").replace(/\W+$/,"")},"trimmer"),(g.InvertedIndex=function(){this.root={docs:{},df:0}}).load=function(e){var t=new this;return t.root=e.root,t},g.InvertedIndex.prototype.addToken=function(e,t,n){for(var n=n||this.root,o=0;o<=e.length-1;){var i=e[o];i in n||(n[i]={docs:{},df:0}),o+=1,n=n[i]}var r=t.ref;n.docs[r]?n.docs[r]={tf:t.tf}:(n.docs[r]={tf:t.tf},n.df+=1)},g.InvertedIndex.prototype.hasToken=function(e){if(!e)return!1;for(var t=this.root,n=0;n=n&&r-1>=o;)s[n]!==u[o]?s[n]u[o]&&o++:(t.add(s[n]),n++,o++);return t},lunr.SortedSet.prototype.clone=function(){var e=new lunr.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},lunr.SortedSet.prototype.union=function(e){for(var t,e=this.length
");return o.innerHTML=i,n.insertBefore(o,n.firstChild),e.innerHTML=n.outerHTML,t.innerHTML="",document.getElementById("searchinput").value="",document.body.contains(document.closeSearch)&&(document.closeSearch.onsubmit=function(){document.querySelector("main").innerHTML=window.main}),!1}function b(e){return[0,1,2,3,4][Math.ceil(parseInt(e,16).toString(2).length/8)]}var u,r,l,c,h;document.body.contains(document.goSearch)&&(document.goSearch.onsubmit=function(){return goSearchNow()},u=document.getElementById("suggestions"),r=document.getElementById("searchinput"),document.addEventListener("keydown",function(t){if(191===t.keyCode&&"INPUT"!==document.activeElement.tagName&&"TEXTAREA"!==document.activeElement.tagName&&(t.preventDefault(),r.focus(),u.classList.remove("d-none")),27===t.keyCode){r.blur(),u.classList.add("d-none");for(var e=document.getElementById("suggestions");e.firstChild;)e.removeChild(e.firstChild)}var n=u.querySelectorAll("a");if(!u.classList.contains("d-none")&&0!==n.length){var o=[...n],i=o.indexOf(document.activeElement);let e=0;38===t.keyCode?(t.preventDefault(),n[e=0",a=n.querySelector("a"),t=n.querySelector("span:first-child"),d=n.querySelector("span:nth-child(2)"),a.href=e.ref,t.textContent=e.doc.title,d.innerHTML=((e,t)=>{var n=t.map(function(e){return elasticlunr.stemmer(e.toLowerCase())}),o=!1,i=0,r=[],s=e.toLowerCase().split(". ");for(p in s){var u,l=s[p].split(/[\s\n]/),a=8;for(u in l){if(0<(v=l[u]).length){for(var c in n)elasticlunr.stemmer(v).startsWith(n[c])&&(a=40,o=!0);r.push([v,a,i]),a=2}i=i+v.length+1}i+=1}if(0===r.length)return void 0!==e.length&&300"),x=v[2]+v[0].length;40===v[1]||v[0].length<12||/^[\x00-\xff]+$/.test(v[0])?S.push(e.substring(v[2],x)):(y=((e,t)=>{for(var n="",o=!1,i=0,r=0,s=0,u=0;u")}return S.push("…"),S.join("")})(e.doc.body,s),u.appendChild(n))});i.length>r;)u.removeChild(i[0])},!0),u.addEventListener("click",function(){for(;u.lastChild;)u.removeChild(u.lastChild);return!1},!0),document.goSearch.onsubmit=e)};
\ No newline at end of file
diff --git a/js/abridge_nopwa.min.js b/js/abridge_nopwa.min.js
new file mode 100644
index 0000000..b3d44fe
--- /dev/null
+++ b/js/abridge_nopwa.min.js
@@ -0,0 +1 @@
+let items=document.querySelectorAll(".preStyle"),changeIcon=(items.forEach(e=>{e.rel="stylesheet"}),(()=>{for(var e=document.getElementsByClassName("m-protected"),t=0;t{e.classList.add(t),setTimeout(()=>e.classList.remove(t),2500)}),copyCodeAndChangeIcon=async(t,e)=>{e=(e.querySelector("table")?getTableCode:getNonTableCode)(e);try{await navigator.clipboard.writeText(e),changeIcon(t,"yes")}catch(e){changeIcon(t,"err")}},getNonTableCode=e=>[...e.querySelectorAll("code")].map(e=>e.textContent).join(""),getTableCode=e=>[...e.querySelectorAll("tr")].map(e=>e.querySelector("td:last-child")?.innerText??"").join("");document.querySelectorAll("pre").forEach(e=>{let t=document.createElement("div");t.className="cc svgs svgh copy",t.innerHTML=" ",e.prepend(t),t.addEventListener("click",()=>copyCodeAndChangeIcon(t,e))}),function(){function g(e){var t=new g.Index;return t.pipeline.add(g.trimmer,g.stopWordFilter,g.stemmer),e&&e.call(t,t),t}var a,c,e,t,d,h,f,p,m,v,y,S,x,b,w,I,E,C,D,F,k,_,N,L,n;g.version="0.9.5",((lunr=g).utils={}).warn=(n=this,function(e){n.console}),g.utils.toString=function(e){return null==e?"":e.toString()},(g.EventEmitter=function(){this.events={}}).prototype.addListener=function(){var e=[].slice.call(arguments),t=e.pop();if("function"!=typeof t)throw new TypeError("last argument must be a function");e.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},g.EventEmitter.prototype.removeListener=function(e,t){this.hasHandler(e)&&-1!=(t=this.events[e].indexOf(t))&&(this.events[e].splice(t,1),0==this.events[e].length)&&delete this.events[e]},g.EventEmitter.prototype.emit=function(e){var t;this.hasHandler(e)&&(t=[].slice.call(arguments,1),this.events[e].forEach(function(e){e.apply(void 0,t)},this))},g.EventEmitter.prototype.hasHandler=function(e){return e in this.events},(g.tokenizer=function(e){var t,n;return arguments.length&&null!=e?Array.isArray(e)?(t=(t=e.filter(function(e){return null!=e})).map(function(e){return g.utils.toString(e).toLowerCase()}),n=[],t.forEach(function(e){e=e.split(g.tokenizer.seperator);n=n.concat(e)},this),n):e.toString().trim().toLowerCase().split(g.tokenizer.seperator):[]}).defaultSeperator=/[\s\-]+/,g.tokenizer.seperator=g.tokenizer.defaultSeperator,g.tokenizer.setSeperator=function(e){null!=e&&"object"==typeof e&&(g.tokenizer.seperator=e)},g.tokenizer.resetSeperator=function(){g.tokenizer.seperator=g.tokenizer.defaultSeperator},g.tokenizer.getSeperator=function(){return g.tokenizer.seperator},(g.Pipeline=function(){this._queue=[]}).registeredFunctions={},g.Pipeline.registerFunction=function(e,t){t in g.Pipeline.registeredFunctions&&g.utils.warn("Overwriting existing registered function: "+t),e.label=t,g.Pipeline.registeredFunctions[t]=e},g.Pipeline.getRegisteredFunction=function(e){return e in g.Pipeline.registeredFunctions!=1?null:g.Pipeline.registeredFunctions[e]},g.Pipeline.warnIfFunctionNotRegistered=function(e){e.label&&e.label in this.registeredFunctions||g.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},g.Pipeline.load=function(e){var n=new g.Pipeline;return e.forEach(function(e){var t=g.Pipeline.getRegisteredFunction(e);if(!t)throw Error("Cannot load un-registered function: "+e);n.add(t)}),n},g.Pipeline.prototype.add=function(){[].slice.call(arguments).forEach(function(e){g.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},g.Pipeline.prototype.after=function(e,t){g.Pipeline.warnIfFunctionNotRegistered(t);e=this._queue.indexOf(e);if(-1==e)throw Error("Cannot find existingFn");this._queue.splice(1+e,0,t)},g.Pipeline.prototype.before=function(e,t){g.Pipeline.warnIfFunctionNotRegistered(t);e=this._queue.indexOf(e);if(-1==e)throw Error("Cannot find existingFn");this._queue.splice(e,0,t)},g.Pipeline.prototype.remove=function(e){e=this._queue.indexOf(e);-1!=e&&this._queue.splice(e,1)},g.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,o=this._queue.length,i=0;i{if(null===e||"object"!=typeof e)return e;var t,n=e.constructor();for(t in e)e.hasOwnProperty(t)&&(n[t]=e[t]);return n})(t):null},g.DocumentStore.prototype.getDoc=function(e){return!1===this.hasDoc(e)?null:this.docs[e]},g.DocumentStore.prototype.hasDoc=function(e){return e in this.docs},g.DocumentStore.prototype.removeDoc=function(e){this.hasDoc(e)&&(delete this.docs[e],delete this.docInfo[e],this.length--)},g.DocumentStore.prototype.addFieldLength=function(e,t,n){null!=e&&0!=this.hasDoc(e)&&(this.docInfo[e]||(this.docInfo[e]={}),this.docInfo[e][t]=n)},g.DocumentStore.prototype.updateFieldLength=function(e,t,n){null!=e&&0!=this.hasDoc(e)&&this.addFieldLength(e,t,n)},g.DocumentStore.prototype.getFieldLength=function(e,t){return null!=e&&e in this.docs&&t in this.docInfo[e]?this.docInfo[e][t]:0},g.DocumentStore.prototype.toJSON=function(){return{docs:this.docs,docInfo:this.docInfo,length:this.length,save:this._save}},a={ational:"ate",tional:"tion",enci:"ence",anci:"ance",izer:"ize",bli:"ble",alli:"al",entli:"ent",eli:"e",ousli:"ous",ization:"ize",ation:"ate",ator:"ate",alism:"al",iveness:"ive",fulness:"ful",ousness:"ous",aliti:"al",iviti:"ive",biliti:"ble",logi:"log"},c={icate:"ic",ative:"",alize:"al",iciti:"ic",ical:"ic",ful:"",ness:""},d=/^([^aeiou][^aeiouy]*)?[aeiouy][aeiou]*[^aeiou][^aeiouy]*/,h=/^([^aeiou][^aeiouy]*)?[aeiouy][aeiou]*[^aeiou][^aeiouy]*[aeiouy][aeiou]*[^aeiou][^aeiouy]*/,f=/^([^aeiou][^aeiouy]*)?[aeiouy][aeiou]*[^aeiou][^aeiouy]*([aeiouy][aeiou]*)?$/,p=/^([^aeiou][^aeiouy]*)?[aeiouy]/,m=/^(.+?)(ss|i)es$/,v=/^(.+?)([^s])s$/,y=/^(.+?)eed$/,S=/^(.+?)(ed|ing)$/,x=/.$/,b=/(at|bl|iz)$/,w=/([^aeiouylsz])\1$/,I=RegExp("^"+(t="[^aeiou][^aeiouy]*")+(e="[aeiouy]")+"[^aeiouwxy]$"),E=/^(.+?[^aeiou])y$/,C=/^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/,D=/^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/,F=/^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/,k=/^(.+?)(s|t)(ion)$/,_=/^(.+?)e$/,N=/ll$/,L=RegExp("^"+t+e+"[^aeiouwxy]$"),g.Pipeline.registerFunction(g.stemmer=function(e){var t,n,o,i,r,s,u,l;return e.length<3||("y"==(n=e.substr(0,1))&&(e=n.toUpperCase()+e.substr(1)),u=v,(r=m).test(e)?e=e.replace(r,"$1$2"):u.test(e)&&(e=e.replace(u,"$1$2")),u=S,(r=y).test(e)?(l=r.exec(e),(r=d).test(l[1])&&(e=e.replace(r=x,""))):u.test(e)&&(s=(l=u.exec(e))[1],(u=p).test(s))&&(e=s,o=w,i=I,(u=b).test(e)?e+="e":o.test(e)?e=e.replace(r=x,""):i.test(e)&&(e+="e")),(r=E).test(e)&&(e=(s=(l=r.exec(e))[1])+"i"),(r=C).test(e)&&(s=(l=r.exec(e))[1],t=l[2],(r=d).test(s))&&(e=s+a[t]),(r=D).test(e)&&(s=(l=r.exec(e))[1],t=l[2],(r=d).test(s))&&(e=s+c[t]),u=k,(r=F).test(e)?(s=(l=r.exec(e))[1],(r=h).test(s)&&(e=s)):u.test(e)&&(s=(l=u.exec(e))[1]+l[2],(u=h).test(s))&&(e=s),(r=_).test(e)&&(s=(l=r.exec(e))[1],u=f,o=L,(r=h).test(s)||u.test(s)&&!o.test(s))&&(e=s),u=h,(r=N).test(e)&&u.test(e)&&(e=e.replace(r=x,"")),"y"==n&&(e=n.toLowerCase()+e.substr(1))),e},"stemmer"),g.stopWordFilter=function(e){return e&&!0!==g.stopWordFilter.stopWords[e]?e:void 0},g.clearStopWords=function(){g.stopWordFilter.stopWords={}},g.addStopWords=function(e){null!=e&&!1!==Array.isArray(e)&&e.forEach(function(e){g.stopWordFilter.stopWords[e]=!0},this)},g.resetStopWords=function(){g.stopWordFilter.stopWords=g.defaultStopWords},g.stopWordFilter.stopWords=g.defaultStopWords={"":!0,a:!0,able:!0,about:!0,across:!0,after:!0,all:!0,almost:!0,also:!0,am:!0,among:!0,an:!0,and:!0,any:!0,are:!0,as:!0,at:!0,be:!0,because:!0,been:!0,but:!0,by:!0,can:!0,cannot:!0,could:!0,dear:!0,did:!0,do:!0,does:!0,either:!0,else:!0,ever:!0,every:!0,for:!0,from:!0,get:!0,got:!0,had:!0,has:!0,have:!0,he:!0,her:!0,hers:!0,him:!0,his:!0,how:!0,however:!0,i:!0,if:!0,in:!0,into:!0,is:!0,it:!0,its:!0,just:!0,least:!0,let:!0,like:!0,likely:!0,may:!0,me:!0,might:!0,most:!0,must:!0,my:!0,neither:!0,no:!0,nor:!0,not:!0,of:!0,off:!0,often:!0,on:!0,only:!0,or:!0,other:!0,our:!0,own:!0,rather:!0,said:!0,say:!0,says:!0,she:!0,should:!0,since:!0,so:!0,some:!0,than:!0,that:!0,the:!0,their:!0,them:!0,then:!0,there:!0,these:!0,they:!0,this:!0,tis:!0,to:!0,too:!0,twas:!0,us:!0,wants:!0,was:!0,we:!0,were:!0,what:!0,when:!0,where:!0,which:!0,while:!0,who:!0,whom:!0,why:!0,will:!0,with:!0,would:!0,yet:!0,you:!0,your:!0},g.Pipeline.registerFunction(g.stopWordFilter,"stopWordFilter"),g.Pipeline.registerFunction(g.trimmer=function(e){if(null==e)throw Error("token should not be undefined");return e.replace(/^\W+/,"").replace(/\W+$/,"")},"trimmer"),(g.InvertedIndex=function(){this.root={docs:{},df:0}}).load=function(e){var t=new this;return t.root=e.root,t},g.InvertedIndex.prototype.addToken=function(e,t,n){for(var n=n||this.root,o=0;o<=e.length-1;){var i=e[o];i in n||(n[i]={docs:{},df:0}),o+=1,n=n[i]}var r=t.ref;n.docs[r]?n.docs[r]={tf:t.tf}:(n.docs[r]={tf:t.tf},n.df+=1)},g.InvertedIndex.prototype.hasToken=function(e){if(!e)return!1;for(var t=this.root,n=0;n=n&&r-1>=o;)s[n]!==u[o]?s[n]u[o]&&o++:(t.add(s[n]),n++,o++);return t},lunr.SortedSet.prototype.clone=function(){var e=new lunr.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},lunr.SortedSet.prototype.union=function(e){for(var t,e=this.length
The JavaScript world has been battling for low bundle size from the very beginning.
+It is now our turn to enter the battle
+
+
Dedicated to all front-end developers who doubt, but.
+
Intro
+
The JavaScript backend in GHC has a long history of various challenges. One of the most notable is the transition from GHC 8.x to 9.x. Significant work has been done up to today by the GHC team, and progress is still ongoing. Besides the obvious need to make the GHC JavaScript backend functional in general, some specific issues have been raised regarding its use in production, one of them being the size of the produced JavaScript bundles.
+
Bundle size is an important consideration when commercial applications face challenges in delivering to end users. It is not surprising that consumers pay attention to software user experience. First impressions matter, and the time required for a fully functional interface to appear on the user's device is crucial.
+
Web applications are particularly sensitive to the duration before user interactions can begin. When you are loading a site or web application, you expect it to be fast. Bundle size is a primary target for loading time optimizations, due to the fact that, at this point, you have little control over what to offer the user while the progress bar is filling up.
+
Bundle Size Challenge
+
The JavaScript world has been battling for low bundle size from the very beginning. Various tactics have been developed up to today. Everyone who has participated in web development has heard words like minification, obfuscation, compression, and code elimination. Each of these terms opens a door to a wide array of tools whose configuration can take a long time and requires special experience: the resulting bundle should not only be lightweight but also functional.
+
Roughly speaking, we can categorize all these tools and approaches into the following set of practical actions:
+
+
Code rewrite. Simple approaches are known as minification. They are based on the fact that JavaScript supports pulling all code into a single line by removing whitespace. More intelligent approaches swap variable names for shorter ones. A side effect of this is that it makes reading such code harder, which in itself is a practice known as obfuscation. Even more advanced tools support unused (dead) code detection, allowing it to be safely removed. How can this happen? Third-party libraries provide various functions, but a specific application uses only a subset of them. The most advanced tools take things a step further: they can detect some code that can be rewritten in a more optimal form according to its actual use cases. For instance, if you use a constant variable, its value can be substituted directly in a call. In that case, the variable definition itself is not important and can be omitted, with its value used in place (inlined).
+
Environment-dependent graceful degradation. The runtime environment can vary significantly due to different browsers and their versions. Sometimes you have control over the user's runtime environment, especially if the application is targeted at commercial clients. More often, your runtime environment is very diverse. Different environments impose different restrictions. Rich (and probably more modern) environments provide a large set of built-in features. The way you deliver your programs could depend on these features, as they can help build optimal bundles where your code does not have to implement low-level behaviors from scratch. Such code can have shortcuts for features where there is no need to include the full implementation, which would add more to the bundle. For example, internationalization (i18n) can be supported by some targets, so you do not need to add a full implementation in your code. This approach encourages modern user environments with faster load times, but for others, it makes things "just work" at the cost of bundle size. Web servers can detect browsers and their versions to select the best bundle size using the User-Agent header.
+
Network-level compression. The simplest approach to reducing load time is to use good old compression, usually gzip compression. There is no need to deal with code optimizations. Most environments support it "out of the box" through the provided Content-Encoding header. It has its own weakness: the time to unpack the application on the client side. However, such a concern has become less important these days, thanks to modern CPUs—even on low-budget devices.
+
Dynamic bundle loading. This is the last but not least option when no other ways give you satisfactory results in the battle for short loading times. Usually, even large applications can be split into smaller parts that can be loaded as the user navigates through the interface. It is an old approach used on the Web: hypertext itself encourages this way of loading time optimization. Modern web applications can be designed to load their parts one by one if the tools used support partial loading.
+
+
JavaScript ecosystem
+
As mentioned in the previous part, the modern JavaScript ecosystem provides battle-tested approaches to dealing with bundle size. The most notable ones that come to mind include:
+
+
Terser, UglifyJS, and Google Closure Compiler. All of them provide methods to transform code into a minified form, ranging from trivial optimizations to more advanced techniques like dead code elimination.
+
Babel for environment-related optimizations. Its primary purpose is to construct a set of "polyfills" that ensure uniform code execution across environments with different capabilities. Babel does not know a priori which capabilities an environment has, but it can be configured declaratively at build time to specify which features are expected to be present or not. One possible scenario for its usage in the task of bundle size reduction is to categorize possible environments into classes and prepare specific builds for each class. Bundle selection for delivery can be fulfilled by the static content server. For example, this can be implemented with the help of Nginx, where bundles can be associated with the incoming User-Agent header.
+
Webpack (Parcel, Rollup) for bundle combining and splitting. The modern JavaScript environment has support for code modularization, but this support is still far from perfect. Even if support becomes more widespread, bundling will probably remain important due to networking: loading one big file generally has fewer side effects on time than loading a set of files with the same total size. Bundlers come into play when your application consists of a large number of modules, which is a common case. Moreover, they add additional value to the application build pipeline: they provide a way to slice a large application into a few bundles that can be loaded dynamically. Such slicing can usually be configured declaratively.
+
Gzip, Deflate, and Brotli via Nginx through fallback on the Content-Encoding header value. Their usage is quite straightforward. It depends only on the selected delivery method. Usually, web servers and content delivery networks handle this task with the best available efforts, so it is very rare that any manual tweaking is needed.
+
+
The Haskell way
+
Let us return to our primary topic and consider how the Haskell environment takes its own seat with the concepts described above.
+
Network-level compression does not depend on how the JavaScript bundle is generated. It is the most accessible way to address the issue of large bundle sizes. We assume that it is enabled by default and, for measurement purposes, we assume that Gzip is used. So, even if the GHC JavaScript backend does not support anything from the list above related to code splitting or code optimizations, we can still improve user experience by reducing bundle loading time through the correct configuration of the delivery channel to use reliable old compression.
+
+
So, there are no troubles here ✅✅.
+
+
Dynamic bundle loading is a complex topic. The GHC JavaScript bundle does not support it natively. However, real-world JavaScript applications usually depend on other JavaScript libraries and modules. We assume that a Haskell application could depend on them: call their functions, return results to them, and be called from external JavaScript code. Currently, the GHC 9.x JavaScript backend lacks full support for FFI. It allows only functions as JavaScript imports. However, it is enough to construct the interface where JavaScript can call Haskell functions and vice versa. Thus, we cover two possible top-level architecture scenarios:
+
+
Haskell is used to write modules that will be used by some top-level JavaScript code. Such JavaScript code could be used only for bootstrapping purposes actually. In that scenario, bundlers (i.e., Webpack) could consider Haskell code as an old-fashioned JavaScript module that operates through globally exported functions. By this assumption, we gain the full power of slicing our application with a bundler, but its atomic slice is limited to the whole JavaScript bundle from the GHC 9.x JavaScript backend because it is a kind of "black box" for the bundler. Thus, it allows you to write different parts of the application in different Haskell modules which could be loaded on-demand from the top-level JavaScript code. The main issue here is to write a correct rule for loading such an "old-fashioned" module. A Haskell module (when Emscripten is used) can contain some global variables which require lots of care from the bundler side to ensure they are loaded sequentially by time but safely "shimmed" for simultaneous usage in the global JavaScript namespace.
+
Haskell is used to write a top-level module that is supposed to be a caller for dependent JavaScript modules. It is supposed that this way is primary for existing commercial frontend applications written in Haskell for the Web. That looks like a straightforward way to begin development but encourages limited benefits from existing JavaScript bundlers. They can be used only to prepare third-party libraries for external calls. The GHC 8.x/9.x JavaScript linker currently does not support dynamically loading dependent Haskell modules on-demand: it assumes that all Haskell code is present statically at the moment of application bootstrap.
+
+
+
Well, this way of bundle size optimization is limited even if possible. Even if the first strategy is chosen, the process of keeping the bundle configuration correct throughout the development lifecycle will require deep knowledge and lots of patience. Not sure what is more, so 🤷♂️.
+
+
Accommodation of this tactic will not be covered by the samples in this article, but it could be an interesting journey for developers who participate in large Haskell web frontend application support. If it finds a strong response from the community, it could be investigated further.
+
Environment-dependent graceful degradation is related to the previously discussed topic. Such tools (i.e., Babel) in the JavaScript ecosystem tend to be used in conjunction with bundlers (i.e., Webpack), but some of them can be used standalone. Their practical purpose for Haskell applications lies in providing a stable environment with all modern features of ECMAScript implemented natively or through "polyfills." Unfortunately, "ponyfills" cannot be used with Haskell frontend applications due to the lack of support for CommonJS/ESM modules in the GHC 8.x/9.x JavaScript backend linker. Fortunately, the GHC 8.x/9.x JavaScript backend generates a very simple JavaScript subset. GHC's JavaScript RTS library has been written with ES5 in mind, with minor inclusions of fat-arrow-style functions from ES6. The used ES-language features are broadly supported nowadays. So, if your code does not use third-party libraries in JavaScript (which is supposed to be a rare case for real-world commercial applications), the usage of tools like Babel does not seem necessary.
+
On the other hand, even a Hello World-like Haskell application comes with a rich set of built-in modules for everyday use. Some modules of i18n and bigint from built-in libraries could be swapped for ones from a stable environment. This could reduce the size of generated JavaScript bundles for modern environments where "polyfills" are not needed. For older environments, such "polyfills" could be incorporated through declarative Babel configuration.
+
We face two scenarios of graceful degradation tool usage for a Haskell web frontend application:
+
+
Third-party JavaScript libraries may require them. There is a dash in the JavaScript world. Authors of popular and reliable libraries tend to use the most modern and fashionable ECMAScript features. This adds additional complexity for Haskell application distribution. Such libraries need to pass through tools like Babel before being added to the resulting bundle.
+
The Haskell application itself relies on built-in packages, which is fine in terms of reliable execution (one of Haskell's strong sides) but not so well with bundle size when the environment provides native or "polyfilled" implementations for basic functions to work with things like i18n and Bignum (BigInt).
+
+
+
In short, this way of optimization has little to do with the Haskell application itself for now. It can be integrated into the resulting bundle compilation to process third-party JavaScript dependencies ✅, but currently, GHC 9.x JavaScript does not support swapping functions from built-in packages with those provided by the environment ❌.
+
+
Experiments with this tactic remain out of scope for the current attempt to bring some benefits. Here, the same action is relevant as for the previous one: strong response from the community could drive investigations into this field.
+
Code rewrite is a common tactic for advanced bundle size optimizations. Besides using optimizing compilers like Google Closure Compiler, the GHC 8.x/9.x JavaScript backend offers features to deal with large bundle sizes. The overview of introduced improvements in this area will be covered in the next section of this article and measured. Also, it is important to keep the resulting bundle compatible with existing optimizing compilers (at least one of them) because it provides additional benefits for application developers.
+
Although a long route still lies ahead, some steps have already come into play nowadays: optimizing compiler support has been fixed, Unicode dead code elimination improved, string representation optimized, and Unicode (again!) table size notably reduced. ✅ Let us see the details in the next section!
+
Passed steps for great good
+
Before anything else, it's necessary to mention that the initial event that sparked this work was an offline discussion where the opinion was formed that even a 100kb total bundle size for a Haskell "Hello World" application is not achievable.
+
Well, does it really matter? We will measure it with size-limit, which shows sizes and time to load on a bad connection.
+
We are going to begin from the latestmaster commit at the time of writing this article. Right on this commit, we will revert the added code optimizations:
+
+
#24789 Reasoning on Unicode static data compression on the GHC side
+
#24504 Eliminate dependency of "Hello World" on Read
+
#24706 Port back more efficient packing of string data from GHCJS to GHC JavaScript backend
+
+
The order is important. They were added in reverse order, so applying reverts to related commits reconstructs the whole GHC state. We want to take the most modern (and buildable!) GHC state and see how the JavaScript bundle size is improved over these commits.
+
Additionally, it's important to note that there is one more significant issue:
It is important, but it does not add optimizations to GHC itself. It only allows us to run the Google Closure Compiler over the resulting bundle, which we can turn on/off manually during the following steps. We will apply all measurements with and without it to track its necessity.
+
Our building pipeline will be the following:
+
+
Build a sample Haskell program with GHC optimization option -O2.
+
Process all.js through Google Closure Compiler with --compilation_level ADVANCED_OPTIMIZATIONS.
+
Process all.js and all.min.js (result of the Google Closure Compiler) with size-limit.
+
+
We will measure the following:
+
+
The size of all.js after the GHC pass
+
The size of all.min.js after the Google Closure pass
+
The brotlied sizes of them both via size-limit
+
The running time via size-limit to estimate how hard it is for the browser to load on a low budget device. It uses estimo internally.
+
+
Lets do some initial measurements (when no improvements have been applied via the reverted commits on fresh master):
$ npx size-limit
+✔ Running JS in headless Chrome
+
+ HelloJS.jsexe/all.js
+ Package size limit has exceeded by 188.74 kB
+ Size limit: 10 kB
+ Size: 198.74 kB brotlied
+ Loading time: 3.9 s on slow 3G
+ Running time: 9.6 s on Snapdragon 410
+ Total time: 13.5 s
+
+ HelloJS.jsexe/all.min.js
+ Package size limit has exceeded by 171.55 kB
+ Size limit: 10 kB
+ Size: 181.55 kB brotlied
+ Loading time: 3.6 s on slow 3G
+ Running time: 7.1 s on Snapdragon 410
+ Total time: 10.6 s
+
+
Well, results are far from perfect. 10s to load.
+
Warning for experienced researchers: We are not going to make reliable sigma-based measurements. Their purpose is only to demonstrate the direction of improvements.
To avoid saying the same things twice (you can follow the issue for details) we are going to disclose it in following samples:
+
[72, 101, 108, 108, 111]
+
+
VS
+
Hello
+
+
You probably noticed that second sample is shorter than first. It was the point of the ticket. It decreases bundle size besides better readability.
+
To make it happen let us deal how string literals work in GHC. They become an int array in a memory address pointer which has type Addr# internally. But not only string literals are encoded in an int array (Addr#). GHC is smart enough to use same technique for all embedded stuff which can be represented as an int array with a pointer. It can be used for embedded files as well. For anything that can look like an int array.
$ npx size-limit
+✔ Running JS in headless Chrome
+
+ HelloJS.jsexe/all.js
+ Package size limit has exceeded by 185.07 kB
+ Size limit: 10 kB
+ Size: 195.07 kB brotlied
+ Loading time: 3.9 s on slow 3G
+ Running time: 7.8 s on Snapdragon 410
+ Total time: 11.6 s
+
+ HelloJS.jsexe/all.min.js
+ Package size limit has exceeded by 85.01 kB
+ Size limit: 10 kB
+ Size: 95.01 kB brotlied
+ Loading time: 1.9 s on slow 3G
+ Running time: 8.2 s on Snapdragon 410
+ Total time: 10.1 s
+
+
Well, our bundle is becoming smaller in size but it remains expensive to load by a low budget device. Note how important it is to use Google Closure Compiler for production builds!
+
What can be removed from the bundle? Unicode? #24504
+
While sifting through the contents of app.js, the following was found:
That is a really long line of code! It takes 4,316,351 characters at the bundle. What is even more interesting that Google Closure Compiler was unable to eliminate it as a dead code. It sounded like for some reason as really needed by:
+
main :: IO ()
+main = print "HelloWorld"
+
+
It was a challenge to prove that it was exactly needed by the application. A special toolkit was created for call graph analysis
+in JavaScript bundles. Its purpose is very simple: It takes the JavaScript AST, reconstructs actual function calls as STG and creates a visualization
+to be processed by a graph explorer (e.g. Gephi).
+
When the graph file had been constructed, we only needed to find the shortest path between JavaScript main and h$ghczminternalZCGHCziInternalziUnicodeziCharziUnicodeDataziGeneralCategoryzilvl_1. That route was found!
+
+
+
Fig. 1. The whole route from main function to Unicode. It demonstrates how much nodes were connected and how. It begins from JavaScript main and ends at h$ghczminternalZCGHCziInternalziUnicodeziCharziUnicodeDataziGeneralCategoryzilvl_1. Total amount of conntected nodes is 30.
+
+
The most interesting node is h$ghczminternalZCGHCziInternalziUnicodezizdwisSpace. It means that isSpace was the only reason why whole Unicode table had been added to the bundle. And isSpace is used by read parser. So, when we call the read function, that dependency route is triggered to be included into result bundle.
+
It turned out that the root of this issue came from an older one. With the help of call graph tracing, it was possible to establish the actual reason and fix it! (Ben Gamari, thank you so much)
$ npx size-limit
+✔ Running JS in headless Chrome
+
+ HelloJS.jsexe/all.js
+ Package size limit has exceeded by 155.23 kB
+ Size limit: 10 kB
+ Size: 165.23 kB brotlied
+ Loading time: 3.3 s on slow 3G
+ Running time: 3.1 s on Snapdragon 410
+ Total time: 6.3 s
+
+ HelloJS.jsexe/all.min.js
+ Package size limit has exceeded by 63.92 kB
+ Size limit: 10 kB
+ Size: 73.92 kB brotlied
+ Loading time: 1.5 s on slow 3G
+ Running time: 2 s on Snapdragon 410
+ Total time: 3.4 s
+
+
73.92 kB! Even more better! But wait.
+
What if Unicode is actually needed by some programs? #24789
+
As you noted there, it does not require much effort to trigger the addition of the unicode table. A trivial reference to read is enough to pull back the whole table back into the bundle.
+That victory is too fragile to be proud of given results. Lots of real applications have to use isSpace when dealing with text parsing and so on. We have to support this case but keep the bundle size low.
+
Let us consider the following sample program:
+
main :: IO ()
+main = print (read @Int "1337")
+
+
Here we are facing the issue again.
+
The variable h$ghczminternalZCGHCziInternalziUnicodeziCharziUnicodeDataziGeneralCategoryzilvl_1 stores information about the mapping of each Unicode character to its General Category. The number of characters in each category varies. Some categories contain significantly more characters than others. When characters are listed sequentially in memory, their order does not necessarily match the order of the categories. This creates a challenge: how to organize characters in memory so that the search for their categories is both fast and space-efficient.
+
Not many ideas came at the beginning, so a broad discussion was required with GHC community to see what can be tried to solve this.
+Additionally, removing Streamly from GHC sources was needed as well because this dependency didn't keep its API stable.
+
Pierre Le Marre came withultimatesolution for the problem with large Unicode table but it was considered too powerful to be applied right now, so, the time for shamochu will come next.
+
Sylvain Henry's approach, less performant in terms of size reduction gains, was deemed much easier to be implemented. The conclusion was to use the latter one because we needed something easier and without additional dependencies at the moment.
+
The main idea is to generate better lookup code which can be translated into switches:
+
generalCategory (ord -> n)
+|...
+| n <129726=21
+| n <129792= lookupIntN "..."# (n -129726) -- variable ranges: use lookup tables
+...
+| n <1048576=29-- constant ranges
+| n <1114110=28
+| otherwise =29
+
+
Sylvain Henry's approach was enhanced with nested ifs (logarithmic search vs linear search) and makes estimation regarding the most appropriate chunk size (as he predicted in the origin message):
+
+
+
Fig. 2. Finding the best size of chunks by comparing all possible values against generated function size. It shows that 50 items is a good-enough value of chunks size.
$ npx size-limit
+✔ Running JS in headless Chrome
+
+ HelloJS.jsexe/all.js
+ Package size limit has exceeded by 186.88 kB
+ Size limit: 10 kB
+ Size: 196.88 kB brotlied
+ Loading time: 3.9 s on slow 3G
+ Running time: 4 s on Snapdragon 410
+ Total time: 7.9 s
+
+ HelloJS.jsexe/all.min.js
+ Package size limit has exceeded by 86.3 kB
+ Size limit: 10 kB
+ Size: 96.3 kB brotlied
+ Loading time: 1.9 s on slow 3G
+ Running time: 2.5 s on Snapdragon 410
+ Total time: 4.4 s
+
+
Well, sizes are looking near same after compression but take a look at Running time. It looks like new version of unicode code is easier to understand by simulated low budget device!
+
Intermediate conclusions
+
This article shows that community work can yield results that beat the original opinion about "completely unachievable 100kb". We seen how 6.8M became 2.8M for uncompressed Haskell JavaScript bundle and how 181.55 kB became 96.3 kB for completely optimized, compressed production-ready JavaScript bundle of trivial Unicode-enabled Haskell JavaScript application.
+
What is next? Besides addingvariouscode optimizations it would be nice also to consider other options from the beginning:
+
+
Give a try to slice Haskell applications in chunks, with Webpack dynamic loading as "black box".
+
Consider adding to GHC JavaScript backend the ability to slice code in CJS/ESM modules.
Extend GHC JavaScript backend Linker with a feature which would switch on/off built-in modules for environments where they can be already provided by platform.
+
+
Thanks!
+
Thanks for the long reading! It was a very interesting journey and the author hopes now it was for you too, dear reader! Let us meet together in contributing to GHC!
+
Thanks for people with whom I was much impressed to work (in alphabetical order):
It is a pleasure to work with all of you on the Glorious Glasgow Haskell Compiler! Special thanks for Jeffrey Young who opened a door for me first and invited to work on the GHC JavaScript Backend.
+
+
+
+
+
+
+
+
+
diff --git a/report-of-js-code-minification/retina-graph-main-to-unicode.png b/report-of-js-code-minification/retina-graph-main-to-unicode.png
new file mode 100644
index 0000000..f342d32
Binary files /dev/null and b/report-of-js-code-minification/retina-graph-main-to-unicode.png differ
diff --git a/robots.txt b/robots.txt
new file mode 100644
index 0000000..95e0a2f
--- /dev/null
+++ b/robots.txt
@@ -0,0 +1,5 @@
+
+Sitemap: https://blog.haskell.org/sitemap.xml
+User-Agent: *
+Allow: /
+Host: https://blog.haskell.org
diff --git a/safari-pinned-tab.svg b/safari-pinned-tab.svg
new file mode 100644
index 0000000..afabe95
--- /dev/null
+++ b/safari-pinned-tab.svg
@@ -0,0 +1,271 @@
+
+
+
diff --git a/search_index.en.json b/search_index.en.json
new file mode 100644
index 0000000..f2b15e3
--- /dev/null
+++ b/search_index.en.json
@@ -0,0 +1 @@
+{"fields":["title","description","body"],"pipeline":["trimmer","stopWordFilter","stemmer"],"ref":"id","version":"0.9.5","index":{"body":{"root":{"docs":{},"df":0,"0":{"docs":{},"df":0,".":{"docs":{},"df":0,"5":{"docs":{},"df":0,".":{"docs":{},"df":0,"8":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":1,"=":{"docs":{},"df":0,"v":{"docs":{},"df":0,"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}}}}},"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"1":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2,"0":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"0":{"docs":{},"df":0,"k":{"docs":{},"df":0,"b":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}},"2":{"docs":{},"df":0,"8":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"3":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}},"8":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"5":{"docs":{},"df":0,"5":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1}}},"2":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2,".":{"docs":{},"df":0,"8":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"0":{"docs":{},"df":0,"1":{"docs":{},"df":0,"9":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"2":{"docs":{},"df":0,"2":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1},"4":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951}},"df":3}}},"4":{"docs":{},"df":0,"5":{"docs":{},"df":0,"0":{"docs":{},"df":0,"4":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"6":{"docs":{},"df":0,"0":{"docs":{},"df":0,"2":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"7":{"docs":{},"df":0,"0":{"docs":{},"df":0,"6":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}},"8":{"docs":{},"df":0,"9":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}},"3":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":1,".":{"docs":{},"df":0,"1":{"docs":{},"df":0,"4":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772}},"df":1}}},"0":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"2":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"4":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,",":{"docs":{},"df":0,"3":{"docs":{},"df":0,"1":{"docs":{},"df":0,"6":{"docs":{},"df":0,",":{"docs":{},"df":0,"3":{"docs":{},"df":0,"5":{"docs":{},"df":0,"1":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}}},"5":{"docs":{},"df":0,"0":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"6":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2,".":{"docs":{},"df":0,"8":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"7":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1,"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"9":{"docs":{},"df":0,"2":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"8":{"docs":{},"df":0,".":{"docs":{},"df":0,"x":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"/":{"docs":{},"df":0,"9":{"docs":{},"df":0,".":{"docs":{},"df":0,"x":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}}}}}}},"9":{"docs":{},"df":0,".":{"docs":{},"df":0,"1":{"docs":{},"df":0,"2":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772}},"df":1},"4":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"6":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1},"x":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}},"6":{"docs":{},"df":0,".":{"docs":{},"df":0,"3":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1,"'":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}},"o":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}},"c":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2}},"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2}}},"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"q":{"docs":{},"df":0,"u":{"docs":{},"df":0,"i":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1}}}}}},"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":3}},"v":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}},"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.23606797749979}},"df":2}}}}},"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"d":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":2.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":4,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}},"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":3}}}}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}}},"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}},"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":3,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}}}}},"o":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1}}}}},"g":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}},"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}},"i":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,".":{"docs":{},"df":0,"j":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"j":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}}},"o":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1},"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1},"w":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":5}}},"p":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":5}}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}}}},"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"z":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}},"b":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3}}}},"p":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":1,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}}}}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"y":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1,"i":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}},"z":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}},"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":2}}},"y":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"/":{"docs":{},"df":0,"s":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}}}}}},"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"y":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.23606797749979},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2},"p":{"docs":{},"df":0,".":{"docs":{},"df":0,"j":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":2,"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":5.656854249492381}},"df":3}}},"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"v":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1},"x":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}}}}}},"r":{"docs":{},"df":0,"b":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}},"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.23606797749979},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"g":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":3}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1}},"i":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}},"o":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":2}}}}},"s":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":1},"m":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}}},"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":1,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}}},"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.23606797749979}},"df":3}}},"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}},"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"k":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}},"b":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178}},"df":1}}},"c":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.4641016151377544}},"df":1}}},"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}},"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"l":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}},"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"e":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":4},"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}},"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1}}}},"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}},"o":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}}},"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.8284271247461903}},"df":2,"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}},"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}}}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}},"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.6457513110645907},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":3}},"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":5}}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"n":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"d":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}},"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}},"g":{"docs":{"https://blog.haskell.org/about/":{"tf":1.7320508075688772},"https://blog.haskell.org/intro/":{"tf":2.0}},"df":2}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}}}},"r":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}},"h":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":3}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}}},"x":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"k":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":4}}},"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"w":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3}}}}},"y":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"d":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}}}},"g":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2},"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.6457513110645907},"https://blog.haskell.org/the-haskell-playground/":{"tf":3.0}},"df":4,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":7.0}},"df":2,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.6457513110645907}},"df":1}}}}},"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}}}},"w":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"y":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}},"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":4.242640687119285},"https://blog.haskell.org/gsoc-2024/":{"tf":2.449489742783178},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":4.123105625617661}},"df":6,".":{"docs":{},"df":0,"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"j":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":2}}}}}}}},"/":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}}},"d":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}},"l":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"ó":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.1622776601683795}},"df":3,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2}}}},"r":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1}}},"e":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"g":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}},"e":{"docs":{},"df":0,"g":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1}}}}}},"u":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}},"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"i":{"docs":{},"df":0,"f":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}},"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1}}}}},"n":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.449489742783178},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178}},"df":2}}}},"s":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}}},"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}}},"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}},"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}}}},"i":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951}},"df":1},"j":{"docs":{},"df":0,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}},"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.0}},"df":1}}}}},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":3.3166247903554},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/gsoc-2024/":{"tf":2.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":5.830951894845301},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.6457513110645907}},"df":6}},"g":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1}}}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}}}},"m":{"docs":{},"df":0,"b":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}},"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}}}}}}}}}}}},"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}}}},"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1,"t":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/about/":{"tf":2.23606797749979},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":3.1622776601683795}},"df":3}}}},"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":3,"j":{"docs":{},"df":0,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}},"u":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/about/":{"tf":1.4142135623730951},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":2.23606797749979},"https://blog.haskell.org/intro/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":4}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}},"e":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.605551275463989},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.23606797749979}},"df":4,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"/":{"docs":{},"df":0,"e":{"docs":{},"df":0,"x":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}},"_":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}}}}},"e":{"docs":{},"df":0,"/":{"docs":{},"df":0,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}}}}},"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3},"x":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2}}},"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.0}},"df":1}}}}}},"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"u":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1},"s":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":3}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":2}}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}},"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":4}}}},"u":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}},"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}}},"j":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":2}}}}},"u":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":3,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178}},"df":2}},"x":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":2.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":2.0}},"df":2}}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"b":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":4,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":2.23606797749979},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4}}}}}},"o":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2}}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}},"o":{"docs":{},"df":0,"k":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/about/":{"tf":1.4142135623730951},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":3.0}},"df":4},"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":2.23606797749979}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":2}}}}},"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"s":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":2}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":2,"a":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}},"p":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1,"s":{"docs":{},"df":0,"—":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":4}}},"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}}}}}}}}}}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":5}}}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2,"i":{"docs":{},"df":0,"z":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"/":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}},"v":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"y":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":2}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"a":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/privacy/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":5,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"t":{"docs":{},"df":0,"y":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"e":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.4142135623730951}},"df":1}},"y":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1},"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178}},"df":1}},"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1},"s":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.0}},"df":1}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":3}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}},"e":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"p":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}},"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}},"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}}}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.7416573867739413},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.8284271247461903}},"df":5,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"y":{"docs":{},"df":0,"=":{"docs":{},"df":0,"v":{"docs":{},"df":0,"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}}}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772}},"df":1}}},"t":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"b":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4},"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":3}},"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":2}},"r":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}}}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":2.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":2.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.6457513110645907}},"df":4}}}},"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1}}}},"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{},"df":0,"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"x":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"f":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}}}}}},"d":{"docs":{},"df":0,"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951}},"df":1,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":1}}}}}}},"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}}},"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}},"v":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":2}}}},"k":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1},"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"b":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}}},"o":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"v":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"r":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"á":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"x":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.23606797749979}},"df":1}}}}}},"o":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":5.916079783099616},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.4142135623730951},"https://blog.haskell.org/intro/":{"tf":1.4142135623730951}},"df":4}}}}}},"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":1}}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951}},"df":2}}}},"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2},"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}},"u":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1},"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}},"w":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":2}}},"u":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":2},"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"e":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}},"y":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":2}}}}},"e":{"docs":{},"df":0,".":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.23606797749979}},"df":3}},"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":3}},"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}},"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}}}},"c":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}}}}},"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"y":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":2.0},"https://blog.haskell.org/intro/":{"tf":2.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":6,"’":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}}}}}}}}},"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/privacy/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":2}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":4}}}}},"g":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1},"h":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1}}}}},"m":{"docs":{},"df":0,"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.449489742783178},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":3}}},"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}}}},"r":{"docs":{},"df":0,"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}},"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1},"g":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":3}}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2,".":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}}}},"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1},"t":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}},"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":4.69041575982343},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3}}}}}},"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.0},"https://blog.haskell.org/gsoc-2024/":{"tf":2.23606797749979},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.449489742783178}},"df":4}}}},"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"5":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"6":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"o":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":3}},"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.1622776601683795},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":3,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2,"u":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"y":{"docs":{},"df":0,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}}}},"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1}}}},"x":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}},"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3}}}},"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0}},"df":2}}},"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.6457513110645907}},"df":3}}},"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":5}},"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2}},"n":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}},"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772}},"df":1}}}}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772}},"df":1}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}},"o":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1},"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"s":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2},"s":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772}},"df":1}},"r":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"r":{"docs":{},"df":0,"a":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}},"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1},"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}},"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}},"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1},"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}}},"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":2.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":4}}}},"e":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}},"w":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"f":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}},"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}},"g":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1},"l":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":3.1622776601683795},"https://blog.haskell.org/gsoc-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.6457513110645907}},"df":5,"(":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1},"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.7320508075688772}},"df":1}}}},"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3},"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1},"v":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}},"x":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":1},"t":{"docs":{},"df":0,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"w":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1}}},"o":{"docs":{},"df":0,"b":{"docs":{},"df":0,"j":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}},"c":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1,"s":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1}}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":5}}}},"r":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.7320508075688772}},"df":1},"m":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":2},"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}},"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":3.3166247903554}},"df":2}}}},"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":2}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}}}},"e":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2},"q":{"docs":{},"df":0,"u":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}},"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":3,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.872983346207417},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":3}}}}},"d":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951}},"df":1,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951}},"df":1}}}}}}},"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}}},"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2}}}}},"g":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}},"p":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.8284271247461903},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":5,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951}},"df":1}}}}},"p":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"h":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/about/":{"tf":1.4142135623730951},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":3.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":5.385164807134504},"https://blog.haskell.org/the-haskell-playground/":{"tf":5.385164807134504}},"df":7,"'":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2},".":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}},"2":{"docs":{},"df":0,"0":{"docs":{},"df":0,"2":{"docs":{},"df":0,"1":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"j":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"u":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}}},"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":1,"h":{"docs":{},"df":0,"u":{"docs":{},"df":0,"b":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"v":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"g":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}},"o":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}},"e":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1},"o":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":2},"g":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.0}},"df":3}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}},"f":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1},"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}},"p":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1}},"t":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/about/":{"tf":1.7320508075688772},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":2}}}},"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}},"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2},"u":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":2.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}}}}}}},"z":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}}},"h":{"docs":{},"df":0,"$":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"c":{"docs":{},"df":0,"z":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"z":{"docs":{},"df":0,"c":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"c":{"docs":{},"df":0,"z":{"docs":{},"df":0,"i":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"z":{"docs":{},"df":0,"i":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"z":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"z":{"docs":{},"df":0,"i":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"z":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"g":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"y":{"docs":{},"df":0,"z":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"v":{"docs":{},"df":0,"l":{"docs":{},"df":0,"_":{"docs":{},"df":0,"1":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"df":0,"d":{"docs":{},"df":0,"w":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}},"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"d":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":3.605551275463989},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.23606797749979},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":4}}}}},"l":{"docs":{},"df":0,"f":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}}},"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":3}},"g":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"p":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.23606797749979}},"df":2}},"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":5}}},"r":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/about/":{"tf":2.23606797749979},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":3.4641016151377544},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.7320508075688772},"https://blog.haskell.org/intro/":{"tf":2.449489742783178},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":5.291502622129181},"https://blog.haskell.org/the-haskell-playground/":{"tf":4.242640687119285}},"df":9,"l":{"docs":{},"df":0,"'":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":3},".":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/about/":{"tf":1.4142135623730951},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":3.0}},"df":3,"’":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}}},"/":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"#":{"docs":{},"df":0,"9":{"docs":{},"df":0,"1":{"docs":{},"df":0,"7":{"docs":{},"df":0,"7":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}}}}}}},"2":{"docs":{},"df":0,"0":{"docs":{},"df":0,"1":{"docs":{},"df":0,"0":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}}}}},"v":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2,"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}}},"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"p":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1},"r":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"v":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1,"w":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{},"df":0,".":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}}},"p":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.449489742783178},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/intro/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":6}},"n":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"y":{"docs":{},"df":0,"'":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}},"r":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/intro/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":5}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}}},"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"g":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}}},"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":2.23606797749979}},"df":1}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1,"i":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}}}},"l":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":2.23606797749979}},"df":1},"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"p":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"z":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}},"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"m":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1,"s":{"docs":{},"df":0,":":{"docs":{},"df":0,"/":{"docs":{},"df":0,"/":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"/":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"/":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"/":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"u":{"docs":{},"df":0,"b":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"/":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"/":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"x":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}},"é":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{},"df":0,"'":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}},".":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1},"1":{"docs":{},"df":0,"8":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}},"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1},"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1,"e":{"docs":{},"df":0,"a":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":3}}},"f":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}}},"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.6457513110645907},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.449489742783178}},"df":4}}}}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.3166247903554},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":5}},"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"o":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":5}}}}},"n":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":2.0}},"df":1,"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":6},"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"r":{"docs":{},"df":0,"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951}},"df":1}}}}}}},"d":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951}},"df":1}}}},"x":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}},"e":{"docs":{},"df":0,"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"f":{"docs":{},"df":0,"o":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"r":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/privacy/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0}},"df":2}}}}}}}}},"e":{"docs":{},"df":0,"q":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":1,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":2.23606797749979}},"df":1}},"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.0}},"df":1},"n":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3}}}}},"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":2,"e":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":1,"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":2.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":3}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}},"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}}},"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":2}},"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}},"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"e":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"o":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}}}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}},"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":1}}}},"r":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":1}},"s":{"docs":{},"df":0,"n":{"docs":{},"df":0,"’":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}},"u":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.6457513110645907},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.23606797749979}},"df":3}}},"t":{"docs":{},"df":0,"'":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":3},"e":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178}},"df":1}}}},"’":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"’":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"j":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1},"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":7.280109889280518}},"df":1}}}}}}}}},"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"y":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951}},"df":1}}}}},"o":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1,"b":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":3.0}},"df":1},"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.7320508075688772}},"df":1}},"n":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"y":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}}},"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"f":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1,"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1}}}}}}},"k":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951}},"df":1}}}},"b":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1},"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":2}},"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"y":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"k":{"docs":{},"df":0,"o":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}},"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}},"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2}}}},"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}},"g":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1},"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/about/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772},"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":5}}}}},"r":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.8284271247461903}},"df":2}},"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"t":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"g":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}},"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2},"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"'":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.6457513110645907}},"df":1},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"b":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}}}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":3.3166247903554},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.0}},"df":5}}}}},"f":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":2,"c":{"docs":{},"df":0,"y":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}},"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{},"df":0,"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.8284271247461903},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"n":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":3,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"k":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}},"u":{"docs":{},"df":0,"x":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}},"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.6457513110645907}},"df":3}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.23606797749979},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}},"t":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"v":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}},"l":{"docs":{},"df":0,"v":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":4.898979485566356},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"g":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":2.23606797749979}},"df":1,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}},"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1},"n":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":3,"u":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3},"w":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.8284271247461903},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"s":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951}},"df":1}},"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1,";":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}}}}},"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}}}}}},"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}}}}}},"s":{"docs":{},"df":0,"m":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":1}}}}},"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"s":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}},"u":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}},"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}},"d":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1},"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2,".":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/intro/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}}}}},"k":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.6457513110645907},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.6457513110645907}},"df":6}},"l":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951}},"df":1}},"g":{"docs":{},"df":0,"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"i":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.23606797749979},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":4}},"e":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}}}},"p":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2},"r":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2},"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1},"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}},"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"x":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":2}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}},"x":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.0}},"df":1}}}},"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":3}}}},"e":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}},"m":{"docs":{},"df":0,"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951}},"df":1}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}}},"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":2.23606797749979}},"df":1}}}},"r":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951}},"df":1}},"s":{"docs":{},"df":0,"q":{"docs":{},"df":0,"u":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4}}}},"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}},"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3},"i":{"docs":{},"df":0,"f":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":2}}}},"u":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1},"r":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.1622776601683795}},"df":1}}},"i":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}},"u":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/gsoc-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.872983346207417},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":5,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"i":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}},"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.6457513110645907},"https://blog.haskell.org/gsoc-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.7416573867739413},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.449489742783178}},"df":5,"o":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}},"v":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":4}},"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":1}}},"p":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3}}}}}}},"n":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":3,"d":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}}}},"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}},"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}}}}}},"e":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":3.1622776601683795},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.605551275463989},"https://blog.haskell.org/the-haskell-playground/":{"tf":3.4641016151377544}},"df":4}},"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"w":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}}}},"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}}}}},"w":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.6457513110645907},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.23606797749979}},"df":7,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1},"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"y":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"/":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"/":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"j":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}},"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"x":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}}},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}},"n":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":3},"r":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}},"e":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":2},"h":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1},"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"w":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.23606797749979},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":4,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}}},"u":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":1,"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":3.1622776601683795}},"df":3}}}}}},"o":{"docs":{},"df":0,"2":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"b":{"docs":{},"df":0,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}},"j":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}}}},"c":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}}}},"d":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1}}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1},"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.872983346207417},"https://blog.haskell.org/the-haskell-playground/":{"tf":3.3166247903554}},"df":4,"/":{"docs":{},"df":0,"o":{"docs":{},"df":0,"f":{"docs":{},"df":0,"f":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}},"e":{"docs":{},"df":0,"’":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"g":{"docs":{},"df":0,"o":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1,"3":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1}}}}},"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}},"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}},"s":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":4.47213595499958}},"df":2,"i":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.23606797749979},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":5}}}}},"r":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":2}}},"g":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":3,"i":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}},"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}}},"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":5,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":2}}},"p":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2}}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}}},"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}}}}},"s":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}},"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}}}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"a":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":4.123105625617661}},"df":4}}}},"g":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.0}},"df":1}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"h":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}},"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"s":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":2.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}},"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":6,"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/privacy/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":4,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":3}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}}}}}}}},"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3},"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"b":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":2.23606797749979}},"df":1}}}}}},"t":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3},"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":2}}}}},"y":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":2}}},"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":4}}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1}}}},"y":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2},"r":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"n":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2}}}}}},"k":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":3}},"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1},"t":{"docs":{},"df":0,"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}}}},"y":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3,".":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,".":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}}}}}}},"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":4.898979485566356}},"df":1}}}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":5,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.7320508075688772}},"df":1}}}}},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.6457513110645907},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":5,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}},"y":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1}}},"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"p":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}}},"n":{"docs":{},"df":0,"y":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"p":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}}},"r":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":3}}}},"t":{"docs":{"https://blog.haskell.org/intro/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":3}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":3}}}}},"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":1}}},"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":3}}}},"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2}}},"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2,"s":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}}}},"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}},"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":1}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.7320508075688772}},"df":1}}}}},"o":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}},"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2}}},"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"a":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":3,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}}},"f":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1,"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.7320508075688772}},"df":2,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,".":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{},"df":0,"m":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}}}}}}}},"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.7320508075688772}},"df":1}}},"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.8284271247461903}},"df":5}},"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":3}}}}},"j":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":3.1622776601683795},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.0},"https://blog.haskell.org/gsoc-2024/":{"tf":2.449489742783178},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.449489742783178}},"df":7,"'":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":2}}}}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":1}},"o":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"f":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}},"u":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"v":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"i":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.3166247903554},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":5}}},"x":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2}},"r":{"docs":{},"df":0,"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178}},"df":2}}}},"t":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}},"q":{"docs":{},"df":0,"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1}}}}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}}},"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}},"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}},"n":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2}}},"e":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":3}},"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":6,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"m":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}},"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4}}}},"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"g":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}}},"p":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":1}}}},"n":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}}}},"r":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.7320508075688772}},"df":1}}}}}},"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}},"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":3.605551275463989},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}},"g":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1},"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}}}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":2},"y":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}},"v":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":2}}},"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"b":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":2}}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":2}}}},"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}}}},"q":{"docs":{},"df":0,"u":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4}}},"i":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.8284271247461903}},"df":1}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":4}}}},"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":2,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":2.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.605551275463989},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951}},"df":1}}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2},"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}}},"w":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}},"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2}}},"s":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"b":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"d":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"o":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1,"u":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}},"t":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1},"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}}},"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":3.3166247903554}},"df":6,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":3}}}}}},"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"m":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":4},"p":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1}}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"x":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":3.1622776601683795}},"df":1}}}}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}}}},"v":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"y":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}}}}}},"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":1}}}}},"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":2}}},"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}}}},"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":4}}}},"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}}},"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":5,"k":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1},"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":2},"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}}},"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"t":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.4142135623730951}},"df":1}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"q":{"docs":{},"df":0,"u":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}}},"r":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.23606797749979},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.8284271247461903}},"df":7}},"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}},"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/privacy/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":5,"u":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":2}}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"p":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.4142135623730951},"https://blog.haskell.org/privacy/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":5}}},"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":1}}},"i":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"p":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":1}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2},"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"w":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3,"n":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"f":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"g":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}},"m":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1},"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}},"p":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2,"f":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}},"u":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}}},"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}},"g":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":6}}},"t":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2},"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}},"z":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":6.082762530298219}},"df":1}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178}},"df":1}}}},"m":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}},"r":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}}}}},"o":{"docs":{},"df":0,"f":{"docs":{},"df":0,"t":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}}},"l":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.4142135623730951}},"df":1},"u":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3}},"v":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"t":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":3},"i":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}}},"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.7320508075688772},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":4}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.4142135623730951},"https://blog.haskell.org/intro/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":5}},"r":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":2,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}},"f":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":2,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}},"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}}}}},"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}},"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}}}}}}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}}}}},"q":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}},"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.6457513110645907},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":2}},"c":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3,".":{"docs":{},"df":0,"y":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}},"a":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3}}}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1},"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.4142135623730951}},"df":1}}},"u":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}},"d":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}},"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}},"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"p":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}},"g":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":2}}},"o":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":2},"r":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/privacy/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":4}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1,"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.23606797749979},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.0}},"df":2}},"p":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}},"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1}}}}}},"u":{"docs":{},"df":0,"f":{"docs":{},"df":0,"f":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}},"y":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"b":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1,"j":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":2.23606797749979}},"df":1}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}},"c":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}}}}}},"h":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":5}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}}}},"g":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}},"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.7320508075688772}},"df":2}}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}}},"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.23606797749979},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":2.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":4.242640687119285},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.23606797749979}},"df":7}},"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}}},"r":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":4},"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}}}},"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}},"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}}},"y":{"docs":{},"df":0,"l":{"docs":{},"df":0,"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}}}},"m":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}},"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"x":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772}},"df":1,".":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}},"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1}},"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1}}}},"g":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1},"h":{"docs":{},"df":0,"a":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}},"k":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.6457513110645907},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":5}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}}},"s":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2}},"x":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/about/":{"tf":2.8284271247461903},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.4142135623730951},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":7}},"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3},"q":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":3}}},"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}}}},"l":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}},"r":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":2,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":4,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}},"x":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":4}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}},"t":{"docs":{},"df":0,"'":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}},"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951}},"df":1}}}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"'":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"y":{"docs":{},"df":0,"'":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"’":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":5,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":1}}}}},"k":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/privacy/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":4}}},"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.23606797749979}},"df":2}},"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0}},"df":2}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}},"e":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.1622776601683795}},"df":3,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}},"u":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.4142135623730951},"https://blog.haskell.org/intro/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":4.123105625617661},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":8}}},"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":3}}}},"o":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":2.449489742783178},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.7320508075688772},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.1622776601683795}},"df":4,"k":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"p":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":1,"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772}},"df":1}}},"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"k":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}},"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}},"e":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}},"i":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3,"g":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2}}}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}}},"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2}}}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3}},"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.0}},"df":1}}}}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}},"o":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2}},"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.449489742783178},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":3,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":2}}}}},"u":{"docs":{},"df":0,"b":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}},"g":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"f":{"docs":{},"df":0,"y":{"docs":{},"df":0,"j":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1},"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}},"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}},"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.449489742783178},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}}}}}},"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}}}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.605551275463989}},"df":1}}},"f":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}}}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}},"u":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}},"w":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}},"p":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":2.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":3,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2}}},"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"s":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":2.23606797749979},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/privacy/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":5.744562646538029},"https://blog.haskell.org/the-haskell-playground/":{"tf":4.123105625617661}},"df":7,"a":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1,"g":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1}},"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":3.3166247903554},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.8284271247461903}},"df":4,"'":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}},"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}},"t":{"docs":{},"df":0,"f":{"docs":{},"df":0,"8":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}},"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}}},"v":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1,"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"1":{"docs":{},"df":0,"4":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"a":{"docs":{},"df":0,"g":{"docs":{},"df":0,"u":{"docs":{},"df":0,"e":{"docs":{},"df":0,"&":{"docs":{},"df":0,"n":{"docs":{},"df":0,"b":{"docs":{},"df":0,"s":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}}}},"l":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.449489742783178}},"df":3,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1}}},"o":{"docs":{},"df":0,"u":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":2}}}}},"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":1}}}},"r":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.6457513110645907}},"df":3},"s":{"docs":{},"df":0,"a":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.7320508075688772},"https://blog.haskell.org/the-haskell-playground/":{"tf":3.4641016151377544}},"df":3}}}}}},"i":{"docs":{},"df":0,"a":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.0}},"df":2},"c":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"e":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"=":{"docs":{},"df":0,"v":{"docs":{},"df":0,"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.449489742783178}},"df":1}}}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}},"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":2}},"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.23606797749979}},"df":3}},"r":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"y":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.1622776601683795},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.8284271247461903}},"df":4}},"e":{"docs":{},"df":0,"'":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1},"l":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"a":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"b":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.1622776601683795},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.7320508075688772}},"df":4,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1}}}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":3}}}},"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0}},"df":3}}},"l":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.0}},"df":3}},"’":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1},"l":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}},"r":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}}},"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979}},"df":1}},"s":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}},"’":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1,"r":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1},"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}},"l":{"docs":{},"df":0,"d":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951}},"df":1}}}},"s":{"docs":{},"df":0,"h":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":2}},"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":4}}}}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1},"k":{"docs":{"https://blog.haskell.org/about/":{"tf":1.4142135623730951},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/intro/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":3.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":2.0}},"df":8,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":2.8284271247461903}},"df":1}},"f":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.8284271247461903}},"df":2}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":2.8284271247461903},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.4142135623730951},"https://blog.haskell.org/gsoc-2024/":{"tf":1.7320508075688772},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":2.23606797749979},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":5},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":2}}}}},"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}},"w":{"docs":{},"df":0,"w":{"docs":{},"df":0,".":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,".":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}},"x":{"docs":{},"df":0,"8":{"docs":{},"df":0,"6":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}},"y":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.4142135623730951}},"df":1}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"'":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1},"r":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1},"v":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.4142135623730951}},"df":1}},"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.4142135623730951},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2}}}}},"’":{"docs":{},"df":0,"v":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}}}},"description":{"root":{"docs":{},"df":0,"2":{"docs":{},"df":0,"0":{"docs":{},"df":0,"2":{"docs":{},"df":0,"4":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":2}}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"1":{"docs":{},"df":0,"4":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"9":{"docs":{},"df":0,".":{"docs":{},"df":0,"1":{"docs":{},"df":0,"2":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"a":{"docs":{},"df":0,"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1}}}}}},"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}}}},"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":2}}}},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}}}}}},"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}}}}},"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}}}}},"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"g":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2,"l":{"docs":{},"df":0,".":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}}}}}}}}},"j":{"docs":{},"df":0,"a":{"docs":{},"df":0,"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}}},"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"f":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1}}}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{},"df":0,"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}}}},"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.7320508075688772}},"df":1}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.4142135623730951}},"df":1}}}}}},"u":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}}}}},"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}}},"u":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}}},"title":{"root":{"docs":{},"df":0,"2":{"docs":{},"df":0,"0":{"docs":{},"df":0,"2":{"docs":{},"df":0,"4":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0},"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":2}}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"1":{"docs":{},"df":0,"4":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"9":{"docs":{},"df":0,".":{"docs":{},"df":0,"1":{"docs":{},"df":0,"2":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/about/":{"tf":1.0}},"df":1}}}},"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":2}}}},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0},"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":2}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}}}}}},"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}}}}},"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}}}}},"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"g":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0},"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":2,"l":{"docs":{},"df":0,".":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}}}}}}}}},"j":{"docs":{},"df":0,"a":{"docs":{},"df":0,"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}}}}},"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"f":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{},"df":0,"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://blog.haskell.org/the-haskell-playground/":{"tf":1.0}},"df":1}}}}}}}}},"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://blog.haskell.org/documentation-best-practices-in-2024/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://blog.haskell.org/privacy/":{"tf":1.0}},"df":1}}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"tf":1.0}},"df":1}}}},"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/report-of-js-code-minification/":{"tf":1.0}},"df":1}}}}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"tf":1.0}},"df":1}}}}}},"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}}},"u":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://blog.haskell.org/intro/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://blog.haskell.org/gsoc-2024/":{"tf":1.0}},"df":1}}}}}}},"documentStore":{"save":true,"docs":{"https://blog.haskell.org/":{"body":"","description":"","id":"https://blog.haskell.org/","title":""},"https://blog.haskell.org/about/":{"body":"About this blog\nWelcome to the Haskell Project's blog!\nThis is the place where the core teams that power the language and its ecosystem communicate about their progress, innovations,\nand new releases. These teams are:\n\nThe GHC Team and the GHC Steering Committee\nThe Cabal Team\nThe Haddock Team\nThe Core Libraries Committee\nThe Haskell Cryptography Group\nThe Haskell Language Server Team\nThe Stack Team and Stackage Curators\nThe Haskell.org Committee\nThe Stability Working Group\nThe Technical Working Group\nThe Security Response Team\nThe Haskell Interlude Podcast\n\nThe Haskell.org Committee is the publisher of this website. Please contact us at committee <at> haskell <dot> org if you wish to\nsignal content that goes against our Guidelines For Respectful Communication.\n","description":"","id":"https://blog.haskell.org/about/","title":"About this blog"},"https://blog.haskell.org/archive/":{"body":"","description":"","id":"https://blog.haskell.org/archive/","title":""},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"body":"In the Haddock team, part of our mission is to help with writing documentation, and promoting best practices. This article will help you write the best documentation you can!\n\nWe adapt documentation outside practices to our ecosystem, and leverage our own technologies to empower Haskell users with their documentation work.\nLet us see some of these techniques, and how the Haddock team can be of help.\nWriting documentation for your software project\nJustify yourself\nWhen you create software, there is a pipeline from your brain straight to your code. Your decisions — such as the libraries you’ve used,\nor your program architecture — shape how your code is structured and written.\nUnfortunately, simply writing the code isn’t enough.The reasoning behind the decisions you made is as important as the decisions themselves. In the short term, solving a problem may let you move ahead immediately, but what keeps you on the correct path is understanding what\nbrought you to that solution.\nIndeed, your choices may not be as popular as you think they are! Of course, you decided on them because you already convinced yourself\nthat they’re best. But you have a user base to convince as well, and they may not see things the same way you do.\nAs such, it is vitally important to document which decisions you made and to justify why you made them. If it’s not immediately obvious\nwhy a behaviour or a pattern exists, future maintainers might be tempted to drop it — only to discover too late why it was needed.\nThe reference flow of documentation\nNot all types of documentation have the same life cycle. Different pieces of documentation are more or less stable, and this determines\nwhich can act as a conceptual and theoretical foundation for your project.\nStable documentation\n\nA README without code\nA vision statement\nThe value proposition and the core domain\n\nThese ought not to change much, because they describe the basic problems that your code aims to address, solve or support in the long run.\nWhile it is normal to fiddle around with the boundaries of your project at the beginning, in general these should change infrequently.\nVolatile documentation\n\nDocumentation generated at runtime\nCode examples\nTests\nConfiguration\n\nThese are expected to change frequently, as your project changes, your API evolves, and you change configuration options.\nVolatile documentation is expensive to maintain, but also very valuable, as it shows in a concrete way how the user can interact with\nyour project.\n\n“When you refer to something, make sure the direction of the reference is from the more volatile to the more stable elements”\n-- Cyrille Martraire, Living Documentation, 2019\n\nDocumentation cascade\nHere is a simplified model of the documentation cascade for a typical Haskell project, from the most volatile to the most stable\nsources:\n\nCode for this diagram\n\n\nThis can be read as:\n\nThe Haddocks of your library or a third-party library have a dependency on the official specs for the domain, on an architecture document,\nand on haddocks from the core libraries (base, text, containers, etc.).\nThe haddocks of these core libraries depend on the GHC manual, official specs for their own domain, and papers.\n\nKeep in mind that while the Haddocks of a project can refer to the project specs, or to an architecture document, these documents should\nnever refer to the project's current implementation. If you must refer to the code, point to where it's located.\nThe (current, volatile) code cannot be the justification for the (planned, stable) architecture.\nThe GHC manual is much more stable than the haddocks of a Core library, which is why documentation should flow from\nthe library to the manual.\nFinally, papers serve the same purpose as architecture documents, where they describe techniques that may be implemented,\nbut they should not point to code that is subject to change – lest they point to a library that has evolved so much\nthat it no longer relates to the paper.\nExample: The Set data structure\nThe Haddocks for the Set datatype\n(from the containers library) are an example of documentation which follows this model well:\n\nThey point to an overview of the API (here: volatile)\nThey refer to the papers that have informed the design of its implementation (stable)\n\nUnderstand for whom you write\n\n\n-- Diátaxis Framework, by Daniele Procida, diataxis.fr\n\nIt is of utmost importance that documentation answers the needs of the users, and for that we must understand these needs.\nUsers need specific kinds of documentation depending on the situation they are in.\nThe above quadrant is the Diátaxis Framework, which maps out the entire life cycle of one’s interaction with a system, a program or a library.\nIt defines four types of documentation where each are a combination of Acquisition or Application, and Action or Cognition.\nTutorials\nIf a new user in need of actively acquiring some practice with the project, they can safely be pointed to the \"Tutorials\" part\nof your documentation: it is the part that focuses on \"Acquisition\" of knowledge through \"Action\".\nThe focus of the tutorial is to make a prospective user acquire basic competence in handling the software: It is an ice-breaker.\nHow-to Guides\nSomeone who needs to perform a task that new to them, but well-known to their group or organisation, will be best served by \"How-to Guides\",\nwhich helps a user get something done in a safe and correct manner. As opposed to Tutorials, How-to Guides are directions that take into account the complexity of the environment\nsurrounding the the user and the action, instead of providing a single path from point A to point B.\nExplanations\nHowever someone who is in need of a deeper – but perhaps less immediately applicable understanding of the project –\nwill be better served by the \"Explanation\", which serves the need for thought (or Cognition)\nExplanations bring historical and technical context to the current state of affairs.\nReference\nFinally, a \"Reference\" is a description of the interfaces and mechanisms of the software.\nIt aims to provide factual informations that is authoritative, with no space for doubt or ambiguity or design questions.\nThe best way to obtain reference is to make the system aware of its inner workings, and have it spit the reference from its own code.\nThrough the lens of Diátaxis, the module API documentation produced by Haddock is a Reference.\nThe OpenAPI standard for documenting REST APIs is also a Reference, although some less fortunate systems find themselves\nwith no ability to understand their own mechanisms, and thus must rely on manually-written specifications.\nIn Haskell, packages like openapi3 help with rendering an OpenAPI specification,\nwhereas companion libraries for web servers like servant-openapi3\nprovide you with a way of declaring REST APIs that can be rendered, even at run-time.\nDo Not Write The One Documentation\nIt is not just about filling out all the quadrants like a checklist (although they are all good to have!).\nInstead, it is about understanding how each section focuses on a particular combination of user needs and situations.\nThe message of Diátaxis is that you are not meant to write The One Documentation that covers everything —\ninevitably, this produces documentation which is shallow due to its breadth. Instead, focus on the strategic aspects of your documentation,\nand you will produce documentation of better quality, with a clear purpose that it can fulfill more easily.\nReach Out\nShould you need any help in writing or proof-reading documentation, please stop by the Matrix chatroom of the Haddock team,\nor ping us with the @haddock group tag on the\nHaskell Gitlab. We would be more than happy to lend you a hand and discuss how to best serve your users,\nyou included.\nRead More\n\nHaddock manual\nThe theory behind Diátaxis\nHow to contribute to Haddock\n\n","description":"","id":"https://blog.haskell.org/documentation-best-practices-in-2024/","title":"Documentation Best Practices in 2024"},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"body":"To conclude the year 2024, the GHC and Cabal teams are happy to announce the releases of GHC 9.12 and cabal 3.14.\n\nHere are some highlights:\nGHC 9.12\nLanguage Extensions\nThis release brings many new and exciting extensions:\n\nMultiline string literals to write string literals with newlines kept verbatim,\nenabling multiline strings without the need for string gaps and literal \\n characters\";\nOr-Patterns, allowing you to match on several patterns in a single case branch:\n\n\n\nNamedDefaults allows you to create type defaulting declarations for literals other than for the Num class. This mechanism is used to make sure that in the expression print (6 + 7), the multiplication gets a concrete type like Integer, Int or Double, instead of the vague Num a => a.\nYou can now apply this mechanism to other typeclasses, like:\n\n\nWhich means that in a module with OverloadedStrings, string literals \"like this\" will default to Text\ninstead of triggering an error about a polymorphic type.\nBase Library\n\nImprovements to backtraces and exceptions. Lots of them.\n\n⚠️ Deprecations\n\nThe deprecation cycle of GHC.Pack has reached its conclusion and the module has been removed.\nGHC.Desugar will be removed in GHC 9.14.\n\nCode Generation\n\nExperimental support for the RISC-V Platform;\nSIMD! In the x86: Most floating-point operations and some integer vector operations are supported 128-bit vectors without LLVM. Get in touch to help with this effort\nYou can try the new experimental -fobject-determinism flag to enable deterministic object code generation.\n\n⚠️ Deprecations\n\nSupport 32-bit Windows & macOS/iOS has been dropped;\nAs a result, the stdcall calling convention for FFI has been dropped, ccall should be used instead.\n\nYou can read the full release notes here.\nCabal 3.14\nNew things\n\n\n(Spec v3.14 only) New field: extra-files allows you to bundle files in the source distribution (sdist) of your cabal package. It serves as an alternative when the files you want to bundle do not fit in the existing data-files (for runtime data), extra-source-files (built by cabal) or extra-doc-files (shipped with Haddocks). This field has no inherent meaning, to avoid misuse of the already existing fields. For instance, you can use extra-files to ship stack.yaml files, which are not used either by the program at run-time, nor by Cabal or Haddock.\n\n\nYou can now compile projects dynamically with profiling enabled. The following options are now available:\n\ncabal.project: profiling-shared: <Boolean>;\ncabal file: ghc-prof-shared-options for passing options when building in profiling dynamic way;\nCommand-line arguments: --enable-profiling --enable-executable-dynamic.\n\n\n\nNew GHC options and extensions are supported.\n\n\nNew build type: Hooks. This build type, intended to eventually replace the Custom build type, integrates better with the rest of the ecosystem (cabal-install, Haskell Language Server).\n\n\nThe experimental haddock-project command supports sub-components.\n\n\nChanged\n\n\ncabal init remembers the chosen language within current session (Haskell2010, GHC2021, etc.).\n\n\ncabal check will raise an error about the insecure git:// protocol in source-repository.\n\n\nEnable recompilation avoidance during Haddock generation.\n\n\nClarify error message when pkg-config is not found.\n\n\nPrint out which project file(s) we are using.\n\n\nFixed\n\n\nThe --promised-dependency flag now accepts the version of a package in the package name. Previously you could only call it with an argument like void=void-0.5.8.\nNow, it is possible to write: --promised-dependency=void-0.5.8=void-0.5.8.\n\n\nAlways pass ghc-options to GHC.\n\n\nEnhance error detection for cabal root project files, including broken symlinks.\n\n\nDon't pass --coverage-for for non-dependency libs of a testsuite.\n\n\nFix a bug that causes cabal init to crash if git is not installed.\n\n\nUnresolved\n\nRecompilation avoidance during Haddock generation sometimes does not work on Windows (haskell/cabal#9177).\n\nYou can see the full changelogs for Cabal & Cabal-syntax, and for cabal-install and cabal-install-solver\nAs always, the Cabal team is always welcoming of new contributors. We have a nice back catalogue of bugs, oddities and feature requests. Stop by our matrix channel!\n","description":"","id":"https://blog.haskell.org/ghc-9-12-cabal-3-14/","title":"GHC 9.12 & Cabal 3.14 releases"},"https://blog.haskell.org/gsoc-2024/":{"body":"The Haskell.org committee is pleased to present the results of Haskell's\nparticipation in the Google Summer of Code 2024. This marks our 13th time\ntaking part in GSoC!\n\n\n\nOf the five projects alloted to our organization, four were successfully\ncompleted:\n\nHLS Cabal Plugin Continuation\nLSP Inlay Hints Feature for haskell-language-server\nContinuous Integration Log Explorer Tool\nParse Error Recovery and Incrementality for GHC\n\n\nCongratulations to all the contributors and a huge thank you to our wonderful mentors!\n\n\n\n\nHLS Cabal Plugin Continuation\nContributor: Georgii Gerasev\nMentor: Fendor\nFor this project Georgii implemented a number of additions and fixes for the\nHLS Cabal plugin, improving the developer experience around working with cabal\nfiles.\n\nFix an issue with completion for shorter file names\nAdd an outline view for cabal files\nIntegrate the Cabal-add tool as a code action\nAdd a go-to definition for modules from exposed-modules and other-modules sections\nAdd a hover with links to documentation for build-depends\n\nRead more in the project results write-up.\n\n\n\nLSP Inlay Hints Feature for haskell-language-server\nContributor: Jinser\nMentor: Michael Peyton Jones\nJinser contributed several features to HLS utilizing inlay hints, which grant\ndevelopers insights into certain code constructs.\n\nProvide explicit imports via inlay hints\nSupport inlay hints for record wildcards\n\n\n\n\nContinuous Integration Log Explorer Tool\nContributor: Abhinav Kumar\nMentor: Bryan Richter\nAbhinav's project was aimed at assisting developers in analyzing large CI test\nlogs, particularly for rare intermittent failures, by creating a web-based\ntool. This tool extends an existing service (Spuriobot) to collect CI log data\nand store it in a full-text search database. It also includes the\ndevelopment of an improved web UI, offering advanced search capabilities and\nautomatic log integration from GitHub workflows.\nRead more in the project results write-up.\n\n\n\nParse Error Recovery and Incrementality for GHC\nContributor: Karim Taha\nMentor: Sebastian Graf\nKarim contributed an enhancement to the Happy parser generater, namely an\nerror recovery mechanism. GHC's parser was then extended to make use of this\nnew feature. This will allow GHC to report multiple parse errors from a single\ncompilation run and in turn improve how parse errors are presented in tooling\nsuch as HLS.\nRead more in the project results write-up.\n","description":"","id":"https://blog.haskell.org/gsoc-2024/","title":"Google Summer of Code 2024 Wrap-up"},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"body":"The members of the Haskell.org Committee (the Committee) and the directors of the Haskell Foundation (the Foundation) are pleased to announce that we have joined forces, with the aim (subject to regulatory approval) of merging Haskell.org, Inc. and Haskell Foundation, Inc. into a single not-for-profit corporation. Together we continue our common mission to advance functional programming and to advocate for the Haskell language, its ecosystem, and its community.\nThe Committee\nThe Committee has a long history of supporting the Haskell community and ecosystem, supervising the resources under the \"haskell.org\" domain, including the www.haskell.org website, Hackage, Discourse, and the Haskell mailing lists, as well as organizing events such as Haskell.org’s participation in Google Summer of Code and the Haskell Summer of Code.\nThe Foundation\nThe Foundation is a newer organization, dedicated to broadening the adoption of Haskell by supporting its ecosystem of tools, libraries, education, and research. It has had similar goals to Haskell.org, and been engaged in complementary activities. Amongst its activities, it facilitates cross-team collaboration on fundamental tooling (e.g. Cabal, Stack, GHCup and the Haskell Language Server), hosts Stackage, financially supports the development of essential ecosystem components (e.g. the GHCup project and Botan bindings), runs workshops that help new contributors to fundamental tooling, and actively seeks financial sponsorship to help fund these efforts.\nBoth corporations are Not-for-Profit corporations and Haskell.org Inc. has also been recognised as exempt from taxation in the USA. For that reason, most of the transactions of the Foundation are conducted by Haskell.org, Inc. One of the biggest factors in the desire to merge corporate entities is to make it easier to manage the legal and financial responsibilities around non-profit status and holding funds. Having only one corporation would also address a source of confusion for donors and sponsors.\nWhat Next?\nThe Committee will continue to serve the community as an important committee of the Foundation. The Committee will retain all its current responsibilities, including independent editorial control of the Haskell.org website. It will also continue to oversee much of the Haskell community infrastructure and manage Haskell's participation in Google Summer of Code.\nJoining forces allows us to better share resources and work together while at the same time allowing the Committee (as part of the Foundation) to retain its independence over its domain.\nThe Committee members and the directors of the Foundation remain deeply grateful for the opportunity to serve the Haskell community. We look forward to continuing this support with greater effectiveness and efficiency as a single unified organization.\nSincerely,\nThe Haskell.org Committee and The Haskell Foundation\n","description":"","id":"https://blog.haskell.org/haskell-foundation-and-committee-merger/","title":"Haskell.org and the Haskell Foundation Join Forces"},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"body":"The Cabal Manual now has a guide on how to collect performance statistics of Haskell applications.\n\nThis guide was very generously contributed by Malte Neuss. It describes the various options you can set in your cabal.project file in order to get a time or space profile of your application.\nProject Configuration Guide\nIt is the recommended entry point for newcomers into the world of Haskell performance analysis.\nAs you progress through it, you will be pointed to other resources like the Profiling section of the GHC Users Guide\nand the Haskell Optimization Handbook, which present you with more in-depth techniques and configuration options.\nMoreover, you will be shown how to produce time and space profiles that can be rendered and analysed with third-party tools like Speedscope.\n\nYou can read it there: https://cabal.readthedocs.io/en/latest/how-to-enable-profiling.html.\nContribute to the documentation\nThe manual follows the documentation best practices of the Haddock team,\nand the Cabal team is eager to receive more contributions to improve the life of our users.\nDo not hesitate to open a pull request at https://github.com/haskell/cabal.\nCheers!\n","description":"","id":"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/","title":"How to collect performance statistics with Cabal"},"https://blog.haskell.org/intro/":{"body":"The Haskell Ecosystem plays host to some amazing projects. Talented developers spend significant amounts of time, often their free time, helping develop, maintain, and support this ecosystem that all Haskell developers use. This space is for all of the developer teams that work on Haskell core infrastructure and power the Haskell Ecosystem.\nThis blog will provide a space for these efforts to communicate with the wider Haskell community. Things you might see here: calls for volunteers, project updates, requests for comments/feedback.\nBlogs also form a key part of an ecosystem’s documentation. We’d like to take this idea to its conclusion in the Haskell ecosystem and provide a place for this high-value documentation to live and be maintained. In addition to helping out with editing, by hosting the posts here we’ll also have shared responsibility for maintaining the blog posts, helping prevent the all-too-common bit-rot that occurs on blog posts.\nThere are already a few posts to get the ball rolling. We’re really excited to share these thoughts with you all.\nHappy Hacking,\nJosé Manuel Calderón Trilla\n","description":"","id":"https://blog.haskell.org/intro/","title":"Welcome"},"https://blog.haskell.org/pages/":{"body":"","description":"","id":"https://blog.haskell.org/pages/","title":""},"https://blog.haskell.org/privacy/":{"body":"Privacy\n\nThis site does not set or use cookies.\nThis site does not store data in the browser to be shared, sent, or sold to third-parties.\nNo personal information is shared, sent, or sold to third-parties.\n\nEffective Date: 1st Jan 2022\n","description":"This page outlines the Privacy Policy for this site, and the date at which this policy was put into affect.","id":"https://blog.haskell.org/privacy/","title":"Privacy Policy"},"https://blog.haskell.org/report-of-js-code-minification/":{"body":"The JavaScript world has been battling for low bundle size from the very beginning.\nIt is now our turn to enter the battle\n\nDedicated to all front-end developers who doubt, but.\nIntro\nThe JavaScript backend in GHC has a long history of various challenges. One of the most notable is the transition from GHC 8.x to 9.x. Significant work has been done up to today by the GHC team, and progress is still ongoing. Besides the obvious need to make the GHC JavaScript backend functional in general, some specific issues have been raised regarding its use in production, one of them being the size of the produced JavaScript bundles.\nBundle size is an important consideration when commercial applications face challenges in delivering to end users. It is not surprising that consumers pay attention to software user experience. First impressions matter, and the time required for a fully functional interface to appear on the user's device is crucial.\nWeb applications are particularly sensitive to the duration before user interactions can begin. When you are loading a site or web application, you expect it to be fast. Bundle size is a primary target for loading time optimizations, due to the fact that, at this point, you have little control over what to offer the user while the progress bar is filling up.\nBundle Size Challenge\nThe JavaScript world has been battling for low bundle size from the very beginning. Various tactics have been developed up to today. Everyone who has participated in web development has heard words like minification, obfuscation, compression, and code elimination. Each of these terms opens a door to a wide array of tools whose configuration can take a long time and requires special experience: the resulting bundle should not only be lightweight but also functional.\nRoughly speaking, we can categorize all these tools and approaches into the following set of practical actions:\n\nCode rewrite. Simple approaches are known as minification. They are based on the fact that JavaScript supports pulling all code into a single line by removing whitespace. More intelligent approaches swap variable names for shorter ones. A side effect of this is that it makes reading such code harder, which in itself is a practice known as obfuscation. Even more advanced tools support unused (dead) code detection, allowing it to be safely removed. How can this happen? Third-party libraries provide various functions, but a specific application uses only a subset of them. The most advanced tools take things a step further: they can detect some code that can be rewritten in a more optimal form according to its actual use cases. For instance, if you use a constant variable, its value can be substituted directly in a call. In that case, the variable definition itself is not important and can be omitted, with its value used in place (inlined).\nEnvironment-dependent graceful degradation. The runtime environment can vary significantly due to different browsers and their versions. Sometimes you have control over the user's runtime environment, especially if the application is targeted at commercial clients. More often, your runtime environment is very diverse. Different environments impose different restrictions. Rich (and probably more modern) environments provide a large set of built-in features. The way you deliver your programs could depend on these features, as they can help build optimal bundles where your code does not have to implement low-level behaviors from scratch. Such code can have shortcuts for features where there is no need to include the full implementation, which would add more to the bundle. For example, internationalization (i18n) can be supported by some targets, so you do not need to add a full implementation in your code. This approach encourages modern user environments with faster load times, but for others, it makes things \"just work\" at the cost of bundle size. Web servers can detect browsers and their versions to select the best bundle size using the User-Agent header.\nNetwork-level compression. The simplest approach to reducing load time is to use good old compression, usually gzip compression. There is no need to deal with code optimizations. Most environments support it \"out of the box\" through the provided Content-Encoding header. It has its own weakness: the time to unpack the application on the client side. However, such a concern has become less important these days, thanks to modern CPUs—even on low-budget devices.\nDynamic bundle loading. This is the last but not least option when no other ways give you satisfactory results in the battle for short loading times. Usually, even large applications can be split into smaller parts that can be loaded as the user navigates through the interface. It is an old approach used on the Web: hypertext itself encourages this way of loading time optimization. Modern web applications can be designed to load their parts one by one if the tools used support partial loading.\n\nJavaScript ecosystem\nAs mentioned in the previous part, the modern JavaScript ecosystem provides battle-tested approaches to dealing with bundle size. The most notable ones that come to mind include:\n\nTerser, UglifyJS, and Google Closure Compiler. All of them provide methods to transform code into a minified form, ranging from trivial optimizations to more advanced techniques like dead code elimination.\nBabel for environment-related optimizations. Its primary purpose is to construct a set of \"polyfills\" that ensure uniform code execution across environments with different capabilities. Babel does not know a priori which capabilities an environment has, but it can be configured declaratively at build time to specify which features are expected to be present or not. One possible scenario for its usage in the task of bundle size reduction is to categorize possible environments into classes and prepare specific builds for each class. Bundle selection for delivery can be fulfilled by the static content server. For example, this can be implemented with the help of Nginx, where bundles can be associated with the incoming User-Agent header.\nWebpack (Parcel, Rollup) for bundle combining and splitting. The modern JavaScript environment has support for code modularization, but this support is still far from perfect. Even if support becomes more widespread, bundling will probably remain important due to networking: loading one big file generally has fewer side effects on time than loading a set of files with the same total size. Bundlers come into play when your application consists of a large number of modules, which is a common case. Moreover, they add additional value to the application build pipeline: they provide a way to slice a large application into a few bundles that can be loaded dynamically. Such slicing can usually be configured declaratively.\nGzip, Deflate, and Brotli via Nginx through fallback on the Content-Encoding header value. Their usage is quite straightforward. It depends only on the selected delivery method. Usually, web servers and content delivery networks handle this task with the best available efforts, so it is very rare that any manual tweaking is needed.\n\nThe Haskell way\nLet us return to our primary topic and consider how the Haskell environment takes its own seat with the concepts described above.\nNetwork-level compression does not depend on how the JavaScript bundle is generated. It is the most accessible way to address the issue of large bundle sizes. We assume that it is enabled by default and, for measurement purposes, we assume that Gzip is used. So, even if the GHC JavaScript backend does not support anything from the list above related to code splitting or code optimizations, we can still improve user experience by reducing bundle loading time through the correct configuration of the delivery channel to use reliable old compression.\n\nSo, there are no troubles here ✅✅.\n\nDynamic bundle loading is a complex topic. The GHC JavaScript bundle does not support it natively. However, real-world JavaScript applications usually depend on other JavaScript libraries and modules. We assume that a Haskell application could depend on them: call their functions, return results to them, and be called from external JavaScript code. Currently, the GHC 9.x JavaScript backend lacks full support for FFI. It allows only functions as JavaScript imports. However, it is enough to construct the interface where JavaScript can call Haskell functions and vice versa. Thus, we cover two possible top-level architecture scenarios:\n\nHaskell is used to write modules that will be used by some top-level JavaScript code. Such JavaScript code could be used only for bootstrapping purposes actually. In that scenario, bundlers (i.e., Webpack) could consider Haskell code as an old-fashioned JavaScript module that operates through globally exported functions. By this assumption, we gain the full power of slicing our application with a bundler, but its atomic slice is limited to the whole JavaScript bundle from the GHC 9.x JavaScript backend because it is a kind of \"black box\" for the bundler. Thus, it allows you to write different parts of the application in different Haskell modules which could be loaded on-demand from the top-level JavaScript code. The main issue here is to write a correct rule for loading such an \"old-fashioned\" module. A Haskell module (when Emscripten is used) can contain some global variables which require lots of care from the bundler side to ensure they are loaded sequentially by time but safely \"shimmed\" for simultaneous usage in the global JavaScript namespace.\nHaskell is used to write a top-level module that is supposed to be a caller for dependent JavaScript modules. It is supposed that this way is primary for existing commercial frontend applications written in Haskell for the Web. That looks like a straightforward way to begin development but encourages limited benefits from existing JavaScript bundlers. They can be used only to prepare third-party libraries for external calls. The GHC 8.x/9.x JavaScript linker currently does not support dynamically loading dependent Haskell modules on-demand: it assumes that all Haskell code is present statically at the moment of application bootstrap.\n\n\nWell, this way of bundle size optimization is limited even if possible. Even if the first strategy is chosen, the process of keeping the bundle configuration correct throughout the development lifecycle will require deep knowledge and lots of patience. Not sure what is more, so 🤷♂️.\n\nAccommodation of this tactic will not be covered by the samples in this article, but it could be an interesting journey for developers who participate in large Haskell web frontend application support. If it finds a strong response from the community, it could be investigated further.\nEnvironment-dependent graceful degradation is related to the previously discussed topic. Such tools (i.e., Babel) in the JavaScript ecosystem tend to be used in conjunction with bundlers (i.e., Webpack), but some of them can be used standalone. Their practical purpose for Haskell applications lies in providing a stable environment with all modern features of ECMAScript implemented natively or through \"polyfills.\" Unfortunately, \"ponyfills\" cannot be used with Haskell frontend applications due to the lack of support for CommonJS/ESM modules in the GHC 8.x/9.x JavaScript backend linker. Fortunately, the GHC 8.x/9.x JavaScript backend generates a very simple JavaScript subset. GHC's JavaScript RTS library has been written with ES5 in mind, with minor inclusions of fat-arrow-style functions from ES6. The used ES-language features are broadly supported nowadays. So, if your code does not use third-party libraries in JavaScript (which is supposed to be a rare case for real-world commercial applications), the usage of tools like Babel does not seem necessary.\nOn the other hand, even a Hello World-like Haskell application comes with a rich set of built-in modules for everyday use. Some modules of i18n and bigint from built-in libraries could be swapped for ones from a stable environment. This could reduce the size of generated JavaScript bundles for modern environments where \"polyfills\" are not needed. For older environments, such \"polyfills\" could be incorporated through declarative Babel configuration.\nWe face two scenarios of graceful degradation tool usage for a Haskell web frontend application:\n\nThird-party JavaScript libraries may require them. There is a dash in the JavaScript world. Authors of popular and reliable libraries tend to use the most modern and fashionable ECMAScript features. This adds additional complexity for Haskell application distribution. Such libraries need to pass through tools like Babel before being added to the resulting bundle.\nThe Haskell application itself relies on built-in packages, which is fine in terms of reliable execution (one of Haskell's strong sides) but not so well with bundle size when the environment provides native or \"polyfilled\" implementations for basic functions to work with things like i18n and Bignum (BigInt).\n\n\nIn short, this way of optimization has little to do with the Haskell application itself for now. It can be integrated into the resulting bundle compilation to process third-party JavaScript dependencies ✅, but currently, GHC 9.x JavaScript does not support swapping functions from built-in packages with those provided by the environment ❌.\n\nExperiments with this tactic remain out of scope for the current attempt to bring some benefits. Here, the same action is relevant as for the previous one: strong response from the community could drive investigations into this field.\nCode rewrite is a common tactic for advanced bundle size optimizations. Besides using optimizing compilers like Google Closure Compiler, the GHC 8.x/9.x JavaScript backend offers features to deal with large bundle sizes. The overview of introduced improvements in this area will be covered in the next section of this article and measured. Also, it is important to keep the resulting bundle compatible with existing optimizing compilers (at least one of them) because it provides additional benefits for application developers.\nAlthough a long route still lies ahead, some steps have already come into play nowadays: optimizing compiler support has been fixed, Unicode dead code elimination improved, string representation optimized, and Unicode (again!) table size notably reduced. ✅ Let us see the details in the next section!\nPassed steps for great good\nBefore anything else, it's necessary to mention that the initial event that sparked this work was an offline discussion where the opinion was formed that even a 100kb total bundle size for a Haskell \"Hello World\" application is not achievable.\nWell, does it really matter? We will measure it with size-limit, which shows sizes and time to load on a bad connection.\nWe are going to begin from the latest master commit at the time of writing this article. Right on this commit, we will revert the added code optimizations:\n\n#24789 Reasoning on Unicode static data compression on the GHC side\n#24504 Eliminate dependency of \"Hello World\" on Read\n#24706 Port back more efficient packing of string data from GHCJS to GHC JavaScript backend\n\nThe order is important. They were added in reverse order, so applying reverts to related commits reconstructs the whole GHC state. We want to take the most modern (and buildable!) GHC state and see how the JavaScript bundle size is improved over these commits.\nAdditionally, it's important to note that there is one more significant issue:\n\n#24602 Google Closure Compiler hard errors\n\nIt is important, but it does not add optimizations to GHC itself. It only allows us to run the Google Closure Compiler over the resulting bundle, which we can turn on/off manually during the following steps. We will apply all measurements with and without it to track its necessity.\nOur building pipeline will be the following:\n\nBuild a sample Haskell program with GHC optimization option -O2.\nProcess all.js through Google Closure Compiler with --compilation_level ADVANCED_OPTIMIZATIONS.\nProcess all.js and all.min.js (result of the Google Closure Compiler) with size-limit.\n\nWe will measure the following:\n\nThe size of all.js after the GHC pass\nThe size of all.min.js after the Google Closure pass\nThe brotlied sizes of them both via size-limit\nThe running time via size-limit to estimate how hard it is for the browser to load on a low budget device. It uses estimo internally.\n\nLets do some initial measurements (when no improvements have been applied via the reverted commits on fresh master):\n\n\nWell, results are far from perfect. 10s to load.\nWarning for experienced researchers: We are not going to make reliable sigma-based measurements. Their purpose is only to demonstrate the direction of improvements.\nEfficient packing of string data #24706\nTo avoid saying the same things twice (you can follow the issue for details) we are going to disclose it in following samples:\n\nVS\n\nYou probably noticed that second sample is shorter than first. It was the point of the ticket. It decreases bundle size besides better readability.\nTo make it happen let us deal how string literals work in GHC. They become an int array in a memory address pointer which has type Addr# internally. But not only string literals are encoded in an int array (Addr#). GHC is smart enough to use same technique for all embedded stuff which can be represented as an int array with a pointer. It can be used for embedded files as well. For anything that can look like an int array.\nSo, we should detect somehow that Addr# is used for string literal representation. Fortunately we are dealing with ByteStrings.\nAccording to the best article about strings representation (The ultimate guide to Haskell Strings) in GHC, we know that a well-formed unicode string should meet the following requirements:\n\nIts content should be limited to UTF8 code points.\n\\0s are not allowed.\n\nPretty small change but how important?\nOur HelloWorld.hs:\n\nResult:\n\n\nWell, our bundle is becoming smaller in size but it remains expensive to load by a low budget device. Note how important it is to use Google Closure Compiler for production builds!\nWhat can be removed from the bundle? Unicode? #24504\nWhile sifting through the contents of app.js, the following was found:\n\nThat is a really long line of code! It takes 4,316,351 characters at the bundle. What is even more interesting that Google Closure Compiler was unable to eliminate it as a dead code. It sounded like for some reason as really needed by:\n\nIt was a challenge to prove that it was exactly needed by the application. A special toolkit was created for call graph analysis\nin JavaScript bundles. Its purpose is very simple: It takes the JavaScript AST, reconstructs actual function calls as STG and creates a visualization\nto be processed by a graph explorer (e.g. Gephi).\nWhen the graph file had been constructed, we only needed to find the shortest path between JavaScript main and h$ghczminternalZCGHCziInternalziUnicodeziCharziUnicodeDataziGeneralCategoryzilvl_1. That route was found!\n\n\nFig. 1. The whole route from main function to Unicode. It demonstrates how much nodes were connected and how. It begins from JavaScript main and ends at h$ghczminternalZCGHCziInternalziUnicodeziCharziUnicodeDataziGeneralCategoryzilvl_1. Total amount of conntected nodes is 30.\n\nThe most interesting node is h$ghczminternalZCGHCziInternalziUnicodezizdwisSpace. It means that isSpace was the only reason why whole Unicode table had been added to the bundle. And isSpace is used by read parser. So, when we call the read function, that dependency route is triggered to be included into result bundle.\nIt turned out that the root of this issue came from an older one. With the help of call graph tracing, it was possible to establish the actual reason and fix it! (Ben Gamari, thank you so much)\nMeasures:\n\n\n73.92 kB! Even more better! But wait.\nWhat if Unicode is actually needed by some programs? #24789\nAs you noted there, it does not require much effort to trigger the addition of the unicode table. A trivial reference to read is enough to pull back the whole table back into the bundle.\nThat victory is too fragile to be proud of given results. Lots of real applications have to use isSpace when dealing with text parsing and so on. We have to support this case but keep the bundle size low.\nLet us consider the following sample program:\n\nHere we are facing the issue again.\nThe variable h$ghczminternalZCGHCziInternalziUnicodeziCharziUnicodeDataziGeneralCategoryzilvl_1 stores information about the mapping of each Unicode character to its General Category. The number of characters in each category varies. Some categories contain significantly more characters than others. When characters are listed sequentially in memory, their order does not necessarily match the order of the categories. This creates a challenge: how to organize characters in memory so that the search for their categories is both fast and space-efficient.\nNot many ideas came at the beginning, so a broad discussion was required with GHC community to see what can be tried to solve this.\nAdditionally, removing Streamly from GHC sources was needed as well because this dependency didn't keep its API stable.\nPierre Le Marre came with ultimate solution for the problem with large Unicode table but it was considered too powerful to be applied right now, so, the time for shamochu will come next.\nSylvain Henry's approach, less performant in terms of size reduction gains, was deemed much easier to be implemented. The conclusion was to use the latter one because we needed something easier and without additional dependencies at the moment.\nThe main idea is to generate better lookup code which can be translated into switches:\n\nSylvain Henry's approach was enhanced with nested ifs (logarithmic search vs linear search) and makes estimation regarding the most appropriate chunk size (as he predicted in the origin message):\n\n\nFig. 2. Finding the best size of chunks by comparing all possible values against generated function size. It shows that 50 items is a good-enough value of chunks size.\n\nMeasures of applied changes:\n\n\nWell, sizes are looking near same after compression but take a look at Running time. It looks like new version of unicode code is easier to understand by simulated low budget device!\nIntermediate conclusions\nThis article shows that community work can yield results that beat the original opinion about \"completely unachievable 100kb\". We seen how 6.8M became 2.8M for uncompressed Haskell JavaScript bundle and how 181.55 kB became 96.3 kB for completely optimized, compressed production-ready JavaScript bundle of trivial Unicode-enabled Haskell JavaScript application.\nWhat is next? Besides adding various code optimizations it would be nice also to consider other options from the beginning:\n\nGive a try to slice Haskell applications in chunks, with Webpack dynamic loading as \"black box\".\nConsider adding to GHC JavaScript backend the ability to slice code in CJS/ESM modules.\nRewrite call graph visualization tool in Haskell and make its output compatible with webpack-bundle-analyzer.\nExtend GHC JavaScript backend Linker with a feature which would switch on/off built-in modules for environments where they can be already provided by platform.\n\nThanks!\nThanks for the long reading! It was a very interesting journey and the author hopes now it was for you too, dear reader! Let us meet together in contributing to GHC!\nThanks for people with whom I was much impressed to work (in alphabetical order):\n\nBen Gamari\nCheng Shao\nHécate Kleidukos\nJeffrey Young\nLuite Stegeman\nMatthew Craven\nMatthew Pickering\nPierre Le Marre\nRodrigo Mesquita\nSylvain Henry\n\nIt is a pleasure to work with all of you on the Glorious Glasgow Haskell Compiler! Special thanks for Jeffrey Young who opened a door for me first and invited to work on the GHC JavaScript Backend.\n","description":"","id":"https://blog.haskell.org/report-of-js-code-minification/","title":"JavaScript Code Minification Report"},"https://blog.haskell.org/the-haskell-playground/":{"body":"The playground (play.haskell.org) allows you to run single-file Haskell programs right from your browser, and share them with others.\nIn this post, I will introduce the playground and give some implementation details.\n\nBeing able to run small Haskell programs in a browser is useful if you want to share a snippet of Haskell code with someone in such a way that the recipient can easily read, modify and execute the code.\nAnother use-case for the playground is if you're on the go (for example at a functional programming conference!) and want to show off some Haskell to your friends.\nIf those friends are performance-minded, they might ask you what the code compiles to.\nFortunately, the playground can help there too!\nBy clicking the \"Core\" button in the playground, you can see the intermediate representation that GHC converts all Haskell code to, and where it performs most of its optimisations; it is a stripped-down version of Haskell where everything is explicit.\n(Among other things, every memory allocation is marked by a let expression in Core; this can be useful to diagnose performance issues.)\nIf you are courageous, you can even look at the native assembly that GHC generates (with the \"Asm\" button).\nThe playground is, of course, implemented in Haskell.\nThe underlying web server is Snap, which I like because it's not too heavy-weight (for a web server, that is), and doesn't get in your way much.\nOrigins\nThe roots of the playground are on IRC (Internet Relay Chat) — which does, indeed, still exist.\nMost of the general Haskell IRC activity is in #haskell on libera.chat.\nIRC is an old and simple protocol, and multi-line messages are not supported, so what do you do if you want to ask for help with a (multi-line) piece of code?\nYou put it on a pastebin and share the link.\nWhich pastebin?\nPeople were using all kinds, and some of the regulars in the channel were complaining 1. that some of those websites were annoying/slow, and 2. that beginners would often only upload half the code, no output, only paraphrase the compiler error, etc.\nThus the idea of a custom pastebin was born:\n\n<sm> also: a new paste bin customized/structured for #haskell to elicit more info ? eg cabal or yaml file, stack yaml file, command, output, platform..\n<tomsmeding> sm: building that pastebin service would be trivial, question is who’d host it\n<sm> trivial eh :)\n<sm> if you build it I’ll host it :)\n<tomsmeding> sure lol\n\nAnd so a pastebin was born (still need to chase them up on that offer).\nBut soon people were back asking for more stuff:\n\nSomehow, this also happened, and it has been running on a small virtual server since then.\nFor now, this is quite sufficient, but should server load increase in the future, we'll need to re-evaluate.\nImplementation\nWhen I wrote the playground, I was in an optimistic mood and prepared it for horizontal scaling to multiple compilation servers.\nFor now this functionality is essentially unused (there is just one worker), but it does mean that the implementation of the playground is modularised in two executables:\n\nThe web server (play-haskell-server in the repository), which serves the HTML frontend, stores saved snippets in a SQLite database, and accepts compilation/execution jobs from users.\nIt distributes these jobs among workers using a thread-pool-like thing, waits for them to complete, and passes the results back to the client.\nA worker (play-haskell-worker), which accepts compile/run jobs over the network and handles them on one of the cores of the machine it runs on.\nIt simply uses GHCs from GHCup, and (hopefully) knows how to properly sandbox the execution of user-submitted programs.\n\nBoth server and worker accept connections using HTTP, but that can be easily upgraded to HTTPS in the usual way: put a reverse proxy (such as Caddy or Nginx) in front of it and terminate TLS there.\n(Caddy has the bonus feature of having built-in support for requesting TLS certificates from Let's Encrypt, which makes this even easier.)\nLet's dive into two more technical aspects of the playground implementation: sandboxing and the build environment.\nSandboxing\nI already mentioned that the worker has to sandbox execution of submitted programs: since the primary functionality of the playground is literally \"please execute arbitrary code on my machine\", we had better make sure that we can do that safely!\nThe typical way to do sandboxing nowadays seems to be containers (e.g. using Docker), but those frameworks typically do much more than we need, and have the number of CVEs to match.\nSo instead, the playground takes the much safer (?) approach of a stack of three hacky shell scripts that successively:\n\nUse Linux user namespaces (using systemd-run) to set resource quotas: this limits CPU use (to a single CPU core), memory use, and the number of concurrent threads.\nUse Linux cgroups with bwrap (also used by Flatpak) to chroot to a Ubuntu distro and prevent access to disk, network, other processes, etc.\nRead-only access is provided to ~/.ghcup, because that's where the GHCs live.\nActually look at what the job is asking for, and do that.\n\nThis is convoluted, and it can surely be simplified (without reaching for bloated containerisation solutions).\nI just don't know how, so if you do, please reach out.\n(And if you'd like to try to break the sandboxing, I'll gladly help you set up the playground on your own machine so that you can test without spoiling the fun for others. ;) )\nThe build environment: making Haskell packages available\nHaving just the boot packages available would make for a rather bare playground (no System.Random, etc.), so we clearly need to provide something more.\nThe current policy for additional packages is \"if you can convince me that a package is useful and it doesn't unnecessarily bloat the dependency tree, I'll add it together with its transitive dependencies\".\nThis has happened multiple times already (e.g. 1, 2, 3).\nThis policy is admittedly completely subjective, but it's unclear if there is a real alternative.\nThe only \"principled\" option seems to be making all of Stackage available, but that is both unwieldy (there's too many packages in there so it takes a huge amount of disk space) and not always possible (the playground aims to support new GHCs immediately after release, and Stackage naturally lags behind).\nIn any case, we need some way of bringing additional Haskell packages in scope when compiling submitted programs.\nOne would naturally reach for cabal here; a possible design would be to have a Cabal project per GHC version and upon job submission replace its Main.hs with the submitted program, after which it is a matter of invoking cabal run.\nHowever, this design has some disadvantages:\n\nTo prevent interference when two jobs for the same GHC version arrive at a worker simultaneously (to be handled on separate cores), (number of GHCs) projects is not enough: we actually need (number of GHCs) * (number of cores) of them.\nThe playground not only supports running an executable, but also showing Core and assembly (also for non-Main modules).\nWhile we could modify the thing.cabal file together with Main.hs to make cabal do the right thing, it turns out that cabal takes quite a bit of time to reconfigure when the thing.cabal file changes.\nTo not make the user wait so long, we actually need (number of GHCs) * (number of cores) * (number of configurations (currently 3)) project directories!\nAnd if the playground is to support passing additional user-specified options to GHC in the future, then the number of configurations will explode.\nClearly this will not scale.\nFurthermore, even without needing to reconfigure the project, cabal still takes some time to update its own administration for every cabal run — time that is unnecessary because we know exactly what needs to happen: just run the same ghc command as before.\n\nPerhaps cabal could be improved on that last point, but even without that, there is enough reason for the playground to do something different.\nWhat happens instead is the following:\n\nI have one Cabal project directory per GHC version, containing a thing.cabal file defining an executable component that depends on all the packages to be made available.\nWhenever I add a new GHC version to the playground, or want to update package versions for an existing one, I cabal build that directory with the appropriate GHC version.\nThis yields a dist-newstyle/cache/plan.json that contains a wealth of information about the precise dependency tree, including the precise package IDs as found in the Cabal store in ~/.cabal/store.\n\nIt is important that this building happens in approximately (!) the same sandboxing setup as the one for the user-submitted jobs, so that paths to the cabal store etc. are the same in both situations.\nI say \"approximately\" here because cabal of course needs write access to ~/.cabal here, and the user does not.\n\n\nThese package IDs are collected and inserted in a generated shell script that invokes ghc in precisely the right way to bring those packages into scope.\nAs it turns out, ghc doesn't really mind getting Main or non-Main modules here; this means that e.g. Core mode simply appends -ddump-simpl -ddump-to-file to the arguments to ghc, and everything works fine.\n\nThere is thus one such generated shell script for each GHC version on the playground; these are what is actually run when a job is handled by a worker.\nThis way, the overhead is as low as possible: just ghc is invoked, and almost nothing else (apart from the sandboxing machinery).\nThe overhead from sandboxing is reduced to a minimum by starting a new sandbox immediately after the previous one exited, so that one should be already running (waiting for a program to compile) when the next job arrives.\nManual work\nThe awkward part of the current setup is that I need to manually prepare a consistent package list for each GHC version.\nI have some automation for that, but it would of course be nicer if the process of adding a new GHC version to the playground was automatic.\nThe trouble is that this is actually non-trivial.\nAs described above, there is a \"wish list\" of packages that we'd like to be available, but not all those packages build with all GHC versions — either because they haven't been updated for the latest GHC yet, or because they exist only for certain GHC versions by design (e.g. ghc-heap).\nIt is not obvious how to effectively determine a maximal subset of this wish list that builds together!\nBecause package dependency constraints need not be monotonic (e.g. package B may depend on A (>= 1 && < 3) || (>= 4 && < 6)), simply using the newest of each package on the wish list (or oldest, as some people seem to prefer) is not necessarily sufficient.\nThis is why the Cabal dependency solver is a thing.\nThe process of \"whittling down\" the wish list to something that does build together, guided by cabal dependency solving errors, is partially automated, but a comprehensive automated solution (that is nevertheless simple enough to maintain and not introduce a slew of robustness bugs of its own) would be nicer.\nIf you have ideas, please jump into the issue tracker and tell me!\nFuture\nThe playground receives a healthy amount of traffic, and it seems to be useful to people, but of course there is a lot that can still be improved.\nA number of ideas are already listed in the issues on the GitHub repository, but if you have an idea for an improvement that's not yet on the list — be it to the design, the user experience, or the implementation — or if you've found a bug and would like to report it, feel free to open an issue.\nIf you would like to work on the project yourself (and it's more than a one-line fix), please open an issue first; that way we can prevent extra or duplicate work on both sides.\nAs an example of a recently added feature, the GHC error output on the playground now links to the Haskell Error Index (for GHC >= 9.6).\n(If you get a GHC error, such as this one, click on the link, and find that it has not been explained yet in the Error Index, they're looking for contributors!)\nThanks to @MangoIV for suggesting this feature.\nIf you want to say hi, I often hang out in #haskell on libera.chat.\nHappy Haskelling!\n","description":"","id":"https://blog.haskell.org/the-haskell-playground/","title":"The Haskell Playground"}},"docInfo":{"https://blog.haskell.org/":{"body":0,"description":0,"title":0},"https://blog.haskell.org/about/":{"body":73,"description":0,"title":1},"https://blog.haskell.org/archive/":{"body":0,"description":0,"title":0},"https://blog.haskell.org/documentation-best-practices-in-2024/":{"body":657,"description":0,"title":4},"https://blog.haskell.org/ghc-9-12-cabal-3-14/":{"body":427,"description":0,"title":5},"https://blog.haskell.org/gsoc-2024/":{"body":265,"description":0,"title":6},"https://blog.haskell.org/haskell-foundation-and-committee-merger/":{"body":249,"description":0,"title":5},"https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/":{"body":95,"description":0,"title":4},"https://blog.haskell.org/intro/":{"body":105,"description":0,"title":1},"https://blog.haskell.org/pages/":{"body":0,"description":0,"title":0},"https://blog.haskell.org/privacy/":{"body":26,"description":9,"title":2},"https://blog.haskell.org/report-of-js-code-minification/":{"body":2274,"description":0,"title":4},"https://blog.haskell.org/the-haskell-playground/":{"body":1135,"description":0,"title":2}},"length":13},"lang":"English"}
\ No newline at end of file
diff --git a/site.webmanifest b/site.webmanifest
new file mode 100644
index 0000000..b20abb7
--- /dev/null
+++ b/site.webmanifest
@@ -0,0 +1,19 @@
+{
+ "name": "",
+ "short_name": "",
+ "icons": [
+ {
+ "src": "/android-chrome-192x192.png",
+ "sizes": "192x192",
+ "type": "image/png"
+ },
+ {
+ "src": "/android-chrome-512x512.png",
+ "sizes": "512x512",
+ "type": "image/png"
+ }
+ ],
+ "theme_color": "#ffffff",
+ "background_color": "#ffffff",
+ "display": "standalone"
+}
diff --git a/sitemap.xml b/sitemap.xml
new file mode 100644
index 0000000..22ee26e
--- /dev/null
+++ b/sitemap.xml
@@ -0,0 +1,128 @@
+
+
+
+ https://blog.haskell.org/
+
+
+ https://blog.haskell.org/about/
+
+
+ https://blog.haskell.org/archive/
+
+
+ https://blog.haskell.org/authors/
+
+
+ https://blog.haskell.org/authors/aaron-allen/
+
+
+ https://blog.haskell.org/authors/hecate/
+
+
+ https://blog.haskell.org/authors/jmct/
+
+
+ https://blog.haskell.org/authors/serge-s-gulin/
+
+
+ https://blog.haskell.org/authors/tom-smeding/
+
+
+ https://blog.haskell.org/categories/
+
+
+ https://blog.haskell.org/categories/cabal/
+
+
+ https://blog.haskell.org/categories/community/
+
+
+ https://blog.haskell.org/categories/ghc/
+
+
+ https://blog.haskell.org/categories/haddock/
+
+
+ https://blog.haskell.org/categories/haskell-foundation/
+
+
+ https://blog.haskell.org/categories/haskell-org/
+
+
+ https://blog.haskell.org/categories/playground/
+
+
+ https://blog.haskell.org/documentation-best-practices-in-2024/
+ 2024-09-15
+
+
+ https://blog.haskell.org/ghc-9-12-cabal-3-14/
+ 2024-12-22
+
+
+ https://blog.haskell.org/gsoc-2024/
+ 2024-11-21
+
+
+ https://blog.haskell.org/haskell-foundation-and-committee-merger/
+ 2024-09-25
+
+
+ https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/
+ 2024-12-23
+
+
+ https://blog.haskell.org/intro/
+ 2024-09-14
+
+
+ https://blog.haskell.org/page/1/
+
+
+ https://blog.haskell.org/privacy/
+
+
+ https://blog.haskell.org/report-of-js-code-minification/
+ 2024-09-15
+
+
+ https://blog.haskell.org/tags/
+
+
+ https://blog.haskell.org/tags/activities-report/
+
+
+ https://blog.haskell.org/tags/announcement/
+
+
+ https://blog.haskell.org/tags/community/
+
+
+ https://blog.haskell.org/tags/documentation/
+
+
+ https://blog.haskell.org/tags/gsoc/
+
+
+ https://blog.haskell.org/tags/javascript/
+
+
+ https://blog.haskell.org/tags/performance/
+
+
+ https://blog.haskell.org/tags/practices/
+
+
+ https://blog.haskell.org/tags/profiling/
+
+
+ https://blog.haskell.org/tags/release/
+
+
+ https://blog.haskell.org/tags/summer-of-code/
+
+
+ https://blog.haskell.org/the-haskell-playground/
+ 2024-09-15
+
+
diff --git a/sw.js b/sw.js
new file mode 100644
index 0000000..bd899cd
--- /dev/null
+++ b/sw.js
@@ -0,0 +1,191 @@
+class Pwa {
+
+ constructor(self) {
+ this.scope = self;
+ const Version = new URL(location).searchParams.get("v");
+ this.CACHE_VERSION = Version;
+ //this.BASE_CACHE_FILES=['/js/theme.min.js','/js/theme_light.min.js','/abridge.css','/js/abridge.min.js','/','/404.html','/offline/','/manifest.json'];
+ this.BASE_CACHE_FILES = ['/js/theme.min.js','/js/theme_light.min.js','/abridge.css','/js/abridge.min.js','/','/404.html','/offline/','/manifest.min.json'];
+ this.host = `${self.location.protocol}//${self.location.host}`;
+ console.info(`Host: ${this.host}`);
+ this.OFFLINE_PAGE = '/offline/';
+ this.NOT_FOUND_PAGE = '/404.html';
+ this.CACHE_NAME = `content-v${this.CACHE_VERSION}`;
+ // 3600=1hour, 28800=8hours, 86400=1day, 604800=1week, 1209600=2weeks
+ this.NORM_TTL = 0;
+ this.LONG_TTL = 0;
+ // keep the ttl on these lower:
+ this.TTL_NORM = ["sw.min.js", "sw_load.min.js"];
+ // rarely change, may be a good idea to periodically refresh, incase I change these and forget to increment service worker version:
+ this.TTL_LONG = ["jpg", "jpeg", "png", "gif", "webp", "avif", "ico", "svg", "xsl", "txt"];
+ // never change, cache forever unless service worker version is incremented:
+ this.TTL_EXEMPT = ["js", "css", "otf", "eot", "ttf", "woff", "woff2", "mp4", "webm", "mp3", "ogg"];
+ // skip these extensions so they expire same time as html: st,wasm,json(search), xml(sitemap,atom,rss)
+ }
+
+ canCache(url) {
+ if (url.startsWith("http://localhost")) {
+ return false;
+ }
+ const result = url.toString().startsWith(this.host);
+ return result;
+ }
+
+ getFileExtension(url) {
+ const extension = url.split('.').reverse()[0].split('?')[0];
+ return (extension.endsWith('/')) ? '/' : extension;
+ }
+ getFileName(url) {
+ const filename = url.substring(url.lastIndexOf('/') + 1).split('?')[0];
+ return (filename.endsWith('/')) ? '/' : filename;
+ }
+
+ getTTL(url) {
+ if (typeof url === 'string') {
+ const extension = this.getFileExtension(url);
+ const filename = this.getFileName(url);
+
+ if (this.TTL_NORM.indexOf(filename) > -1) {
+ console.info(url + ' contains a TTL_NORM filename');
+ return this.NORM_TTL;
+ }
+ if (this.TTL_LONG.indexOf(extension) > -1) {
+ console.info(url + ' contains a TTL_LONG extension');
+ return this.LONG_TTL;
+ }
+ if (this.TTL_EXEMPT.indexOf(extension) > -1) {
+ console.info(url + ' contains a TTL_EXEMPT extension');
+ return null;
+ }
+ console.info(url + ' TTL_NORM');
+ return this.NORM_TTL;
+ }
+ return null;
+ }
+
+ async installServiceWorker() {
+ try {
+ await caches.open(this.CACHE_NAME).then((cache) => {
+ return cache.addAll(this.BASE_CACHE_FILES);
+ }, err => console.error(`Error with ${this.CACHE_NAME}`, err));
+ return this.scope.skipWaiting();
+ }
+ catch (err) {
+ return console.error("Error with installation: ", err);
+ }
+ }
+
+ cleanupLegacyCache() {
+
+ const currentCaches = [this.CACHE_NAME];
+
+ return new Promise(
+ (resolve, reject) => {
+ caches.keys()
+ .then((keys) => keys.filter((key) => !~currentCaches.indexOf(key)))
+ .then((legacy) => {
+ if (legacy.length) {
+ Promise.all(legacy.map((legacyKey) => caches.delete(legacyKey))
+ ).then(() => resolve()).catch((err) => {
+ console.error("Error in legacy cleanup: ", err);
+ reject(err);
+ });
+ } else {
+ resolve();
+ }
+ }).catch((err) => {
+ console.error("Error in legacy cleanup: ", err);
+ reject(err);
+ });
+ });
+ }
+
+ async preCacheUrl(url) {
+ const cache = await caches.open(this.CACHE_NAME);
+ const response = await cache.match(url);
+ if (!response) {
+ return fetch(url).then(resp => cache.put(url, resp.clone()));
+ }
+ return null;
+ }
+
+ register() {
+ this.scope.addEventListener('install', event => {
+ event.waitUntil(
+ Promise.all([
+ this.installServiceWorker(),
+ this.scope.skipWaiting(),
+ ]));
+ console.info('SW Installed');
+ });
+
+ this.scope.addEventListener('activate', event => {
+ event.waitUntil(Promise.all(
+ [this.cleanupLegacyCache(),
+ this.scope.clients.claim(),
+ this.scope.skipWaiting()]).catch((err) => {
+ console.error("Activation error: ", err);
+ event.skipWaiting();
+ }));
+ });
+
+ this.scope.addEventListener('fetch', event => {
+ event.respondWith(
+ caches.open(this.CACHE_NAME).then(async cache => {
+ // check if this is NOT a resource we allow cacheing (some other domain), if so fetch it instead of cache.
+ if (!this.canCache(event.request.url)) {
+ return fetch(event.request);
+ }
+ // check the cache for the requested resource
+ const response = await cache.match(event.request);
+ if (response) {
+ const headers = response.headers.entries();
+ let date = null;
+ for (let pair of headers) {
+ if (pair[0] === 'date') {
+ date = new Date(pair[1]);
+ break;
+ }
+ }
+ // date is not working, so ignore TTL and just serve the cached resource.
+ if (!date) {
+ return response;
+ }
+ const age = parseInt(((new Date().getTime() - date.getTime()) / 1000).toString());
+ const ttl = this.getTTL(event.request.url);
+ if (ttl === null || (ttl && age < ttl)) {
+ // return the resource if it is not beyond the TTL
+ return response;
+ }
+ }
+ // if we made it here then we either did not have the cache, or the TTL was expired.
+ return fetch(event.request.clone()).then(resp => {
+ if (resp.status < 400) {
+ if (this.canCache(event.request.url)) {
+ cache.put(event.request, resp.clone());
+ }
+ return resp;
+ }
+ else {
+ return cache.match(this.NOT_FOUND_PAGE);
+ }
+ }).catch(err => {
+ // if we made it here then we were unable to fetch the resource.
+ // maybe we were only fetching because of expired TTL, so use the cache regardless of TTL:
+ if (typeof event.request.url === 'string') {
+ console.info("url: "+event.request.url)
+ }
+ if (response) {
+ return response;
+ }
+ // if we made it here then we were unable to fetch the resource and do not have it cached.
+ console.error(`Error fetching ${event.request.url} resulted in offline`, err);
+ return cache.match(this.OFFLINE_PAGE);
+ })
+ }));
+ });
+ }
+}
+
+const pwa = new Pwa(self);
+pwa.register();
diff --git a/sw.min.js b/sw.min.js
new file mode 100644
index 0000000..8812d76
--- /dev/null
+++ b/sw.min.js
@@ -0,0 +1 @@
+class Pwa{constructor(t){this.scope=t;var e=new URL(location).searchParams.get("v");this.CACHE_VERSION=e,this.BASE_CACHE_FILES=["/js/theme.min.js","/js/theme_light.min.js","/abridge.css","/js/abridge.min.js","/","/404.html","/offline/","/manifest.min.json"],this.host=t.location.protocol+"//"+t.location.host,this.OFFLINE_PAGE="/offline/",this.NOT_FOUND_PAGE="/404.html",this.CACHE_NAME="content-v"+this.CACHE_VERSION,this.NORM_TTL=0,this.LONG_TTL=0,this.TTL_NORM=["sw.min.js","sw_load.min.js"],this.TTL_LONG=["jpg","jpeg","png","gif","webp","avif","ico","svg","xsl","txt"],this.TTL_EXEMPT=["js","css","otf","eot","ttf","woff","woff2","mp4","webm","mp3","ogg"]}canCache(t){return!t.startsWith("http://localhost")&&t.toString().startsWith(this.host)}getFileExtension(t){t=t.split(".").reverse()[0].split("?")[0];return t.endsWith("/")?"/":t}getFileName(t){t=t.substring(1+t.lastIndexOf("/")).split("?")[0];return t.endsWith("/")?"/":t}getTTL(t){var e;return"string"==typeof t?(e=this.getFileExtension(t),t=this.getFileName(t),~this.TTL_NORM.indexOf(t)?this.NORM_TTL:~this.TTL_LONG.indexOf(e)?this.LONG_TTL:~this.TTL_EXEMPT.indexOf(e)?null:this.NORM_TTL):null}async installServiceWorker(){try{return await caches.open(this.CACHE_NAME).then(t=>t.addAll(this.BASE_CACHE_FILES),t=>{}),this.scope.skipWaiting()}catch(t){}}cleanupLegacyCache(){let i=[this.CACHE_NAME];return new Promise((e,s)=>{caches.keys().then(t=>t.filter(t=>!~i.indexOf(t))).then(t=>{t.length?Promise.all(t.map(t=>caches.delete(t))).then(()=>e()).catch(t=>{s(t)}):e()}).catch(t=>{s(t)})})}async preCacheUrl(e){let s=await caches.open(this.CACHE_NAME);return await s.match(e)?null:fetch(e).then(t=>s.put(e,t.clone()))}register(){this.scope.addEventListener("install",t=>{t.waitUntil(Promise.all([this.installServiceWorker(),this.scope.skipWaiting()]))}),this.scope.addEventListener("activate",e=>{e.waitUntil(Promise.all([this.cleanupLegacyCache(),this.scope.clients.claim(),this.scope.skipWaiting()]).catch(t=>{e.skipWaiting()}))}),this.scope.addEventListener("fetch",h=>{h.respondWith(caches.open(this.CACHE_NAME).then(async e=>{if(!this.canCache(h.request.url))return fetch(h.request);let s=await e.match(h.request);if(s){var i;let t=null;for(i of s.headers.entries())if("date"===i[0]){t=new Date(i[1]);break}if(!t)return s;var n=parseInt(""+((new Date).getTime()-t.getTime())/1e3),a=this.getTTL(h.request.url);if(null===a||a&&nt.status<400?(this.canCache(h.request.url)&&e.put(h.request,t.clone()),t):e.match(this.NOT_FOUND_PAGE)).catch(t=>(h.request.url,s||e.match(this.OFFLINE_PAGE)))}))})}}let pwa=new Pwa(self);pwa.register();
\ No newline at end of file
diff --git a/tags/activities-report/index.html b/tags/activities-report/index.html
new file mode 100644
index 0000000..d13d6ab
--- /dev/null
+++ b/tags/activities-report/index.html
@@ -0,0 +1,91 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ activities-report tag | The Haskell Programming Language's blog
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
The playground (play.haskell.org) allows you to run single-file Haskell programs right from your browser, and share them with others.
+In this post, I will introduce the playground and give some implementation details.
+
+
Being able to run small Haskell programs in a browser is useful if you want to share a snippet of Haskell code with someone in such a way that the recipient can easily read, modify and execute the code.
+Another use-case for the playground is if you're on the go (for example at a functional programming conference!) and want to show off some Haskell to your friends.
+
If those friends are performance-minded, they might ask you what the code compiles to.
+Fortunately, the playground can help there too!
+By clicking the "Core" button in the playground, you can see the intermediate representation that GHC converts all Haskell code to, and where it performs most of its optimisations; it is a stripped-down version of Haskell where everything is explicit.
+(Among other things, every memory allocation is marked by a let expression in Core; this can be useful to diagnose performance issues.)
+If you are courageous, you can even look at the native assembly that GHC generates (with the "Asm" button).
+
The playground is, of course, implemented in Haskell.
+The underlying web server is Snap, which I like because it's not too heavy-weight (for a web server, that is), and doesn't get in your way much.
+
Origins
+
The roots of the playground are on IRC (Internet Relay Chat) — which does, indeed, still exist.
+Most of the general Haskell IRC activity is in #haskell on libera.chat.
+IRC is an old and simple protocol, and multi-line messages are not supported, so what do you do if you want to ask for help with a (multi-line) piece of code?
+You put it on a pastebin and share the link.
+Which pastebin?
+
People were using all kinds, and some of the regulars in the channel were complaining 1. that some of those websites were annoying/slow, and 2. that beginners would often only upload half the code, no output, only paraphrase the compiler error, etc.
+Thus the idea of a custom pastebin was born:
+
+
<sm> also: a new paste bin customized/structured for #haskell to elicit more info ? eg cabal or yaml file, stack yaml file, command, output, platform..
+<tomsmeding> sm: building that pastebin service would be trivial, question is who’d host it
+<sm> trivial eh :)
+<sm> if you build it I’ll host it :)
+<tomsmeding> sure lol
+
+
And so a pastebin was born (still need to chase them up on that offer).
+But soon people were back asking for more stuff:
+
+
Somehow, this also happened, and it has been running on a small virtual server since then.
+For now, this is quite sufficient, but should server load increase in the future, we'll need to re-evaluate.
+
Implementation
+
When I wrote the playground, I was in an optimistic mood and prepared it for horizontal scaling to multiple compilation servers.
+For now this functionality is essentially unused (there is just one worker), but it does mean that the implementation of the playground is modularised in two executables:
+
+
The web server (play-haskell-server in the repository), which serves the HTML frontend, stores saved snippets in a SQLite database, and accepts compilation/execution jobs from users.
+It distributes these jobs among workers using a thread-pool-like thing, waits for them to complete, and passes the results back to the client.
+
A worker (play-haskell-worker), which accepts compile/run jobs over the network and handles them on one of the cores of the machine it runs on.
+It simply uses GHCs from GHCup, and (hopefully) knows how to properly sandbox the execution of user-submitted programs.
+
+
Both server and worker accept connections using HTTP, but that can be easily upgraded to HTTPS in the usual way: put a reverse proxy (such as Caddy or Nginx) in front of it and terminate TLS there.
+(Caddy has the bonus feature of having built-in support for requesting TLS certificates from Let's Encrypt, which makes this even easier.)
+
Let's dive into two more technical aspects of the playground implementation: sandboxing and the build environment.
+
Sandboxing
+
I already mentioned that the worker has to sandbox execution of submitted programs: since the primary functionality of the playground is literally "please execute arbitrary code on my machine", we had better make sure that we can do that safely!
+The typical way to do sandboxing nowadays seems to be containers (e.g. using Docker), but those frameworks typically do much more than we need, and have the number of CVEs to match.
+So instead, the playground takes the much safer (?) approach of a stack of three hacky shell scripts that successively:
+
+
Use Linux user namespaces (using systemd-run) to set resource quotas: this limits CPU use (to a single CPU core), memory use, and the number of concurrent threads.
+
Use Linux cgroups with bwrap (also used by Flatpak) to chroot to a Ubuntu distro and prevent access to disk, network, other processes, etc.
+Read-only access is provided to ~/.ghcup, because that's where the GHCs live.
+
Actually look at what the job is asking for, and do that.
+
+
This is convoluted, and it can surely be simplified (without reaching for bloated containerisation solutions).
+I just don't know how, so if you do, please reach out.
+(And if you'd like to try to break the sandboxing, I'll gladly help you set up the playground on your own machine so that you can test without spoiling the fun for others. ;) )
+
The build environment: making Haskell packages available
+
Having just the boot packages available would make for a rather bare playground (no System.Random, etc.), so we clearly need to provide something more.
+The current policy for additional packages is "if you can convince me that a package is useful and it doesn't unnecessarily bloat the dependency tree, I'll add it together with its transitive dependencies".
+This has happened multiple times already (e.g. 1, 2, 3).
+This policy is admittedly completely subjective, but it's unclear if there is a real alternative.
+The only "principled" option seems to be making all of Stackage available, but that is both unwieldy (there's too many packages in there so it takes a huge amount of disk space) and not always possible (the playground aims to support new GHCs immediately after release, and Stackage naturally lags behind).
+
In any case, we need some way of bringing additional Haskell packages in scope when compiling submitted programs.
+One would naturally reach for cabal here; a possible design would be to have a Cabal project per GHC version and upon job submission replace its Main.hs with the submitted program, after which it is a matter of invoking cabal run.
+However, this design has some disadvantages:
+
+
To prevent interference when two jobs for the same GHC version arrive at a worker simultaneously (to be handled on separate cores), (number of GHCs) projects is not enough: we actually need (number of GHCs) * (number of cores) of them.
+
The playground not only supports running an executable, but also showing Core and assembly (also for non-Main modules).
+While we could modify the thing.cabal file together with Main.hs to make cabal do the right thing, it turns out that cabal takes quite a bit of time to reconfigure when the thing.cabal file changes.
+To not make the user wait so long, we actually need (number of GHCs) * (number of cores) * (number of configurations (currently 3)) project directories!
+And if the playground is to support passing additional user-specified options to GHC in the future, then the number of configurations will explode.
+Clearly this will not scale.
+
Furthermore, even without needing to reconfigure the project, cabal still takes some time to update its own administration for every cabal run — time that is unnecessary because we know exactly what needs to happen: just run the same ghc command as before.
+
+
Perhaps cabal could be improved on that last point, but even without that, there is enough reason for the playground to do something different.
+What happens instead is the following:
+
+
I have one Cabal project directory per GHC version, containing a thing.cabal file defining an executable component that depends on all the packages to be made available.
+
Whenever I add a new GHC version to the playground, or want to update package versions for an existing one, I cabal build that directory with the appropriate GHC version.
+This yields a dist-newstyle/cache/plan.json that contains a wealth of information about the precise dependency tree, including the precise package IDs as found in the Cabal store in ~/.cabal/store.
+
+
It is important that this building happens in approximately (!) the same sandboxing setup as the one for the user-submitted jobs, so that paths to the cabal store etc. are the same in both situations.
+I say "approximately" here because cabal of course needs write access to ~/.cabal here, and the user does not.
+
+
+
These package IDs are collected and inserted in a generated shell script that invokes ghc in precisely the right way to bring those packages into scope.
+As it turns out, ghc doesn't really mind getting Main or non-Main modules here; this means that e.g. Core mode simply appends -ddump-simpl -ddump-to-file to the arguments to ghc, and everything works fine.
+
+
There is thus one such generated shell script for each GHC version on the playground; these are what is actually run when a job is handled by a worker.
+This way, the overhead is as low as possible: just ghc is invoked, and almost nothing else (apart from the sandboxing machinery).
+The overhead from sandboxing is reduced to a minimum by starting a new sandbox immediately after the previous one exited, so that one should be already running (waiting for a program to compile) when the next job arrives.
+
Manual work
+
The awkward part of the current setup is that I need to manually prepare a consistent package list for each GHC version.
+I have some automation for that, but it would of course be nicer if the process of adding a new GHC version to the playground was automatic.
+
The trouble is that this is actually non-trivial.
+As described above, there is a "wish list" of packages that we'd like to be available, but not all those packages build with all GHC versions — either because they haven't been updated for the latest GHC yet, or because they exist only for certain GHC versions by design (e.g. ghc-heap).
+It is not obvious how to effectively determine a maximal subset of this wish list that builds together!
+Because package dependency constraints need not be monotonic (e.g. package B may depend on A (>= 1 && < 3) || (>= 4 && < 6)), simply using the newest of each package on the wish list (or oldest, as some people seem to prefer) is not necessarily sufficient.
+This is why the Cabal dependency solver is a thing.
+
The process of "whittling down" the wish list to something that does build together, guided by cabal dependency solving errors, is partially automated, but a comprehensive automated solution (that is nevertheless simple enough to maintain and not introduce a slew of robustness bugs of its own) would be nicer.
+If you have ideas, please jump into the issue tracker and tell me!
+
Future
+
The playground receives a healthy amount of traffic, and it seems to be useful to people, but of course there is a lot that can still be improved.
+A number of ideas are already listed in the issues on the GitHub repository, but if you have an idea for an improvement that's not yet on the list — be it to the design, the user experience, or the implementation — or if you've found a bug and would like to report it, feel free to open an issue.
+If you would like to work on the project yourself (and it's more than a one-line fix), please open an issue first; that way we can prevent extra or duplicate work on both sides.
+
As an example of a recently added feature, the GHC error output on the playground now links to the Haskell Error Index (for GHC >= 9.6).
+(If you get a GHC error, such as this one, click on the link, and find that it has not been explained yet in the Error Index, they're looking for contributors!)
+Thanks to @MangoIV for suggesting this feature.
+
If you want to say hi, I often hang out in #haskell on libera.chat.
+Happy Haskelling!
+
+
+
+
+
+
+
+
+
diff --git a/the-haskell-playground/playground-issue.png b/the-haskell-playground/playground-issue.png
new file mode 100644
index 0000000..89a7ccd
Binary files /dev/null and b/the-haskell-playground/playground-issue.png differ
diff --git a/tinysearch_engine_bg.wasm b/tinysearch_engine_bg.wasm
new file mode 100644
index 0000000..6524c13
Binary files /dev/null and b/tinysearch_engine_bg.wasm differ
+
+
+
+
