chore: prepare v0.0.3

.tool-versions

@@ -1 +1,2 @@
 purescript 0.15.15
+bun 1.1.18

LICENSE

@@ -0,0 +1,675 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.
+

README.md

@@ -1,28 +1,16 @@
-# purescript-cbor-stream
+# purescript-threading
+Concurrency primitives inspired by python's multithreading and rust, allowing for
+predictable concurrency with `Aff`
 
-Type-safe bindings for the streaming API of `cbor-x`
+## Use Cases
+* Create a background worker thread
+* Communicate between threads (`Threading.Channel`)
+* Limit access to a resource _(eg. a database connection pool, file handle)_ to 1 concurrent actor (`Threading.RWLock`, `Threading.Mutex`)
+* Coordinate concurrent threads, waiting for some common goal to be reached before continuing (`Threading.Barrier`)
+* Create a pool of concurrent "threads" that can pull work from a queue, with graceful exiting and error handling
+* Remotely kill a thread, or non-blockingly ask if it has exited
 
 ## Installing
 ```bash
-spago install cbor-stream
-{bun|yarn|npm|pnpm} install cbor-x
-```
-
-## Examples
-
-### Convert a cbor-encoded dataset to csv
-```purescript
-import Pipes.Node.Stream as Pipes.Stream
-import Pipes.Node.FS as Pipes.FS
-import Pipes.Node.Buffer as Pipes.Buffer
-import Pipes.CBOR as Pipes.CBOR
-import Pipes.CSV as Pipes.CSV
-import Pipes.Prelude ((>->))
-import Pipes.Prelude as Pipes
-
-Pipes.runEffect
-  $ Pipes.FS.read "foo.bin"
-    >-> Pipes.CBOR.decode @{id :: Int, name :: String}
-    >-> Pipes.CSV.stringify
-    >-> Pipes.FS.write "foo.csv"
+spago install threading
 ```

bun/prepare.js

@@ -22,8 +22,8 @@ await writeFile("./spago.yaml", spagonew);
 
 const readme = await readFile("./README.md", "utf8");
 const readmenew = readme.replace(
-  /packages\/purescript-cbor-stream\/.+?\//g,
-  `/packages/purescript-cbor-stream/${ver}/`,
+  /packages\/purescript-threading\/.+?\//g,
+  `/packages/purescript-threading/${ver}/`,
 );
 await writeFile("./README.md", readmenew);
 

package.json

@@ -1,12 +1,10 @@
 {
-  "name": "purescript-cbor-stream",
-  "version": "v1.0.4",
+  "name": "purescript-threading",
+  "version": "v0.0.3",
   "type": "module",
-  "dependencies": {
-    "cbor-x": "^1.5.9",
-    "decimal.js": "^10.4.3"
-  },
+  "dependencies": {},
   "devDependencies": {
-    "typescript": "^5.4.5"
+    "typescript": "^5.4.5",
+    "bun": "1.1.18"
   }
 }

spago.yaml

@@ -1,53 +1,42 @@
 package:
-  name: cbor-stream
+  name: threading
   publish:
-    version: '1.0.4'
+    version: '0.0.3'
     license: 'GPL-3.0-or-later'
     location:
       githubOwner: 'cakekindel'
-      githubRepo: 'purescript-cbor-stream'
+      githubRepo: 'purescript-threading'
   build:
     strict: true
-    pedanticPackages: true
+    # pedanticPackages: true
   dependencies:
     - aff: ">=7.1.0 <8.0.0"
     - arrays: ">=7.3.0 <8.0.0"
-    - bifunctors: ">=6.0.0 <7.0.0"
-    - datetime: ">=6.1.0 <7.0.0"
+    - catenable-lists: ">=7.0.0 <8.0.0"
+    - control: ">=6.0.0 <7.0.0"
     - effect: ">=4.0.0 <5.0.0"
     - either: ">=6.1.0 <7.0.0"
-    - exceptions: ">=6.0.0 <7.0.0"
+    - exceptions: ">=6.1.0 <7.0.0"
+    - filterable: ">=5.0.0 <6.0.0"
     - foldable-traversable: ">=6.0.0 <7.0.0"
-    - foreign: ">=7.0.0 <8.0.0"
-    - foreign-object: ">=4.1.0 <5.0.0"
-    - js-bigints: ">=2.2.1 <3.0.0"
-    - js-date: ">=8.0.0 <9.0.0"
-    - js-maps: ">=0.1.2 <0.2.0"
     - maybe: ">=6.0.0 <7.0.0"
-    - node-buffer: ">=9.0.0 <10.0.0"
-    - node-event-emitter: ">=3.0.0 <4.0.0"
-    - node-stream-pipes: ">=1.6.0 <2.0.0"
-    - node-streams: ">=9.0.0 <10.0.0"
     - nullable: ">=6.0.0 <7.0.0"
     - ordered-collections: ">=3.2.0 <4.0.0"
-    - pipes: ">=8.0.0 <9.0.0"
     - prelude: ">=6.0.1 <7.0.0"
-    - record: ">=4.0.0 <5.0.0"
-    - simple-json: ">=9.0.0 <10.0.0"
-    - tailrec: ">=6.1.0 <7.0.0"
+    - refs: ">=6.0.0 <7.0.0"
     - transformers: ">=6.0.0 <7.0.0"
+    - tuples: ">=7.0.0 <8.0.0"
     - typelevel-prelude: ">=7.0.0 <8.0.0"
-    - unsafe-coerce: ">=6.0.0 <7.0.0"
   test:
     main: Test.Main
     dependencies:
       - console
-      - gen
-      - node-fs
-      - node-zlib
-      - precise-datetime
-      - quickcheck
-      - simple-json
+      - datetime
+      - newtype
+      - parallel
       - spec
+      - tailrec
 workspace:
+  packageSet:
+    registry: 53.3.0
   extraPackages: {}

src/Data.CBOR.purs

@@ -1,158 +0,0 @@
-module Data.CBOR where
-
-import Prelude
-
-import Control.Monad.Error.Class (liftMaybe, try)
-import Control.Monad.Except (ExceptT(..), withExcept)
-import Control.Monad.Except.Trans (runExceptT)
-import Data.Array as Array
-import Data.DateTime (DateTime)
-import Data.Either (Either(..), isRight)
-import Data.Foldable (class Foldable)
-import Data.FoldableWithIndex (foldlWithIndex)
-import Data.JSDate (JSDate)
-import Data.JSDate as JSDate
-import Data.Map (Map)
-import Data.Maybe (Maybe(..))
-import Data.Symbol (class IsSymbol, reflectSymbol)
-import Data.Traversable (traverse)
-import Foreign (F, Foreign, ForeignError(..), readArray, readNullOrUndefined, unsafeReadTagged, unsafeToForeign)
-import Foreign.Index (readProp)
-import JS.BigInt (BigInt)
-import JS.Map (Map) as JS
-import JS.Map as JS.Map
-import Prim.Row as Row
-import Prim.RowList (class RowToList, Cons, Nil, RowList)
-import Record (get)
-import Record.Builder (Builder)
-import Record.Builder as Builder
-import Simple.JSON (class ReadForeign, class WriteForeign, readImpl, writeImpl)
-import Type.Prelude (Proxy(..))
-
-class ReadCBOR :: Type -> Constraint
-class ReadCBOR a where
-  readCBOR :: Foreign -> F a
-
-class WriteCBOR :: Type -> Constraint
-class WriteCBOR a where
-  writeCBOR :: a -> Foreign
-
-instance ReadCBOR Foreign where
-  readCBOR = pure
-else instance (RowToList r rl, ReadCBORFields rl () r) => ReadCBOR (Record r) where
-  readCBOR o = do
-    flip Builder.build {} <$> getFields (Proxy @rl) o
-else instance ReadCBOR BigInt where
-  readCBOR = unsafeReadTagged "BigInt"
-else instance ReadCBOR JSDate where
-  readCBOR = unsafeReadTagged "Date"
-else instance ReadCBOR DateTime where
-  readCBOR a = do
-    date :: JSDate <- readCBOR a
-    liftMaybe (pure $ ForeignError $ "Invalid DateTime: " <> show date) $ JSDate.toDateTime date
-else instance ReadCBOR a => ReadCBOR (Array a) where
-  readCBOR a = do
-    raws :: Array Foreign <- readArray a
-    traverse readCBOR raws
-else instance ReadCBOR a => ReadCBOR (Maybe a) where
-  readCBOR a = do
-    isNull <- isRight <$> try (readNullOrUndefined a)
-    if isNull then
-      pure Nothing
-    else
-      Just <$> readCBOR @a a
-else instance (ReadCBOR v) => ReadCBOR (JS.Map String v) where
-  readCBOR map = do
-    map' :: JS.Map String Foreign <- unsafeReadTagged "Map" map
-    foldlWithIndex (\k b v -> do
-      map'' <- b
-      v' <- readCBOR v
-      pure $ JS.Map.insert k v' map''
-    ) (pure JS.Map.empty) map'
-else instance (ReadForeign a) => ReadCBOR a where
-  readCBOR = readImpl
-
-instance WriteCBOR Foreign where
-  writeCBOR = identity
-else instance (RowToList r rl, WriteCBORFields rl r () to) => WriteCBOR (Record r) where
-  writeCBOR rec = unsafeToForeign $ Builder.build (writeImplFields (Proxy @rl) rec) {}
-else instance WriteCBOR BigInt where
-  writeCBOR = unsafeToForeign
-else instance WriteCBOR JSDate where
-  writeCBOR = unsafeToForeign
-else instance WriteCBOR DateTime where
-  writeCBOR = unsafeToForeign <<< JSDate.fromDateTime
-else instance (WriteCBOR k, WriteCBOR v) => WriteCBOR (JS.Map k v) where
-  writeCBOR = unsafeToForeign
-else instance (WriteCBOR a) => WriteCBOR (Array a) where
-  writeCBOR as = unsafeToForeign $ writeCBOR <$> as
-else instance (Foldable f, WriteCBOR a) => WriteCBOR (f a) where
-  writeCBOR as = unsafeToForeign $ writeCBOR $ Array.fromFoldable as
-else instance (JS.Map.EncodeKey k, WriteCBOR k, WriteCBOR v) => WriteCBOR (Map k v) where
-  writeCBOR map = writeCBOR $ foldlWithIndex (\k m v -> JS.Map.insert k v m) JS.Map.empty map
-else instance (WriteForeign a) => WriteCBOR a where
-  writeCBOR = writeImpl
-
-applyEither :: forall e a b. Semigroup e => Either e (a -> b) -> Either e a -> Either e b
-applyEither (Left e) (Right _) = Left e
-applyEither (Left e1) (Left e2) = Left (e1 <> e2)
-applyEither (Right _) (Left e) = Left e
-applyEither (Right fun) (Right a) = Right (fun a)
-
-exceptTApply :: forall a b e m. Semigroup e => Applicative m => ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b
-exceptTApply fun a = ExceptT $ applyEither
-  <$> runExceptT fun
-  <*> runExceptT a
-
-class ReadCBORFields (xs :: RowList Type) (from :: Row Type) (to :: Row Type)
-  | xs -> from to where
-  getFields :: Proxy xs
-    -> Foreign
-    -> F (Builder (Record from) (Record to))
-
-instance readFieldsCons ::
-  ( IsSymbol name
-  , ReadCBOR ty
-  , ReadCBORFields tail from from'
-  , Row.Lacks name from'
-  , Row.Cons name ty from' to
-  ) => ReadCBORFields (Cons name ty tail) from to where
-  getFields _ obj = (compose <$> first) `exceptTApply` rest
-    where
-      first = do
-        value <- withExcept' (readCBOR =<< readProp name obj)
-        pure $ Builder.insert nameP value
-      rest = getFields tailP obj
-      nameP = Proxy :: Proxy name
-      tailP = Proxy :: Proxy tail
-      name = reflectSymbol nameP
-      withExcept' = withExcept <<< map $ ErrorAtProperty name
-
-instance readFieldsNil ::
-  ReadCBORFields Nil () () where
-  getFields _ _ =
-    pure identity
-
-class WriteCBORFields (rl :: RowList Type) row (from :: Row Type) (to :: Row Type)
-  | rl -> row from to where
-  writeImplFields :: forall g. g rl -> Record row -> Builder (Record from) (Record to)
-
-instance consWriteCBORFields ::
-  ( IsSymbol name
-  , WriteCBOR ty
-  , WriteCBORFields tail row from from'
-  , Row.Cons name ty whatever row
-  , Row.Lacks name from'
-  , Row.Cons name Foreign from' to
-  ) => WriteCBORFields (Cons name ty tail) row from to where
-  writeImplFields _ rec = result
-    where
-      namep = Proxy :: Proxy name
-      value = writeCBOR $ get namep rec
-      tailp = Proxy :: Proxy tail
-      rest = writeImplFields tailp rec
-      result = Builder.insert namep value <<< rest
-
-instance nilWriteCBORFields ::
-  WriteCBORFields Nil row () () where
-  writeImplFields _ _ = identity

src/Effect.CBOR.js

@@ -1,7 +0,0 @@
-import {decode, encode} from 'cbor-x'
-
-/** @type {(a: Buffer) => () => unknown} */
-export const decodeImpl = buf => () => decode(buf)
-
-/** @type {(a: unknown) => () => Buffer} */
-export const encodeImpl = buf => () => encode(buf)

src/Effect.CBOR.purs

@@ -1,21 +0,0 @@
-module Effect.CBOR where
-
-import Prelude
-
-import Control.Monad.Error.Class (liftEither)
-import Control.Monad.Except (runExcept)
-import Data.Bifunctor (lmap)
-import Data.CBOR (class ReadCBOR, class WriteCBOR, readCBOR, writeCBOR)
-import Effect (Effect)
-import Effect.Exception (error)
-import Foreign (Foreign)
-import Node.Buffer (Buffer)
-
-foreign import decodeImpl :: Buffer -> Effect Foreign
-foreign import encodeImpl :: Foreign -> Effect Buffer
-
-decode :: forall a. ReadCBOR a => Buffer -> Effect a
-decode = (liftEither <<< lmap (error <<< show) <<< runExcept <<< readCBOR) <=< decodeImpl
-
-encode :: forall a. WriteCBOR a => a -> Effect Buffer
-encode = encodeImpl <<< writeCBOR

src/JS.Finalization.js

@@ -0,0 +1,8 @@
+/** @type {<T>(cb: (t: T) => void) => () => FinalizationRegistry<T>} */
+export const registry = (cb) => () => new FinalizationRegistry(cb);
+
+/** @type {<T>(f: FinalizationRegistry<T>) => <O extends WeakKey>(a: WeakRef<O>) => (b: T) => () => void} */
+export const register = (fin) => (a) => (b) => () => fin.register(a, b);
+
+/** @type {<T>(f: FinalizationRegistry<T>) => <O extends WeakKey>(a: WeakRef<O>) => () => void} */
+export const unregister = (fin) => (a) => () => fin.unregister(a);

src/JS.Finalization.purs

@@ -0,0 +1,15 @@
+module JS.Drop where
+
+import Prelude
+
+import Effect (Effect)
+import JS.WeakRef (WeakRef)
+
+type Registry_ a = Registry a Unit
+
+foreign import data Registry :: Type -> Type -> Type
+
+foreign import registry :: forall a b. (b -> Effect Unit) -> Effect (Registry a b)
+
+foreign import register :: forall a b. Registry a b -> WeakRef a -> b -> Effect Unit
+foreign import unregister :: forall a b. Registry a b -> WeakRef a -> Effect Unit

src/JS.WeakRef.js

@@ -0,0 +1,5 @@
+/** @type {<T extends WeakKey>(_: T) => () => WeakRef<T>} */
+export const make = (a) => () => new WeakRef(a);
+
+/** @type {<T extends WeakKey>(_: WeakRef<T>) => () => T | undefined} */
+export const _deref = (a) => () => a.deref();

src/JS.WeakRef.purs

@@ -0,0 +1,17 @@
+module JS.WeakRef where
+
+import Prelude
+
+import Data.Maybe (Maybe)
+import Data.Nullable (Nullable)
+import Data.Nullable as Nullable
+import Effect (Effect)
+
+foreign import data WeakRef :: Type -> Type
+
+foreign import make :: forall a. a -> Effect (WeakRef a)
+
+deref :: forall a. WeakRef a -> Effect (Maybe a)
+deref = map Nullable.toMaybe <<< _deref
+
+foreign import _deref :: forall a. WeakRef a -> Effect (Nullable a)

src/Node.Stream.CBOR.Decode.js

@@ -1,7 +0,0 @@
-import { DecoderStream } from "cbor-x";
-
-/** @type {(s: import('cbor-x').Options) => () => DecoderStream} */
-export const makeImpl = (c) => () => new DecoderStream({useRecords: false, ...c});
-
-/** @type {(s: DecoderStream) => () => unknown | null} */
-export const readImpl = (p) => () => p.read();

src/Node.Stream.CBOR.Decode.purs

@@ -1,52 +0,0 @@
-module Node.Stream.CBOR.Decode where
-
-import Prelude hiding (join)
-
-import Data.Nullable (Nullable)
-import Effect (Effect)
-import Effect.Uncurried (mkEffectFn1)
-import Foreign (Foreign)
-import Foreign.Object (Object)
-import Node.Buffer (Buffer)
-import Node.EventEmitter (EventHandle(..))
-import Node.EventEmitter.UtilTypes (EventHandle1)
-import Node.Stream (Read, Stream, Write)
-import Node.Stream.CBOR.Options (F32, Options, prepareOptions)
-import Node.Stream.Object (Transform) as Object
-import Prim.Row (class Nub, class Union)
-import Unsafe.Coerce (unsafeCoerce)
-
-data CBORDecode
-
--- | CBOR decoding transform stream
--- |
--- | Accepts unencoded `Buffer` chunks, and transforms them
--- | to JS values.
-type CBORDecoder :: Row Type -> Type
-type CBORDecoder r = Stream (read :: Read, write :: Write, cbor :: CBORDecode | r)
-
-make
-  :: forall r missing extra minimal minimalExtra
-   . Union r missing (Options extra)
-  => Union r (useFloat32 :: F32) minimal
-  => Nub minimal (useFloat32 :: F32 | minimalExtra)
-  => { | r }
-  -> Effect (CBORDecoder ())
-make = makeImpl <<< prepareOptions @r @missing
-
-toObjectStream :: forall r. CBORDecoder r -> Object.Transform Buffer Foreign
-toObjectStream = unsafeCoerce
-
--- | `data` event. Emitted when a CSV record has been parsed.
-dataH :: forall a. EventHandle1 (CBORDecoder a) Foreign
-dataH = EventHandle "data" mkEffectFn1
-
--- | FFI
-foreign import makeImpl :: forall r. Foreign -> Effect (Stream r)
-
--- | FFI
-foreign import readImpl :: forall r. Stream r -> Effect (Nullable Foreign)
-
--- | FFI
-recordToForeign :: forall r. Record r -> Object Foreign
-recordToForeign = unsafeCoerce

src/Node.Stream.CBOR.Encode.js

@@ -1,7 +0,0 @@
-import { EncoderStream } from "cbor-x";
-
-/** @type {(s: import('cbor-x').Options) => () => EncoderStream} */
-export const makeImpl = (c) => () => new EncoderStream({useRecords: false, ...c});
-
-/** @type {(s: EncoderStream) => (a: unknown) => () => void} */
-export const writeImpl = (s) => (a) => () => s.write(a);

src/Node.Stream.CBOR.Encode.purs

@@ -1,49 +0,0 @@
-module Node.Stream.CBOR.Encode where
-
-import Prelude
-
-import Data.CBOR (class WriteCBOR, writeCBOR)
-import Effect (Effect)
-import Foreign (Foreign)
-import Foreign.Object (Object)
-import Node.Buffer (Buffer)
-import Node.Stream (Read, Stream, Write)
-import Node.Stream.CBOR.Options (F32, Options, prepareOptions)
-import Node.Stream.Object (Transform) as Object
-import Prim.Row (class Nub, class Union)
-import Unsafe.Coerce (unsafeCoerce)
-
-data CBOREncode
-
-type CBOREncoder :: Row Type -> Type
-type CBOREncoder r = Stream (read :: Read, write :: Write, csv :: CBOREncode | r)
-
-foreign import makeImpl :: forall r. Foreign -> Effect (Stream r)
-foreign import writeImpl :: forall r. Stream r -> Foreign -> Effect Unit
-
-recordToForeign :: forall r. Record r -> Object Foreign
-recordToForeign = unsafeCoerce
-
--- | Create a raw Transform stream that accepts chunks of `Array String`,
--- | and transforms them into string CSV rows.
--- |
--- | Requires an ordered array of column names.
-make
-  :: forall r missing extra minimal minimalExtra
-   . Union r missing (Options extra)
-  => Union r (useFloat32 :: F32) minimal
-  => Nub minimal (useFloat32 :: F32 | minimalExtra)
-  => { | r }
-  -> Effect (CBOREncoder ())
-make = makeImpl <<< prepareOptions @r @missing
-
--- | Convert the raw stream to a typed ObjectStream
-toObjectStream :: CBOREncoder () -> Object.Transform Foreign Buffer
-toObjectStream = unsafeCoerce
-
--- | Write a record to a CSVStringifier.
--- |
--- | The record will be emitted on the `Readable` end
--- | of the stream as a string chunk.
-write :: forall a r. WriteCBOR a => CBOREncoder r -> a -> Effect Unit
-write s a = writeImpl s $ writeCBOR a

src/Node.Stream.CBOR.Options.js

@@ -1,11 +0,0 @@
-import {FLOAT32_OPTIONS} from 'cbor-x'
-
-/** @type {<F32>(o: {round: (_a: F32) => boolean, fit: (_a: F32) => boolean, always: (_a: F32) => boolean}) => (f: F32) => FLOAT32_OPTIONS} */
-export const f32ToConst = ({round, fit, always}) => a => 
-  round(a)
-  ? FLOAT32_OPTIONS.ALWAYS
-  : fit(a)
-  ? FLOAT32_OPTIONS.DECIMAL_FIT
-  : round(a)
-  ? FLOAT32_OPTIONS.DECIMAL_ROUND
-  : FLOAT32_OPTIONS.NEVER

src/Node.Stream.CBOR.Options.purs

@@ -1,50 +0,0 @@
-module Node.Stream.CBOR.Options where
-
-import Prelude
-
-import Foreign (Foreign, unsafeToForeign)
-import Prim.Row (class Nub, class Union)
-import Record (merge, modify)
-import Type.Prelude (Proxy(..))
-
-data F32
-  = F32Always
-  | F32DecimalRound
-  | F32DecimalFit
-  | F32Never
-
-derive instance Eq F32
-
-foreign import data CBORStruct :: Type
-foreign import f32ToConst :: {always :: F32 -> Boolean, round :: F32 -> Boolean, fit :: F32 -> Boolean} -> F32 -> Foreign
-
-type Options r =
-  ( useRecords :: Boolean
-  , structures :: Array CBORStruct
-  , structuredClone :: Boolean
-  , mapsAsObject :: Boolean
-  , useFloat32 :: F32
-  , alwaysUseFloat :: Boolean
-  , pack :: Boolean
-  , variableMapSize :: Boolean
-  , copyBuffers :: Boolean
-  , bundleStrings :: Boolean
-  , useTimestamp32 :: Boolean
-  , largeBigIntToFloat :: Boolean
-  , useTag259ForMaps :: Boolean
-  , tagUint8Array :: Boolean
-  , int64AsNumber :: Boolean
-  | r
-  )
-
-prepareOptions
-  :: forall @r @missing extra minimal minimalExtra
-   . Union r missing (Options extra)
-  => Union r (useFloat32 :: F32) minimal
-  => Nub minimal (useFloat32 :: F32 | minimalExtra)
-  => { | r }
-  -> Foreign
-prepareOptions a =
-  unsafeToForeign
-  $ modify (Proxy @"useFloat32") (f32ToConst {fit: eq F32DecimalFit, round: eq F32DecimalRound, always: eq F32Always})
-  $ merge a {useFloat32: F32Never}

src/Pipes.CBOR.purs

@@ -1,52 +0,0 @@
-module Pipes.CBOR where
-
-import Prelude
-
-import Control.Monad.Error.Class (class MonadThrow, liftEither)
-import Control.Monad.Except (runExcept)
-import Control.Monad.Rec.Class (class MonadRec, forever)
-import Data.Bifunctor (lmap)
-import Data.CBOR (class ReadCBOR, class WriteCBOR, readCBOR, writeCBOR)
-import Data.Maybe (Maybe)
-import Effect.Aff.Class (class MonadAff)
-import Effect.Class (liftEffect)
-import Effect.Exception (Error, error)
-import Node.Buffer (Buffer)
-import Node.Stream.CBOR.Decode as CBOR.Decode
-import Node.Stream.CBOR.Encode as CBOR.Encode
-import Pipes (await, yield, (>->))
-import Pipes.Core (Pipe)
-import Pipes.Node.Stream as Pipes.Stream
-
--- | Transforms buffer chunks of a CBOR file to parsed values
--- | of type `a`.
-decode
-  :: forall m @a
-   . MonadRec m
-  => MonadAff m
-  => MonadThrow Error m
-  => ReadCBOR a
-  => Pipe (Maybe Buffer) (Maybe a) m Unit
-decode = do
-  raw <- liftEffect $ CBOR.Decode.make {}
-  let
-    unmarshal = forever do
-      r <- await
-      yield =<< liftEither (lmap (error <<< show) $ runExcept $ readCBOR @a r)
-    parser = Pipes.Stream.fromTransform $ CBOR.Decode.toObjectStream raw
-  parser >-> Pipes.Stream.inEOS unmarshal
-
--- | Encode purescript values as CBOR buffers
-encode
-  :: forall m a
-   . MonadAff m
-  => MonadThrow Error m
-  => MonadRec m
-  => WriteCBOR a
-  => Pipe (Maybe a) (Maybe Buffer) m Unit
-encode = do
-  raw <- liftEffect $ CBOR.Encode.make {}
-  let
-    printer = Pipes.Stream.fromTransform $ CBOR.Encode.toObjectStream raw
-    marshal = forever $ yield =<< (writeCBOR <$> await)
-  Pipes.Stream.inEOS marshal >-> printer

src/Threading.Ath.purs

@@ -0,0 +1 @@
+module Threading.Ath where

src/Threading.Barrier.purs

@@ -0,0 +1,35 @@
+module Threading.Barrier (Barrier, barrier, wait) where
+
+import Prelude
+
+import Data.Array as Array
+import Data.Either (Either(..))
+import Data.Foldable (sequence_)
+import Effect (Effect)
+import Effect.Aff (Aff)
+import Effect.Aff as Aff
+import Effect.Class (liftEffect)
+import Effect.Ref (Ref)
+import Effect.Ref as Ref
+import Type.Function (type ($))
+
+-- | A barrier enables multiple threads to synchronize the beginning of some computation.
+data Barrier = Barrier Int (Ref $ Array $ Effect Unit)
+
+-- | Create a new barrier that will only unblock waiting threads
+-- | when `n` threads are waiting (including this one)
+barrier :: Int -> Effect Barrier
+barrier n = Barrier n <$> Ref.new []
+
+-- | Wait until the provided number of threads
+-- | are also `wait`ing
+wait :: Barrier -> Aff Unit
+wait (Barrier n wakersRef) = do
+  wakers <- liftEffect $ Ref.read wakersRef
+  if n <= 1 then
+    pure unit
+  else if Array.length wakers == (n - 1) then
+    liftEffect $ sequence_ wakers
+  else Aff.makeAff \cb -> do
+    Ref.modify_ (_ <> [ cb $ Right unit ]) wakersRef
+    pure $ Aff.nonCanceler

src/Threading.Channel.purs

@@ -0,0 +1,163 @@
+module Threading.Channel
+  ( Channel
+  , Sender
+  , Receiver
+  , recv
+  , tryRecv
+  , send
+  , peek
+  , tryPeek
+  , channel
+  , sender
+  , receiver
+  ) where
+
+import Prelude
+
+import Control.Monad.Error.Class (throwError)
+import Data.Array as Array
+import Data.CatList (CatList)
+import Data.CatList as CatList
+import Data.Either (Either(..))
+import Data.Maybe (Maybe(..), isJust, maybe)
+import Data.Traversable (for)
+import Data.Tuple (fst)
+import Data.Tuple.Nested ((/\))
+import Data.Witherable (wither)
+import Effect (Effect)
+import Effect.Aff (Aff)
+import Effect.Aff as Aff
+import Effect.Class (liftEffect)
+import Effect.Exception (error)
+import JS.WeakRef (WeakRef)
+import JS.WeakRef as WeakRef
+import Threading.Data.Mutex (Mutex)
+import Threading.Data.Mutex as Mutex
+import Type.Function (type ($))
+
+-- | A multi-producer multi-consumer channel for communication
+-- | between threads.
+-- |
+-- | Senders will broadcast messages to all living receivers,
+-- | doing nothing if there are no receivers.
+-- |
+-- | Receivers can wait for messages to be sent. Messages that
+-- | are sent while the receiver is not waiting will be buffered,
+-- | and `recv`d in the order they were sent.
+data Channel a = Channel (Mutex $ Array $ WeakRef $ Receiver a)
+
+data Sender a = Sender (Channel a)
+data Receiver a = Receiver (Mutex $ Maybe (a -> Effect Unit)) (Mutex $ CatList a)
+
+-- | Create a new channel
+channel :: forall a. Effect (Channel a)
+channel = do
+  recvs <- Mutex.mutex []
+  pure $ Channel recvs
+
+-- | Create a new message receiver
+receiver :: forall a. Channel a -> Aff (Receiver a)
+receiver (Channel recvsRef) = do
+  g <- Mutex.lock recvsRef
+  liftEffect do
+    queue <- Mutex.mutex CatList.empty
+    wake <- Mutex.mutex Nothing
+    recvs <- Mutex.read g
+    let r = Receiver wake queue
+    recvWeak <- WeakRef.make r
+    Mutex.write g $ Array.cons recvWeak recvs
+    Mutex.release g
+    pure r
+
+-- | Create a new message sender
+sender :: forall a. Channel a -> Effect (Sender a)
+sender c = pure $ Sender c
+
+-- | Send a message to all living receivers
+send :: forall a. Sender a -> a -> Aff Unit
+send (Sender (Channel recvsRef)) a = do
+  recvsG <- Mutex.lock recvsRef
+  recvWeaks <- liftEffect $ Mutex.read recvsG
+  recvs <- liftEffect $ wither WeakRef.deref recvWeaks
+  void $ for recvs \(Receiver wakeRef queueRef) -> do
+    wakeG <- Mutex.lock wakeRef
+    wake <- liftEffect $ Mutex.read wakeG
+
+    queueG <- Mutex.lock queueRef
+    head /\ tail <-
+      liftEffect (Mutex.read queueG)
+        <#> CatList.uncons
+        <#> maybe (a /\ CatList.empty) (\(head /\ tail) -> head /\ CatList.snoc tail a)
+
+    let
+      q = CatList.cons head tail
+
+    liftEffect do
+      maybe (Mutex.write queueG q) (\f -> Mutex.write queueG tail *> f head) wake
+      Mutex.release wakeG
+      Mutex.release queueG
+  liftEffect $ Mutex.release recvsG
+
+-- | Read a queued message and pop it from the queue.
+-- |
+-- | If no queued messages have been sent, returns Nothing.
+tryRecv :: forall a. Receiver a -> Aff (Maybe a)
+tryRecv (Receiver _ queueRef) = do
+  queueG <- Mutex.lock queueRef
+  queueM <- CatList.uncons <$> liftEffect (Mutex.read queueG)
+  for queueM \(a /\ tail) -> liftEffect $ Mutex.write queueG tail *> Mutex.release queueG $> a
+
+-- | Block until a message is sent, and pop it from the queue.
+-- |
+-- | If a message has been sent since the
+-- | last call to `recv`, then it will
+-- | be immediately popped & returned.
+recv :: forall a. Receiver a -> Aff a
+recv (Receiver wakeRef queueRef) = do
+  wakeG <- Mutex.lock wakeRef
+  queueG <- Mutex.lock queueRef
+  liftEffect
+    $ whenM (isJust <$> Mutex.read wakeG)
+    $ throwError
+    $ error "Receiver has been shared between multiple fibers, which is not supported."
+
+  queueM <- liftEffect $ CatList.uncons <$> Mutex.read queueG
+  case queueM of
+    Just (a /\ tail) -> liftEffect do
+      Mutex.write queueG tail
+      Mutex.release wakeG
+      Mutex.release queueG
+      pure a
+    Nothing -> Aff.makeAff \cb -> do
+      Mutex.write wakeG $ Just $ cb <<< Right
+      Mutex.release wakeG
+      Mutex.release queueG
+      pure $ Aff.Canceler $ const $ Mutex.put wakeRef Nothing
+
+-- | Read a queued message without altering the queue.
+-- |
+-- | If no queued messages have been sent, returns Nothing.
+tryPeek :: forall a. Receiver a -> Aff (Maybe a)
+tryPeek (Receiver _ queueRef) = map fst <$> CatList.uncons <$> Mutex.get queueRef
+
+-- | Block until a message is sent, and read
+-- | it without removing it from the queue.
+-- |
+-- | If a message has been sent since the
+-- | last call to `recv`, then it will
+-- | be immediately returned.
+peek :: forall a. Receiver a -> Aff a
+peek (Receiver wakeRef queueRef) = do
+  wakeG <- Mutex.lock wakeRef
+  queueM <- CatList.uncons <$> Mutex.get queueRef
+  liftEffect
+    $ whenM (isJust <$> Mutex.read wakeG)
+    $ throwError
+    $ error "Receiver has been shared between multiple fibers, which is not supported."
+
+  case queueM of
+    Just (a /\ _) -> liftEffect $ Mutex.release wakeG $> a
+    Nothing -> Aff.makeAff \cb -> do
+      Mutex.write wakeG $ Just $ cb <<< Right
+      Mutex.release wakeG
+      pure $ Aff.Canceler $ const $ Mutex.put wakeRef Nothing

src/Threading.Data.Mutex.js

@@ -0,0 +1,133 @@
+/**
+ * @template T
+ * @typedef {(g: Guard<T>) => () => void}
+ * Waker
+ */
+
+/** @template T */
+class Guard {
+  released = false;
+
+  /**
+   * @param {Mutex<T>} mutex
+   * @param {() => void} onExplicitRelease
+   */
+  constructor(mutex, onExplicitRelease) {
+    this.mutex = mutex;
+    this.cb = onExplicitRelease;
+  }
+
+  read() {
+    if (this.released) {
+      throw new Error("Guard#read after explicit release");
+    }
+    return this.mutex.a;
+  }
+
+  /** @param {T} a */
+  write(a) {
+    if (this.released) {
+      throw new Error("Guard#write after explicit release");
+    }
+    this.mutex.a = a;
+  }
+
+  release() {
+    if (!this.released) {
+      this.released = true;
+      this.cb();
+    }
+  }
+}
+
+/** @template T */
+class Mutex {
+  /** @type {WeakRef<Guard<T>> | undefined} */
+  guard = undefined;
+
+  /** @type {Array<(g: Guard<T>) => () => void>} */
+  wakers = [];
+
+  /** @type {FinalizationRegistry<undefined>} */
+  cleanup = new FinalizationRegistry(() => this._guardReleased());
+
+  /**
+   * @param {T} a
+   */
+  constructor(a) {
+    this.a = a;
+  }
+
+  _guardReleased() {
+    this.guard = undefined;
+    const wake = this.wakers.shift();
+    if (wake) {
+      wake(this._newGuard())();
+    }
+  }
+
+  _newGuard() {
+    const g = new Guard(this, () => {
+      if (!this.guard) throw new Error("unreachable");
+      this.cleanup.unregister(this.guard);
+      this._guardReleased();
+    });
+
+    this.guard = new WeakRef(g);
+    this.cleanup.register(g, undefined);
+    return g;
+  }
+
+  locked() {
+    return !!this.guard;
+  }
+
+  /** @param {Waker<T>} cb */
+  lock(cb) {
+    if (!this.guard) {
+      cb(this._newGuard())();
+      return undefined;
+    } else {
+      this.wakers.push(cb);
+      return cb;
+    }
+  }
+
+  /** @param {Waker<T>} cb */
+  releaseWaker(cb) {
+    const ix = this.wakers.indexOf(cb);
+    if (ix > -1) {
+      this.wakers.splice(ix, 1);
+    }
+  }
+
+  tryLock() {
+    if (!this.guard) {
+      return this._newGuard();
+    }
+  }
+}
+
+/** @type {<T>(t: T) => () => Mutex<T>} */
+export const _make = (a) => () => new Mutex(a);
+
+/** @type {<T>(mutex: Mutex<T>) => (cb: Waker<T>) => () => Waker<T> | undefined} */
+export const _lock = (mutex) => (cb) => () => mutex.lock(cb);
+
+/** @type {<T>(mutex: Mutex<T>) => () => boolean} */
+export const _locked = (mutex) => () => mutex.locked();
+
+/** @type {<T>(mutex: Mutex<T>) => () => Guard<T> | undefined} */
+export const _tryLock = (mutex) => () => mutex.tryLock();
+
+/** @type {<T>(mutex: Mutex<T>) => (cb: Waker<T>) => () => void} */
+export const _releaseWaker = (mutex) => (cb) => () => mutex.releaseWaker(cb);
+
+/** @type {<T>(guard: Guard<T>) => () => void} */
+export const _guardRelease = (g) => () => g.release();
+
+/** @type {<T>(guard: Guard<T>) => () => T} */
+export const _guardRead = (g) => () => g.read();
+
+/** @type {<T>(guard: Guard<T>) => (t: T) => () => void} */
+export const _guardWrite = (g) => (a) => () => g.write(a);

src/Threading.Data.Mutex.purs

@@ -0,0 +1,140 @@
+-- | A Mutex allows any number of threads to share mutable
+-- | state, with at most 1 thread having read or write access
+-- | at a time.
+-- |
+-- | Threads can access the data with `lock` or `tryLock`,
+-- | which both return a `Guard`.
+-- |
+-- | The holder of a `Guard` is guaranteed exclusive read &
+-- | write access to the data contained in the `Mutex`.
+module Threading.Data.Mutex
+  ( Mutex
+  , Guard
+  , mutex
+  , lock
+  , tryLock
+  , locked
+  , release
+  , modify
+  , modify_
+  , write
+  , read
+  , get
+  , put
+  ) where
+
+import Prelude
+
+import Data.Either (Either(..))
+import Data.Maybe (Maybe(..))
+import Data.Nullable (Nullable)
+import Data.Nullable as Nullable
+import Effect (Effect)
+import Effect.Aff (Aff)
+import Effect.Aff as Aff
+import Effect.Class (liftEffect)
+
+foreign import data Waker :: Type
+
+foreign import data Mutex :: Type -> Type
+
+-- | A lock to a Mutex.
+-- |
+-- | Guards may be read from, written to, and released. Guards **must** be
+-- | released in order for other blocking threads to continue.
+-- |
+-- | _Note: If a Guard reclaimed by the garbage collector without being released,
+-- | its Mutex will notice and behave as if the Guard was explicitly released.
+-- | This will hopefully catch deadlocks caused by threads that have exited
+-- | while holding a Guard._
+foreign import data Guard :: Type -> Type
+
+foreign import _make :: forall a. a -> Effect (Mutex a)
+
+foreign import _locked :: forall a. Mutex a -> Effect Boolean
+foreign import _lock :: forall a. Mutex a -> (Guard a -> Effect Unit) -> Effect (Nullable Waker)
+foreign import _tryLock :: forall a. Mutex a -> Effect (Nullable (Guard a))
+
+foreign import _releaseWaker :: forall a. Mutex a -> Waker -> Effect Unit
+
+foreign import _guardRead :: forall a. Guard a -> Effect a
+foreign import _guardWrite :: forall a. Guard a -> a -> Effect Unit
+foreign import _guardRelease :: forall a. Guard a -> Effect Unit
+
+-- | Create a new Mutex
+mutex :: forall a. a -> Effect (Mutex a)
+mutex = _make
+
+-- | Is the Mutex currently locked?
+locked :: forall a. Mutex a -> Effect Boolean
+locked = _locked
+
+-- | Attempt to acquire a lock without blocking.
+-- |
+-- | If the Mutex is currently locked, this will return `Nothing`.
+tryLock :: forall a. Mutex a -> Effect (Maybe (Guard a))
+tryLock = map Nullable.toMaybe <<< _tryLock
+
+-- | Acquire a lock, blocking if another thread
+-- | currently holds a lock.
+-- |
+-- | If multiple threads invoke `lock`, they will
+-- | be unlocked in the order that they blocked on `lock`.
+lock :: forall a. Mutex a -> Aff (Guard a)
+lock m = Aff.makeAff \cb -> do
+  waker <- Nullable.toMaybe <$> _lock m (cb <<< Right)
+  pure $ case waker of
+    Just w -> Aff.effectCanceler $ _releaseWaker m w
+    Nothing -> Aff.nonCanceler
+
+-- | Take a snapshot of the value in a Mutex
+-- |
+-- | This is a shorthand for acquiring a lock, reading it,
+-- | then immediately releasing the lock.
+get :: forall a. Mutex a -> Aff a
+get m = do
+  g <- lock m
+  a <- liftEffect $ read g <* release g
+  pure a
+
+-- | Write a new value to a Mutex
+-- |
+-- | This is a shorthand for acquiring a lock, writing to it,
+-- | then immediately releasing the lock.
+put :: forall a. Mutex a -> a -> Aff Unit
+put m a = do
+  g <- lock m
+  liftEffect $ write g a *> release g
+
+-- | Modify the value contained in a Mutex
+-- |
+-- | This is a shorthand for acquiring a lock,
+-- | reading from it, writing to it, then
+-- | immediately releasing it.
+-- |
+-- | Returns the new value.
+modify :: forall a. Mutex a -> (a -> a) -> Aff a
+modify m f = do
+  g <- lock m
+  liftEffect $ ((f <$> read g) >>= (\a -> write g a *> release g $> a))
+
+-- | `modify` with its return value ignored.
+modify_ :: forall a. Mutex a -> (a -> a) -> Aff Unit
+modify_ m f = void $ modify m f
+
+-- | Release the lock
+-- |
+-- | Attempting to `read` or `write` this `Guard`
+-- | will throw an exception.
+-- |
+-- | Repeated invocations of `release` are ignored.
+release :: forall a. Guard a -> Effect Unit
+release = _guardRelease
+
+-- | Read the value in the Mutex via the Guard
+read :: forall a. Guard a -> Effect a
+read = _guardRead
+
+-- | Write a new value into the Mutex via the Guard
+write :: forall a. Guard a -> a -> Effect Unit
+write = _guardWrite

src/Threading.Data.RWLock.purs

@@ -0,0 +1,282 @@
+-- | A RWLock allows threads to share mutable state.
+-- |
+-- | Any number of threads can concurrently read the state,
+-- | when there isn't a thread with write access.
+-- |
+-- | Get write access with `lockWrite` or `tryLockWrite`,
+-- | or read access with `lockRead` or `tryLockRead`.
+-- |
+-- | `(try)lockWrite` returns a `WriteGuard`, which guarantees
+-- | no other threads have read or write access until it is released.
+-- |
+-- | `(try)lockRead` returns a `ReadGuard`, which guarantees
+-- | no threads have write access until it is released.
+module Threading.Data.RWLock
+  ( RWLock
+  , ReadGuard
+  , WriteGuard
+  , rwLock
+  , lockWrite
+  , tryLockWrite
+  , lockRead
+  , tryLockRead
+  , locked
+  , Locked(..)
+  , get
+  , put
+  , modify
+  , modify_
+  , release
+  , read
+  , write
+  , class RWLockGuard
+  ) where
+
+import Prelude
+
+import Control.Alternative (guard)
+import Control.Monad.Error.Class (liftMaybe, throwError)
+import Control.Monad.Maybe.Trans (runMaybeT)
+import Control.Monad.Trans.Class (lift)
+import Data.Foldable (elem, traverse_)
+import Data.Generic.Rep (class Generic)
+import Data.Maybe (Maybe(..))
+import Data.Set (Set)
+import Data.Set as Set
+import Data.Show.Generic (genericShow)
+import Data.Traversable (traverse)
+import Effect (Effect)
+import Effect.Aff (Aff)
+import Effect.Class (liftEffect)
+import Effect.Exception (error)
+import Effect.Ref (Ref)
+import Effect.Ref as Ref
+import Threading.Data.Mutex (Mutex)
+import Threading.Data.Mutex as Mutex
+import Type.Function (type ($))
+
+-- | The lock state of the RWLock
+data Locked
+  -- | There are no readers or writers.
+  = Unlocked
+  -- | There is a writer, and the RWLock is not
+  -- | currently readable or writable.
+  | LockedWriting
+  -- | There is at least one reader, and the RWLock is not
+  -- | currently writable.
+  | LockedReading
+
+derive instance Generic Locked _
+derive instance Eq Locked
+instance Show Locked where
+  show = genericShow
+
+newtype WriteLockHeld = WriteLockHeld (Maybe Int)
+
+-- | A Read-Write lock
+-- |
+-- | Ensures that there can be at most 1 thread with write
+-- | access to the data contained in the RWLock, or any
+-- | number of concurrent readers.
+data RWLock a = RWLock
+  -- Guarantee that state transitions are exclusive
+  { fence :: Mutex Unit
+  -- Monotonically increasing guard counter
+  , id :: Ref Int
+  -- Condvar-style mutex indicating writability.
+  --
+  -- When a lock is held and the mutex contains `WriteLockHeld Nothing`, then there are 1 or more readers.
+  --
+  -- When a lock is held and the mutex contains `WriteLockHeld (Just <id>)`, then the lock is held by a writer.
+  , w :: Mutex WriteLockHeld
+  -- Ref containing the MutexGuard for `w`.
+  --
+  -- When a held WriteGuard or the final held ReadGuard is released, the guard contained will be
+  -- released, and `Nothing` will be written here.
+  , wLock :: Ref $ Maybe $ Mutex.Guard WriteLockHeld
+  -- Ref tracking active readers
+  , readers :: Mutex $ Set Int
+  -- The data contained in the RWLock
+  , state :: Ref a
+  }
+
+-- | Internal
+-- |
+-- | Guarantees that no other `fenced` sections
+-- | run concurrently with this one.
+fenced :: forall a r. RWLock a -> Aff r -> Aff r
+fenced (RWLock { fence }) m = do
+  g <- Mutex.lock fence
+  m <* liftEffect (Mutex.release g)
+
+-- | A guard with read access to data of type `a`
+data ReadGuard a = ReadGuard Int (RWLock a)
+
+-- | A guard with read+write access to data of type `a`
+data WriteGuard a = WriteGuard Int (RWLock a)
+
+-- | Acquire a write-access lock to the data
+-- | contained in the RWLock.
+-- |
+-- | If another thread holds a `ReadGuard` or `WriteGuard`,
+-- | this will block until the data is writable.
+lockWrite :: forall a. RWLock a -> Aff (WriteGuard a)
+lockWrite rw@(RWLock { id: idRef, w, wLock }) = do
+  id <- liftEffect $ Ref.modify (_ + 1) idRef
+  g <- Mutex.lock w
+  liftEffect $ Mutex.write g $ WriteLockHeld $ Just id
+  liftEffect $ Ref.write (Just g) wLock
+  pure $ WriteGuard id rw
+
+-- | Acquire a write-access lock to the data
+-- | contained in the RWLock.
+-- |
+-- | If another thread holds a `ReadGuard` or `WriteGuard`,
+-- | this will return Nothing.
+tryLockWrite :: forall a. RWLock a -> Aff (Maybe (WriteGuard a))
+tryLockWrite rw =
+  fenced rw
+    $ liftEffect (locked rw) >>= case _ of
+        Unlocked -> Just <$> lockWrite rw
+        _ -> pure Nothing
+
+-- | Acquire a read-access lock to the data
+-- | contained in the RWLock.
+-- |
+-- | If another thread holds a `WriteGuard`,
+-- | this will block until the data is readable.
+lockRead :: forall a. RWLock a -> Aff (ReadGuard a)
+lockRead rw@(RWLock { fence, id: idRef, w, wLock, readers: readersM }) = do
+  fenceG <- Mutex.lock fence
+  id <- liftEffect $ Ref.modify (_ + 1) idRef
+  l <- liftEffect $ locked rw
+  let
+    block = do
+      wl' <- Mutex.lock w
+      liftEffect $ Mutex.write wl' (WriteLockHeld Nothing)
+      liftEffect $ Ref.write (Just wl') wLock
+    done = liftEffect (Mutex.release fenceG)
+
+  fenceG' <- case l of
+    LockedReading -> pure fenceG
+    LockedWriting -> done *> block *> Mutex.lock fence
+    Unlocked -> block $> fenceG
+
+  readersG <- Mutex.lock readersM
+  liftEffect do
+    readers <- Mutex.read readersG
+    Mutex.write readersG $ Set.insert id readers
+    Mutex.release readersG
+    Mutex.release fenceG'
+  pure $ ReadGuard id rw
+
+-- | Acquire a read-access lock to the data
+-- | contained in the RWLock.
+-- |
+-- | If another thread holds a `WriteGuard`,
+-- | this will return Nothing.
+tryLockRead :: forall a. RWLock a -> Aff (Maybe (ReadGuard a))
+tryLockRead rw =
+  liftEffect (locked rw) >>= case _ of
+      LockedWriting -> pure Nothing
+      _ -> Just <$> lockRead rw
+
+-- | Create a new RWLock
+rwLock :: forall a. a -> Effect (RWLock a)
+rwLock a = do
+  fence <- Mutex.mutex unit
+  id <- liftEffect $ Ref.new 0
+  w <- Mutex.mutex $ WriteLockHeld Nothing
+  wLock <- liftEffect $ Ref.new Nothing
+  readers <- Mutex.mutex Set.empty
+  state <- liftEffect $ Ref.new a
+  pure $ RWLock { fence, id, w, wLock, readers, state }
+
+-- | Typeclass implemented by `WriteGuard` and `ReadGuard`
+-- | allowing a common `release` + `read` function (as opposed
+-- | to `releaseRead`, `releaseWrite`, etc.)
+class RWLockGuard g where
+  release :: forall a. g a -> Aff Unit
+  read :: forall a. g a -> Aff a
+
+instance RWLockGuard WriteGuard where
+  release w@(WriteGuard _ rw@(RWLock { wLock })) =
+    fenced rw $ void $ liftEffect do
+      g <- _writeGuardOk w
+      Ref.write Nothing wLock
+      Mutex.release g
+  read (WriteGuard id rw@(RWLock { state, wLock })) =
+    fenced rw $ liftEffect do
+      mg <- Ref.read wLock
+      g <- liftMaybe (error "WriteGuard has been released!") mg
+      WriteLockHeld id' <- Mutex.read g
+      when (Just id /= id') $ throwError $ error "WriteGuard has been released!"
+      Ref.read state
+
+instance RWLockGuard ReadGuard where
+  release (ReadGuard id rw@(RWLock { wLock, readers: readersM })) =
+    fenced rw $ void $ runMaybeT do
+      readersG <- lift $ Mutex.lock readersM
+      readers <- liftEffect $ Mutex.read readersG
+      guard $ elem id readers
+      liftEffect do
+        Mutex.write readersG $ Set.delete id readers
+        empty <- ((_ == 0) <<< Set.size) <$> Mutex.read readersG
+        Mutex.release readersG
+        when empty $ Ref.read wLock >>= traverse_ \g -> do
+          Ref.write Nothing wLock
+          Mutex.release g
+  read (ReadGuard id rw@(RWLock { readers: readersM, state })) =
+    fenced rw do
+      readersG <- Mutex.lock readersM
+      readers <- liftEffect $ Mutex.read readersG
+      when (not $ elem id readers) $ throwError $ error "ReadGuard has been released!"
+      liftEffect $ Mutex.release readersG
+      liftEffect $ Ref.read state
+
+_writeGuardOk :: forall a. WriteGuard a -> Effect (Mutex.Guard WriteLockHeld)
+_writeGuardOk (WriteGuard id (RWLock { wLock })) = do
+  mg <- Ref.read wLock
+  g <- liftMaybe (error "WriteGuard has been released!") mg
+  WriteLockHeld id' <- Mutex.read g
+  when (Just id /= id') $ throwError $ error "WriteGuard has been released!"
+  pure g
+
+-- | Writes a new value
+write :: forall a. WriteGuard a -> a -> Effect Unit
+write w@(WriteGuard _ (RWLock { state })) a = do
+  void $ _writeGuardOk w
+  Ref.write a state
+
+-- | Asks what state the RWLock is currently in
+locked :: forall a. RWLock a -> Effect Locked
+locked (RWLock { wLock }) = do
+  Ref.read wLock
+    >>= traverse Mutex.read
+    >>= case _ of
+      Nothing -> pure Unlocked
+      Just (WriteLockHeld Nothing) -> pure LockedReading
+      Just (WriteLockHeld (Just _)) -> pure LockedWriting
+
+-- | Get the value currently in the RWLock.
+-- |
+-- | Shorthand for `lockRead rw >>= (\l -> read l <* release l)`
+get :: forall a. RWLock a -> Aff a
+get rw = lockRead rw >>= (\l -> read l <* release l)
+
+-- | Write a new value to the RWLock.
+-- |
+-- | Shorthand for `lockWrite rw >>= (\l -> liftEffect (write l a) <* release l)`
+put :: forall a. RWLock a -> a -> Aff Unit
+put rw a = lockWrite rw >>= (\l -> liftEffect (write l a) <* release l)
+
+-- | Modify the value in the RWLock using the provided function.
+modify :: forall a. RWLock a -> (a -> a) -> Aff a
+modify rw f = do
+  l <- lockWrite rw
+  a <- f <$> read l
+  liftEffect (write l a) *> release l $> a
+
+-- | Shorthand for `void $ modify rw f`
+modify_ :: forall a. RWLock a -> (a -> a) -> Aff Unit
+modify_ rw f = void $ modify rw f

src/Threading.Handle.purs

@@ -0,0 +1,3 @@
+module Threading.Handle where
+
+data Handle = Handle

src/Threading.purs

@@ -0,0 +1 @@
+module Threading where

test/Test/Main.purs

@@ -5,10 +5,19 @@ import Prelude
 import Data.Maybe (Maybe(..))
 import Effect (Effect)
 import Effect.Aff (launchAff_)
-import Test.Pipes.CBOR as Test.Pipes.CBOR
+import Effect.Aff as Aff
+import Test.Spec (it)
 import Test.Spec.Reporter (specReporter)
 import Test.Spec.Runner (defaultConfig, runSpec')
+import Test.Threading.Barrier as Test.Threading.Barrier
+import Test.Threading.Channel as Test.Threading.Channel
+import Test.Threading.Data.Mutex as Test.Threading.Data.Mutex
+import Test.Threading.Data.RWLock as Test.Threading.Data.RWLock
 
 main :: Effect Unit
-main = launchAff_ $ runSpec' (defaultConfig { failFast = true, timeout = Nothing }) [ specReporter ] do
-  Test.Pipes.CBOR.spec
+main = launchAff_ $ Aff.supervise $ runSpec' (defaultConfig { failFast = true, timeout = Nothing }) [ specReporter ] do
+  Test.Threading.Data.Mutex.spec
+  Test.Threading.Data.RWLock.spec
+  Test.Threading.Channel.spec
+  Test.Threading.Barrier.spec
+  it "all tests were run" $ pure unit

test/Test/Pipes.CSV.purs

@@ -1,87 +0,0 @@
-module Test.Pipes.CBOR where
-
-import Prelude
-
-import Control.Monad.Cont (lift)
-import Control.Monad.Gen (chooseInt)
-import Data.Array as Array
-import Data.DateTime (DateTime)
-import Data.List ((:))
-import Data.List as List
-import Data.Maybe (Maybe(..), fromJust)
-import Data.Newtype (wrap)
-import Data.PreciseDateTime (fromRFC3339String, toDateTimeLossy)
-import Data.Tuple.Nested ((/\))
-import Effect (Effect)
-import Effect.Aff (delay)
-import Effect.CBOR as CBOR
-import Effect.Class (liftEffect)
-import Node.Buffer (Buffer)
-import Node.Buffer as Buffer
-import Node.Encoding (Encoding(..))
-import Partial.Unsafe (unsafePartial)
-import Pipes (yield, (>->))
-import Pipes.CBOR as Pipes.CBOR
-import Pipes.Collect as Pipes.Collect
-import Pipes.Node.Stream as Pipes.Stream
-import Pipes.Prelude (toListM) as Pipes
-import Test.QuickCheck.Gen (randomSample')
-import Test.Spec (Spec, before, describe, it)
-import Test.Spec.Assertions (shouldEqual)
-
-cborHex :: String
-cborHex = "82b90002646e616d656568656e72796174c1fb41d990ee6d671aa0b90002646e616d65656a756c696f6174c1fbc1d756dad0bbb646"
-
-cborBuf :: Effect Buffer
-cborBuf = Buffer.fromString cborHex Hex
-
-exp :: Array {name :: String, t :: DateTime}
-exp =
-  [{name: "henry", t: toDateTimeLossy $ unsafePartial fromJust $ fromRFC3339String $ wrap "2024-05-14T19:21:25.611Z"}
-  ,{name: "julio", t: toDateTimeLossy $ unsafePartial fromJust $ fromRFC3339String $ wrap "1920-05-14T20:21:17.067Z"}
-  ]
-
-
-dt :: String -> DateTime
-dt = toDateTimeLossy <<< unsafePartial fromJust <<< fromRFC3339String <<< wrap
-
-spec :: Spec Unit
-spec =
-  describe "Pipes.CBOR" do
-    it "encode" do
-      bytes
-        <- Pipes.Collect.toBuffer
-          $ Pipes.Stream.withEOS (yield exp)
-             >-> Pipes.CBOR.encode
-             >-> Pipes.Stream.unEOS
-      act <- liftEffect $ CBOR.decode bytes
-      act `shouldEqual` exp
-
-    describe "parse" do
-      it "parses csv" do
-        buf <- liftEffect $ cborBuf
-        rows <- Pipes.toListM
-          $ Pipes.Stream.withEOS (yield buf *> lift (delay $ wrap 10.0))
-              >-> Pipes.CBOR.decode
-
-        rows `shouldEqual` ((Just exp) : Nothing : List.Nil)
-      before
-        (do
-          nums <- liftEffect $ randomSample' 100000 (chooseInt 0 9)
-          let
-            objs = (\n -> {id: n}) <$> nums
-          bytes <-
-            Pipes.Collect.toBuffer
-            $ Pipes.Stream.withEOS (yield objs)
-              >-> Pipes.CBOR.encode
-              >-> Pipes.Stream.unEOS
-          pure $ nums /\ bytes
-        )
-        $ it "parses large csv" \(nums /\ bytes) -> do
-          rows <-
-            Pipes.Collect.toArray
-              $ Pipes.Stream.withEOS (yield bytes)
-                  >-> Pipes.CBOR.decode @(Array {id :: Int})
-                  >-> Pipes.Stream.unEOS
-
-          rows `shouldEqual` [(\id -> { id }) <$> nums]

test/Test/Threading.Barrier.purs

@@ -0,0 +1,41 @@
+module Test.Threading.Barrier where
+
+import Prelude
+
+import Data.Newtype (wrap)
+import Effect.Aff as Aff
+import Effect.Class (liftEffect)
+import Effect.Ref as Ref
+import Test.Spec (Spec, describe, it)
+import Test.Spec.Assertions (shouldEqual)
+import Threading.Barrier as Barrier
+
+spec :: Spec Unit
+spec =
+  describe "Threading.Barrier" do
+    it "creates" do
+      void $ liftEffect $ Barrier.barrier 1
+    it "barrer 1 >>= wait immediately resolves" do
+      b <- liftEffect $ Barrier.barrier 1
+      Barrier.wait b
+    it "barrer only resolves when all 3 threads wait" do
+      barrier <- liftEffect $ Barrier.barrier 3
+
+      aDone <- liftEffect $ Ref.new false
+      bDone <- liftEffect $ Ref.new false
+      a <- Aff.forkAff do
+        Barrier.wait barrier
+        liftEffect $ Ref.write true aDone
+      b <- Aff.forkAff do
+        Barrier.wait barrier
+        liftEffect $ Ref.write true bDone
+
+      Aff.delay $ wrap 10.0
+      liftEffect (Ref.read aDone) >>= shouldEqual false
+      liftEffect (Ref.read bDone) >>= shouldEqual false
+
+      Barrier.wait barrier
+      Aff.joinFiber a
+      Aff.joinFiber b
+      liftEffect (Ref.read aDone) >>= shouldEqual true
+      liftEffect (Ref.read bDone) >>= shouldEqual true

test/Test/Threading.Channel.purs

@@ -0,0 +1,91 @@
+module Test.Threading.Channel where
+
+import Prelude
+
+import Control.Monad.Rec.Class (Step(..), tailRecM)
+import Data.Array as Array
+import Data.Maybe (Maybe(..), isNothing, maybe)
+import Data.Traversable (traverse)
+import Effect.Aff as Aff
+import Effect.Class (liftEffect)
+import Effect.Console as Console
+import Test.Spec (Spec, describe, it)
+import Test.Spec.Assertions (expectError, shouldEqual)
+import Threading.Channel as Channel
+
+spec :: Spec Unit
+spec =
+  describe "Threading.Channel" do
+    describe "channel" do
+      it "creates" $ liftEffect $ void $ Channel.channel
+    describe "receiver" do
+      it "creates" do
+        c <- liftEffect $ Channel.channel
+        void $ Channel.receiver c
+    describe "Sender" do
+      describe "send" do
+        it "does nothing when no receivers" do
+          c <- liftEffect $ Channel.channel
+          s <- liftEffect $ Channel.sender c
+          Channel.send s 0
+        it "broadcasts to multiple receivers" do
+          c <- liftEffect $ Channel.channel
+          s <- liftEffect $ Channel.sender c
+          ra <- Channel.receiver c
+          rb <- Channel.receiver c
+          fiber <- Aff.forkAff $ traverse Channel.recv [ ra, rb ]
+          Channel.send s 100
+          as <- Aff.joinFiber fiber
+          as `shouldEqual` [ 100, 100 ]
+    describe "Receiver" do
+      describe "recv" do
+        it "throws if multiple fibers blocking" do
+          c <- liftEffect $ Channel.channel
+          r <- Channel.receiver c
+          void $ Aff.forkAff $ Channel.recv r
+          expectError $ Channel.recv r
+        it "recv resolves with messages in the order they were sent" do
+          c <- liftEffect $ Channel.channel
+          s <- liftEffect $ Channel.sender c
+          r <- Channel.receiver c
+          Channel.send s $ Just 1
+          Channel.send s $ Just 2
+          Channel.send s $ Just 3
+          Channel.send s $ Just 4
+          fiber <- Aff.forkAff $ flip tailRecM [] \as -> maybe (Done as) (Loop <<< Array.snoc as) <$> Channel.recv r
+          Channel.send s $ Just 5
+          Channel.send s Nothing
+          as <- Aff.joinFiber fiber
+          as `shouldEqual` [ 1, 2, 3, 4, 5 ]
+        it "blocks until a message is sent" do
+          c <- liftEffect $ Channel.channel
+          s <- liftEffect $ Channel.sender c
+          r <- Channel.receiver c
+          fiber <- Aff.forkAff $ Channel.recv r
+          Channel.send s 10
+          a <- Aff.joinFiber fiber
+          a `shouldEqual` 10
+        it "immediately resolves if a message buffered" do
+          c <- liftEffect $ Channel.channel
+          s <- liftEffect $ Channel.sender c
+          r <- Channel.receiver c
+          Channel.send s 10
+          a <- Channel.recv r
+          a `shouldEqual` 10
+      describe "tryRecv" do
+        it "returns Nothing when no data has been sent" do
+          c <- liftEffect $ Channel.channel
+          r <- Channel.receiver c
+          ma <- Channel.tryRecv r
+          isNothing ma `shouldEqual` true
+        it "returns Just when a message has been buffered" do
+          c <- liftEffect $ Channel.channel
+          s <- liftEffect $ Channel.sender c
+          r <- Channel.receiver c
+          Channel.send s 10
+          ma <- Channel.tryRecv r
+          ma `shouldEqual` (Just 10)
+    describe "sender" do
+      it "creates" do
+        c <- liftEffect $ Channel.channel
+        void $ liftEffect $ Channel.sender c

test/Test/Threading.Data.Mutex.purs

@@ -0,0 +1,157 @@
+module Test.Threading.Data.Mutex where
+
+import Prelude
+
+import Control.Monad.Error.Class (liftEither, liftMaybe)
+import Control.Parallel (parOneOf)
+import Data.Either (Either(..))
+import Data.Maybe (isNothing)
+import Data.Time.Duration (Milliseconds(..))
+import Data.Traversable (for_)
+import Effect.Aff as Aff
+import Effect.Class (liftEffect)
+import Effect.Exception (error)
+import Effect.Ref as Ref
+import Test.Spec (Spec, describe, it, pending')
+import Test.Spec.Assertions (expectError, shouldEqual)
+import Threading.Data.Mutex as Mutex
+
+spec :: Spec Unit
+spec =
+  describe "Threading.Data.Mutex" do
+    describe "mutex" do
+      it "creates" $ liftEffect $ void $ Mutex.mutex 0
+    describe "read" do
+      it "reads the value" do
+        m <- liftEffect $ Mutex.mutex 0
+        g <- Mutex.lock m
+        v <- liftEffect $ Mutex.read g
+        v `shouldEqual` 0
+      it "throws if released" do
+        m <- liftEffect $ Mutex.mutex 0
+        g <- Mutex.lock m
+        liftEffect $ Mutex.release g
+        expectError $ liftEffect $ Mutex.read g
+    describe "write" do
+      it "writes the value" do
+        m <- liftEffect $ Mutex.mutex 0
+        g <- Mutex.lock m
+        liftEffect $ Mutex.write g 1
+        v <- liftEffect $ Mutex.read g
+        v `shouldEqual` 1
+      it "throws if released" do
+        m <- liftEffect $ Mutex.mutex 0
+        g <- Mutex.lock m
+        liftEffect $ Mutex.release g
+        expectError $ liftEffect $ Mutex.write g 1
+    describe "get" do
+      it "yields immediately when unlocked" do
+        m <- liftEffect $ Mutex.mutex 0
+        val <- Mutex.get m
+        val `shouldEqual` 0
+      it "blocks until unlocked" do
+        m <- liftEffect $ Mutex.mutex 0
+        g <- Mutex.lock m
+        getFiber <- Aff.forkAff $ Mutex.get m
+        liftEffect $ Mutex.write g 1
+        liftEffect $ Mutex.release g
+        read <- Aff.joinFiber getFiber
+        read `shouldEqual` 1
+    describe "put" do
+      it "yields immediately when unlocked" do
+        m <- liftEffect $ Mutex.mutex 0
+        Mutex.put m 1
+        val <- Mutex.get m
+        val `shouldEqual` 1
+      it "blocks until unlocked" do
+        m <- liftEffect $ Mutex.mutex 0
+        g <- Mutex.lock m
+        getFiber <- Aff.forkAff $ Mutex.put m 2
+        liftEffect $ Mutex.write g 1
+        liftEffect $ Mutex.release g
+        Aff.joinFiber getFiber
+        val <- Mutex.get m
+        val `shouldEqual` 2
+    describe "modify" do
+      it "yields immediately when unlocked" do
+        m <- liftEffect $ Mutex.mutex 0
+        val <- Mutex.modify m (_ + 1)
+        val `shouldEqual` 1
+      it "blocks until unlocked" do
+        m <- liftEffect $ Mutex.mutex 0
+        g <- Mutex.lock m
+        getFiber <- Aff.forkAff $ Mutex.modify m (_ * 10)
+        liftEffect $ Mutex.write g 1
+        liftEffect $ Mutex.release g
+        val <- Aff.joinFiber getFiber
+        val `shouldEqual` 10
+    describe "lock" do
+      it "yields immediately when unlocked" do
+        m <- liftEffect $ Mutex.mutex 0
+        void $ Mutex.lock m
+      it "blocks when locked" do
+        m <- liftEffect $ Mutex.mutex 0
+        g <- Mutex.lock m
+        finished <- liftEffect $ Ref.new false
+        fiber <- Aff.forkAff do
+          void $ Mutex.lock m
+          void $ liftEffect $ Ref.write true finished
+        Aff.delay $ Milliseconds 5.0
+        f1 <- liftEffect $ Ref.read finished
+        f1 `shouldEqual` false
+        liftEffect $ Mutex.release g
+        Aff.joinFiber fiber
+        f2 <- liftEffect $ Ref.read finished
+        f2 `shouldEqual` true
+      it "locks are acquired in the order they were requested" do
+        m <- liftEffect $ Mutex.mutex 0
+        g <- Mutex.lock m
+        a <- Aff.forkAff $ Mutex.modify_ m (_ + 1) -- 1
+        b <- Aff.forkAff $ Mutex.modify_ m (_ * 10) -- 10
+        c <- Aff.forkAff $ Mutex.modify_ m (_ + 10) -- 20
+        d <- Aff.forkAff $ Mutex.modify_ m (_ * 10) -- 200
+        liftEffect $ Mutex.release g
+        for_ [ a, b, c, d ] Aff.joinFiber
+        n <- Mutex.get m
+        n `shouldEqual` 200
+      pending' "should be (eventually) unlocked if a fiber exits without releasing the lock" do
+        m <- liftEffect $ Mutex.mutex 0
+        -- Fiber acquires a lock then immediately resolves without releasing.
+        --
+        -- When the GC reclaims the guard object, the Mutex should notice and behave
+        -- as if it was explicitly released.
+        void $ Aff.forkAff $ void $ Mutex.lock m
+        liftEither =<< parOneOf
+          [ Aff.delay (Milliseconds 20000.0) $> Left (error "timed out waiting for GC to reclaim lock")
+          , Mutex.lock m $> Right unit
+          ]
+    describe "tryLock" do
+      it "returns Just when unlocked" do
+        m <- liftEffect $ Mutex.mutex 0
+        void $ liftMaybe (error $ "Mutex.tryLock returned Nothing on new mutex") =<< liftEffect (Mutex.tryLock m)
+      it "returns Nothing when locked" do
+        m <- liftEffect $ Mutex.mutex 0
+        _ <- liftMaybe (error $ "Mutex.tryLock returned Nothing on new mutex") =<< liftEffect (Mutex.tryLock m)
+        g <- liftEffect (Mutex.tryLock m)
+        isNothing g `shouldEqual` true
+      it "returns Just after release" do
+        m <- liftEffect $ Mutex.mutex 0
+        g <- liftMaybe (error $ "Mutex.tryLock returned Nothing on new mutex") =<< liftEffect (Mutex.tryLock m)
+        liftEffect $ Mutex.release g
+        void $ liftMaybe (error $ "Mutex.tryLock returned Nothing after lock released") =<< liftEffect (Mutex.tryLock m)
+    describe "locked" do
+      it "is false when unlocked" do
+        m <- liftEffect $ Mutex.mutex 0
+        l <- liftEffect $ Mutex.locked m
+        l `shouldEqual` false
+      it "is true when locked" do
+        m <- liftEffect $ Mutex.mutex 0
+        _ <- liftMaybe (error $ "Mutex.tryLock returned Nothing on new mutex") =<< liftEffect (Mutex.tryLock m)
+        l <- liftEffect $ Mutex.locked m
+        l `shouldEqual` true
+      it "is false after lock released" do
+        m <- liftEffect $ Mutex.mutex 0
+        g <- liftMaybe (error $ "Mutex.tryLock returned Nothing on new mutex") =<< liftEffect (Mutex.tryLock m)
+        liftEffect $ Mutex.release g
+        l' <- liftEffect $ Mutex.locked m
+        l' `shouldEqual` false

test/Test/Threading.Data.RWLock.purs

@@ -0,0 +1,203 @@
+module Test.Threading.Data.RWLock where
+
+import Prelude
+
+import Control.Monad.Error.Class (liftMaybe)
+import Data.Maybe (isNothing)
+import Data.Time.Duration (Milliseconds(..))
+import Data.Traversable (for_)
+import Effect.Aff as Aff
+import Effect.Class (liftEffect)
+import Effect.Console as Console
+import Effect.Exception (error)
+import Effect.Ref as Ref
+import Test.Spec (Spec, describe, it)
+import Test.Spec.Assertions (expectError, shouldEqual)
+import Threading.Data.RWLock as RWLock
+
+spec :: Spec Unit
+spec =
+  describe "Threading.Data.RWLock" do
+    describe "rwLock" do
+      it "creates" $ liftEffect $ void $ RWLock.rwLock 0
+    describe "read" do
+      it "reads the value" do
+        m <- liftEffect $ RWLock.rwLock 0
+        g <- RWLock.lockRead m
+        v <- RWLock.read g
+        v `shouldEqual` 0
+      it "throws if released" do
+        m <- liftEffect $ RWLock.rwLock 0
+        g <- RWLock.lockRead m
+        RWLock.release g
+        expectError $ RWLock.read g
+    describe "write" do
+      it "writes the value" do
+        m <- liftEffect $ RWLock.rwLock 0
+        g <- RWLock.lockWrite m
+        liftEffect $ RWLock.write g 1
+        v <- RWLock.read g
+        v `shouldEqual` 1
+      it "throws if released" do
+        m <- liftEffect $ RWLock.rwLock 0
+        g <- RWLock.lockWrite m
+        RWLock.release g
+        expectError $ liftEffect $ RWLock.write g 1
+    describe "get" do
+      it "yields immediately when unlocked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        val <- RWLock.get m
+        val `shouldEqual` 0
+      it "blocks until unlocked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        g <- RWLock.lockWrite m
+        getFiber <- Aff.forkAff $ RWLock.get m
+        liftEffect $ RWLock.write g 1
+        RWLock.release g
+        read <- Aff.joinFiber getFiber
+        read `shouldEqual` 1
+    describe "put" do
+      it "yields immediately when unlocked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        RWLock.put m 1
+        val <- RWLock.get m
+        val `shouldEqual` 1
+      it "blocks until unlocked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        g <- RWLock.lockWrite m
+        getFiber <- Aff.forkAff $ RWLock.put m 2
+        liftEffect $ RWLock.write g 1
+        RWLock.release g
+        Aff.joinFiber getFiber
+        val <- RWLock.get m
+        val `shouldEqual` 2
+    describe "modify" do
+      it "yields immediately when unlocked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        val <- RWLock.modify m (_ + 1)
+        val `shouldEqual` 1
+      it "blocks until unlocked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        g <- RWLock.lockWrite m
+        getFiber <- Aff.forkAff $ RWLock.modify m (_ * 10)
+        liftEffect $ RWLock.write g 1
+        RWLock.release g
+        val <- Aff.joinFiber getFiber
+        val `shouldEqual` 10
+    describe "lockRead" do
+      it "yields immediately when unlocked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        void $ RWLock.lockRead m
+      it "blocks when write locked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        g <- RWLock.lockWrite m
+        finished <- liftEffect $ Ref.new false
+        fiber <- Aff.forkAff do
+          void $ RWLock.lockRead m
+          void $ liftEffect $ Ref.write true finished
+        Aff.delay $ Milliseconds 5.0
+        f1 <- liftEffect $ Ref.read finished
+        f1 `shouldEqual` false
+        RWLock.release g
+        Aff.joinFiber fiber
+        f2 <- liftEffect $ Ref.read finished
+        f2 `shouldEqual` true
+      it "does not block when read locked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        void $ Aff.forkAff $ void $ RWLock.lockRead m
+        void $ Aff.forkAff $ void $ RWLock.lockRead m
+        void $ RWLock.lockRead m
+        n <- RWLock.get m
+        n `shouldEqual` 0
+      it "blocks when write locked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        g <- RWLock.lockWrite m
+        finished <- liftEffect $ Ref.new false
+        fiber <- Aff.forkAff do
+          g' <- RWLock.lockRead m
+          liftEffect $ Ref.write true finished
+          RWLock.read g'
+        liftEffect $ RWLock.write g 1
+        f <- liftEffect $ Ref.read finished
+        f `shouldEqual` false
+        RWLock.release g
+        n <- Aff.joinFiber fiber
+        n `shouldEqual` 1
+    describe "lockWrite" do
+      it "yields immediately when unlocked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        void $ RWLock.lockWrite m
+      it "blocks when write locked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        g <- RWLock.lockWrite m
+        finished <- liftEffect $ Ref.new false
+        fiber <- Aff.forkAff do
+          void $ RWLock.lockWrite m
+          void $ liftEffect $ Ref.write true finished
+        Aff.delay $ Milliseconds 5.0
+        f1 <- liftEffect $ Ref.read finished
+        f1 `shouldEqual` false
+        RWLock.release g
+        Aff.joinFiber fiber
+        f2 <- liftEffect $ Ref.read finished
+        f2 `shouldEqual` true
+      it "blocks when read locked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        g <- RWLock.lockRead m
+        finished <- liftEffect $ Ref.new false
+        fiber <- Aff.forkAff do
+          void $ RWLock.lockWrite m
+          void $ liftEffect $ Ref.write true finished
+        Aff.delay $ Milliseconds 5.0
+        f1 <- liftEffect $ Ref.read finished
+        f1 `shouldEqual` false
+        RWLock.release g
+        Aff.joinFiber fiber
+        f2 <- liftEffect $ Ref.read finished
+        f2 `shouldEqual` true
+      it "locks are acquired in the order they were requested" do
+        m <- liftEffect $ RWLock.rwLock 0
+        g <- RWLock.lockWrite m
+        a <- Aff.forkAff $ RWLock.modify_ m (_ + 1) -- 1
+        b <- Aff.forkAff $ RWLock.modify_ m (_ * 10) -- 10
+        c <- Aff.forkAff $ RWLock.modify_ m (_ + 10) -- 20
+        d <- Aff.forkAff $ RWLock.modify_ m (_ * 10) -- 200
+        RWLock.release g
+        for_ [ a, b, c, d ] Aff.joinFiber
+        n <- RWLock.get m
+        n `shouldEqual` 200
+    describe "tryLockWrite" do
+      it "returns Just when unlocked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        void $ liftMaybe (error $ "RWLock.tryLockWrite returned Nothing on new mutex") =<< RWLock.tryLockWrite m
+      it "returns Nothing when locked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        _ <- liftMaybe (error $ "RWLock.tryLockWrite returned Nothing on new mutex") =<< RWLock.tryLockWrite m
+        g <- RWLock.tryLockWrite m
+        isNothing g `shouldEqual` true
+      it "returns Just after release" do
+        m <- liftEffect $ RWLock.rwLock 0
+        g <- liftMaybe (error $ "RWLock.tryLockWrite returned Nothing on new mutex") =<< RWLock.tryLockWrite m
+        RWLock.release g
+        void $ liftMaybe (error $ "RWLock.tryLockWrite returned Nothing after lock released") =<< RWLock.tryLockWrite m
+    describe "locked" do
+      it "Unlocked" do
+        m <- liftEffect $ RWLock.rwLock 0
+        l <- liftEffect $ RWLock.locked m
+        l `shouldEqual` RWLock.Unlocked
+      it "LockedWriting" do
+        m <- liftEffect $ RWLock.rwLock 0
+        _ <- liftMaybe (error $ "RWLock.tryLockWrite returned Nothing on new mutex") =<< RWLock.tryLockWrite m
+        l <- liftEffect $ RWLock.locked m
+        l `shouldEqual` RWLock.LockedWriting
+      it "LockedReading" do
+        m <- liftEffect $ RWLock.rwLock 0
+        _ <- liftMaybe (error $ "RWLock.tryLockRead returned Nothing on new mutex") =<< RWLock.tryLockRead m
+        l <- liftEffect $ RWLock.locked m
+        l `shouldEqual` RWLock.LockedReading
+      it "Unlocked after lock released" do
+        m <- liftEffect $ RWLock.rwLock 0
+        g <- liftMaybe (error $ "RWLock.tryLockWrite returned Nothing on new mutex") =<< RWLock.tryLockWrite m
+        RWLock.release g
+        l' <- liftEffect $ RWLock.locked m
+        l' `shouldEqual` RWLock.Unlocked