purescript-bridge 0.3.2.0 → 0.4.0.0
raw patch · 12 files changed
+615/−933 lines, 12 filesdep +lensdep +mtldep +purescript-bridgedep ~base
Dependencies added: lens, mtl, purescript-bridge, transformers
Dependency ranges changed: base
Files
- LICENSE +24/−655
- purescript-bridge.cabal +16/−10
- src/Language/PureScript/Bridge.hs +36/−60
- src/Language/PureScript/Bridge/Builder.hs +211/−0
- src/Language/PureScript/Bridge/PSTypes.hs +47/−55
- src/Language/PureScript/Bridge/Primitives.hs +23/−20
- src/Language/PureScript/Bridge/Printer.hs +65/−47
- src/Language/PureScript/Bridge/SumType.hs +63/−33
- src/Language/PureScript/Bridge/Tuple.hs +10/−7
- src/Language/PureScript/Bridge/TypeInfo.hs +52/−40
- src/Language/PureScript/Bridge/TypeParameters.hs +13/−6
- test/Spec.hs +55/−0
LICENSE view
@@ -1,661 +1,30 @@- GNU AFFERO GENERAL PUBLIC LICENSE- Version 3, 19 November 2007-- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>- Everyone is permitted to copy and distribute verbatim copies- of this license document, but changing it is not allowed.-- Preamble-- The GNU Affero General Public License is a free, copyleft license for-software and other kinds of works, specifically designed to ensure-cooperation with the community in the case of network server software.-- The licenses for most software and other practical works are designed-to take away your freedom to share and change the works. By contrast,-our General Public Licenses are 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.-- 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.-- Developers that use our General Public Licenses protect your rights-with two steps: (1) assert copyright on the software, and (2) offer-you this License which gives you legal permission to copy, distribute-and/or modify the software.-- A secondary benefit of defending all users' freedom is that-improvements made in alternate versions of the program, if they-receive widespread use, become available for other developers to-incorporate. Many developers of free software are heartened and-encouraged by the resulting cooperation. However, in the case of-software used on network servers, this result may fail to come about.-The GNU General Public License permits making a modified version and-letting the public access it on a server without ever releasing its-source code to the public.-- The GNU Affero General Public License is designed specifically to-ensure that, in such cases, the modified source code becomes available-to the community. It requires the operator of a network server to-provide the source code of the modified version running there to the-users of that server. Therefore, public use of a modified version, on-a publicly accessible server, gives the public access to the source-code of the modified version.-- An older license, called the Affero General Public License and-published by Affero, was designed to accomplish similar goals. This is-a different license, not a version of the Affero GPL, but Affero has-released a new version of the Affero GPL which permits relicensing under-this license.-- 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 Affero 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. Remote Network Interaction; Use with the GNU General Public License.-- Notwithstanding any other provision of this License, if you modify the-Program, your modified version must prominently offer all users-interacting with it remotely through a computer network (if your version-supports such interaction) an opportunity to receive the Corresponding-Source of your version by providing access to the Corresponding Source-from a network server at no charge, through some standard or customary-means of facilitating copying of software. This Corresponding Source-shall include the Corresponding Source for any work covered by version 3-of the GNU General Public License that is incorporated pursuant to the-following paragraph.-- 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 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 work with which it is combined will remain governed by version-3 of the GNU General Public License.-- 14. Revised Versions of this License.-- The Free Software Foundation may publish revised and/or new versions of-the GNU Affero 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 Affero 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 Affero 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 Affero 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>+Copyright Robert Klotzner (c) 2016 - This program is free software: you can redistribute it and/or modify- it under the terms of the GNU Affero General Public License as published by- the Free Software Foundation, either version 3 of the License, or- (at your option) any later version.+All rights reserved. - 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 Affero General Public License for more details.+Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met: - You should have received a copy of the GNU Affero General Public License- along with this program. If not, see <http://www.gnu.org/licenses/>.+ * Redistributions of source code must retain the above copyright+ notice, this list of conditions and the following disclaimer. -Also add information on how to contact you by electronic and paper mail.+ * Redistributions in binary form must reproduce the above+ copyright notice, this list of conditions and the following+ disclaimer in the documentation and/or other materials provided+ with the distribution. - If your software can interact with users remotely through a computer-network, you should also make sure that it provides a way for users to-get its source. For example, if your program is a web application, its-interface could display a "Source" link that leads users to an archive-of the code. There are many ways you could offer source, and different-solutions will be better for different programs; see section 13 for the-specific requirements.+ * Neither the name of Robert Klotzner nor the names of other+ contributors may be used to endorse or promote products derived+ from this software without specific prior written permission. - 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 AGPL, see-<http://www.gnu.org/licenses/>.+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
purescript-bridge.cabal view
@@ -10,7 +10,7 @@ -- PVP summary: +-+------- breaking API changes -- | | +----- non-breaking API additions -- | | | +--- code changes with no API change-version: 0.3.2.0+version: 0.4.0.0 -- A short (one-line) description of the package. synopsis: Generate PureScript data types from Haskell data types@@ -19,7 +19,7 @@ -- description: -- The license under which the package is released.-license: AGPL-3+license: BSD3 -- The file containing the license text. license-file: LICENSE@@ -54,6 +54,7 @@ library -- Modules exported by the library. exposed-modules: Language.PureScript.Bridge+ , Language.PureScript.Bridge.Builder , Language.PureScript.Bridge.Primitives , Language.PureScript.Bridge.Printer , Language.PureScript.Bridge.PSTypes@@ -73,7 +74,10 @@ , containers , directory , filepath+ , mtl+ , lens , text+ , transformers , generic-deriving ghc-options: -Wall@@ -85,11 +89,13 @@ default-language: Haskell2010 --- Test-Suite tests--- type: detailed-0.9--- test-module: Tests--- build-depends: base--- , Cabal >= 1.9.2--- , HUnit--- , purescript-bridge--- hs-source-dirs: test+Test-Suite tests+ type: exitcode-stdio-1.0+ main-is: Spec.hs+ build-depends: base+ , containers+ -- , HUnit+ , purescript-bridge+ , text+ hs-source-dirs: test+ default-language: Haskell2010
src/Language/PureScript/Bridge.hs view
@@ -1,17 +1,20 @@+{-# LANGUAGE DataKinds #-} {-# LANGUAGE OverloadedStrings #-}+ module Language.PureScript.Bridge ( bridgeSumType , defaultBridge- , doBridge , module Bridge , writePSTypes ) where -import qualified Data.Text as T+import Control.Applicative+import qualified Data.Map as M import qualified Data.Text.IO as T +import Language.PureScript.Bridge.Builder as Bridge import Language.PureScript.Bridge.Primitives as Bridge import Language.PureScript.Bridge.Printer as Bridge import Language.PureScript.Bridge.SumType as Bridge@@ -19,11 +22,6 @@ import Language.PureScript.Bridge.TypeInfo as Bridge --import Control.Applicative-import qualified Data.Map as M-import Data.Maybe- -- | Your entry point to this library and quite likely all you will need. -- Make sure all your types derive Generic and Typeable. -- Typeable is not needed from ghc-7.10 on.@@ -31,31 +29,31 @@ -- Then list all your types you want to use in PureScript and call 'writePSTypes': -- -- > let myTypes = [--- > toSumType (Proxy :: Proxy MyType1)--- > , toSumType (Proxy :: Proxy MyType2)+-- > mkSumType (Proxy :: Proxy MyType1)+-- > , mkSumType (Proxy :: Proxy MyType2) -- > ] -- >--- > writePSTypes defaultBridge "path/to/your/purescript/project" myTypes+-- > writePSTypes (buildBridge defaultBridge) "path/to/your/purescript/project" myTypes -- -- You can define your own type bridges based on 'defaultBridge': -- ----- > myBridge = 'defaultBridge' <|> mySpecialTypeBridge+-- > myBridge = defaultBridge <|> mySpecialTypeBridge -- -- and use it with 'writePSTypes': ----- > writePSTypes myBridge "path/to/your/purescript/project" myTypes+-- > writePSTypes (buildBridge myBridge) "path/to/your/purescript/project" myTypes ----- Find examples for implementing your own type bridges in: "Language.PureScript.Bridge.Primitives".+-- Find examples for implementing your own bridges in: "Language.PureScript.Bridge.Primitives". -- -- == Result: -- 'writePSTypes' will write out PureScript modules to the given path, mirroring the hierarchy of the Haskell modules -- the types came from. In addition a list of needed PS packages is printed to the console. ----- The list of needed packages is retrieved from the bridged 'TypeInfo' data, so make sure you set 'typePackage' correctly+-- The list of needed packages is retrieved from the bridged 'TypeInfo' data, so make sure you set '_typePackage' correctly -- in your own bridges, in order for this feature to be useful. ----- == Real world usage example:+-- == Real world usage example (at time of this writing outdated, at time of reading hopefully fixed): -- A real world use case of this library can be found <https://github.com/gonimo/gonimo-back/blob/master/src/MkFrontendTypes.hs here>. -- -- With custom bridges defined <https://github.com/gonimo/gonimo-back/blob/master/src/Gonimo/TypeBridges.hs here> and@@ -64,11 +62,12 @@ -- Parts of the generated output can be found <https://github.com/gonimo/gonimo-front/blob/master/src/Gonimo/Types.purs here>. -- -- Note how 'Secret' and 'Key'--- get translated according to our custom rules, with correct imports and everything. Also the formatting is quite nice, I think - would you have guessed that this code was generated?+-- get translated according to our custom rules, with correct imports and everything.+-- Also the formatting is quite nice, would you have guessed that this code was generated? -- -- == /WARNING/: -- This function overwrites files - make backups or use version control!-writePSTypes :: TypeBridge -> FilePath -> [SumType] -> IO ()+writePSTypes :: FullBridge -> FilePath -> [SumType 'Haskell] -> IO () writePSTypes br root sts = do let bridged = map (bridgeSumType br) sts let modules = M.elems $ sumTypesToModules M.empty bridged@@ -78,26 +77,15 @@ let packages = sumTypesToNeededPackages bridged mapM_ (T.putStrLn . mappend " - ") packages --- | Translate leaf types in a sum type to match PureScript types.-bridgeSumType :: TypeBridge -> SumType -> SumType-bridgeSumType br (SumType t cs) = SumType fixedT $ map (bridgeConstructor br) cs- where- fixedT= t { typeParameters = map fixTypeParameters (typeParameters t)}---- | Translate types optimistically: If the passed 'TypeBridge' returns 'Nothing',--- then the original 'TypeInfo' is returned with the 'typePackage' field cleared.+-- | Translate all 'TypeInfo' values in a 'SumType' to PureScript types. ----- This function also recurses into all 'typeParameters' of the passed 'TypeInfo'.+-- Example usage, with defaultBridge: ----- You typically don't need to call this function directly, just use 'bridgeSumType' with your 'TypeBridge'.-doBridge :: TypeBridge -> TypeInfo -> TypeInfo-doBridge br info = let- translated = info { typePackage = "" }- res = fixTypeParameters $ fromMaybe translated (br info)- in- res {- typeParameters = map (doBridge br) . typeParameters $ res- }+-- > data Foo = Foo | Bar Int | FooBar Int Text deriving (Generic, Typeable, Show)+--+-- > bridgeSumType (buildBridge defaultBridge) (mkSumType (Proxy :: Proxy Foo))+bridgeSumType :: FullBridge -> SumType 'Haskell -> SumType 'PureScript+bridgeSumType br (SumType t cs) = SumType (br t) $ map (bridgeConstructor br) cs -- | Default bridge for mapping primitive/common types: -- You can append your own bridges like this:@@ -106,35 +94,23 @@ -- -- Find examples for bridge definitions in "Language.PureScript.Bridge.Primitives" and -- "Language.PureScript.Bridge.Tuple".-defaultBridge :: TypeBridge-defaultBridge t = stringBridge t- <|> listBridge t- <|> maybeBridge t- <|> eitherBridge t- <|> boolBridge t- <|> intBridge t- <|> tupleBridge t+defaultBridge :: BridgePart+defaultBridge = textBridge+ <|> listBridge+ <|> maybeBridge+ <|> eitherBridge+ <|> boolBridge+ <|> intBridge+ <|> tupleBridge+ <|> stringBridge -- | Translate types in a constructor.-bridgeConstructor :: TypeBridge -> DataConstructor -> DataConstructor+bridgeConstructor :: FullBridge -> DataConstructor 'Haskell -> DataConstructor 'PureScript bridgeConstructor br (DataConstructor name (Left infos)) =- DataConstructor name . Left $ map (doBridge br) infos+ DataConstructor name . Left $ map br infos bridgeConstructor br (DataConstructor name (Right record)) = DataConstructor name . Right $ map (bridgeRecordEntry br) record -- | Translate types in a record entry.-bridgeRecordEntry :: TypeBridge -> RecordEntry -> RecordEntry-bridgeRecordEntry br (RecordEntry label value) = RecordEntry label $ doBridge br value---- | Translate types that come from any module named "Something.TypeParameters" to lower case:--- Also drop the 1 at the end if present-fixTypeParameters :: TypeInfo -> TypeInfo-fixTypeParameters t- | T.isSuffixOf "TypeParameters" (typeModule t) = t {- typePackage = "" -- Don't suggest any packages- , typeModule = "" -- Don't import any modules- , typeName = stripNum . T.toLower $ typeName t- }- | otherwise = t- where- stripNum v = fromMaybe v (T.stripSuffix "1" v)+bridgeRecordEntry :: FullBridge -> RecordEntry 'Haskell -> RecordEntry 'PureScript+bridgeRecordEntry br (RecordEntry label value) = RecordEntry label $ br value
+ src/Language/PureScript/Bridge/Builder.hs view
@@ -0,0 +1,211 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE TypeSynonymInstances #-}++-- | A bridge builder DSL, powered by 'Monad', 'Alternative' and lens.+--+-- Bridges can be built within the BridgeBuilder monad.+-- You can check properties of the to be bridged Haskell 'TypeInfo' with '^==' or 'doCheck',+-- you have choice ('<|>'), you can fail ('empty') and you can return a translated PureScript+-- 'TypeInfo' ('return'). The Haskell 'TypeInfo' can be accessed with:+--+-- > view haskType+--+-- Find usage examples in "Language.PureScript.Bridge.Primitives" and "Language.PureScript.Bridge.PSTypes"+module Language.PureScript.Bridge.Builder (+ FullBridge+, FixUpBridge+, BridgeData+, fullBridge+, BridgeBuilder+, BridgePart+, clearPackageFixUp+, errorFixUp+, buildBridge+, buildBridgeWithCustomFixUp+, doCheck+, (^==)+, (<|>)+, psTypeParameters+, fixTypeParameters+) where++import Control.Applicative+import Control.Lens+import Control.Monad (MonadPlus, guard, mplus,+ mzero)+import Control.Monad.Reader.Class+import Control.Monad.Trans.Reader (ReaderT (..))+import Data.Maybe (fromMaybe)+import Data.Monoid+import qualified Data.Text as T+import Language.PureScript.Bridge.TypeInfo++type FullBridge = TypeInfo 'Haskell -> TypeInfo 'PureScript++-- | Bridges to use when a 'BridgePart' returns 'Nothing'.+type FixUpBridge = FullBridge++data BridgeData = BridgeData {+ -- | The Haskell type to translate.+ _haskType :: TypeInfo 'Haskell+ -- | Reference to the bride itself, needed for translation of type constructors.+ , _fullBridge :: FullBridge+ }++-- | By implementing the 'haskType' lens in the HasHaskType class, we are able+-- to use it for both 'BridgeData' and a plain 'TypeInfo Haskell', therefore+-- you can use it with 'doCheck' and '^==' for checks on the complete 'TypeInfo Haskell'+-- value.+--+-- Example:+--+-- > stringBridge :: BridgePart+-- > stringBridge = do+-- > -- Note: we are using the TypeInfo 'Haskell instance here:+-- > haskType ^== mkTypeInfo (Proxy :: Proxy String)+-- > return psString+instance HasHaskType BridgeData where+ haskType inj (BridgeData iT fB) = flip BridgeData fB <$> inj iT++fullBridge :: Lens' BridgeData FullBridge+fullBridge inj (BridgeData iT fB) = BridgeData iT <$> inj fB++newtype BridgeBuilder a =+ BridgeBuilder (ReaderT BridgeData Maybe a)+ deriving (Functor, Applicative, Monad, MonadReader BridgeData)+++type BridgePart = BridgeBuilder (TypeInfo 'PureScript)++-- | Bridge to PureScript by simply clearing out the '_typePackage' field.+-- This bridge is used by default as 'FixUpBridge' by 'buildBridge':+--+-- > buildBridge = buildBridgeWithCustomFixUp clearPackageFixUp+--+-- Thus, if no bridge matches a type, it gets optimistically translated to a PureScript type+-- which is idential to the Haskell type. Only the '_typePackage' field gets cleared,+-- as it is very unlikely that the PureScript package is called the same as the Haskell package.+--+-- Alternatively, if you are not that optimistic, you can use errorFixUp+-- - which simply calls 'error' when used.+--+-- > buildBridgeWithCustomFixUp errorFixUp yourBridge+--+-- Of course you can also write your own 'FixUpBridge'.+-- In this case it is highly recommended that you build your custom 'FixUpBridge'+-- from 'BridgePart' with 'buildBridgeWithCustomFixUp' too, with 'FixUpBridge' being finally 'errorFixUp'.+-- This way you get all the builder convenience and proper bridging of 'typeParameters'.+-- For an example have a look at the implementation+-- of 'clearPackageFixup'.+clearPackageFixUp :: FixUpBridge+clearPackageFixUp = buildBridgeWithCustomFixUp errorFixUp $ do+ input <- view haskType+ psArgs <- psTypeParameters+ return TypeInfo {+ _typePackage = ""+ , _typeModule = input ^. typeModule+ , _typeName = input ^. typeName+ , _typeParameters = psArgs+ }++-- | A 'FixUpBridge' which calles 'error' when used.+-- Usage:+--+-- > buildBridgeWithCustomFixUp errorFixUp yourBridge+errorFixUp :: FixUpBridge+errorFixUp inType = let+ message = "No translation supplied for Haskell type: '"+ <> inType ^. typeName <> "', from module: '"+ <> inType ^. typeModule <> "', from package: '"+ <> inType ^. typePackage <> "'!"+ in+ error $ T.unpack message++-- | Build a bridge.+--+-- This is a convenience wrapper for 'buildBridgeWithCustomFixUp'.+--+-- Definition:+--+-- > buildBridgeWithCustomFixUp clearPackageFixUp+buildBridge :: BridgePart -> FullBridge+buildBridge = buildBridgeWithCustomFixUp clearPackageFixUp+++-- | Takes a constructed BridgePart and makes it a total function ('FullBridge')+-- by using the supplied 'FixUpBridge' when 'BridgePart' returns 'Nothing'.+--+-- The supplied 'BridgePart' also gets passed through 'fixTypeParameters' in+-- order to support translation of type constructors.+buildBridgeWithCustomFixUp :: FixUpBridge -> BridgePart -> FullBridge+buildBridgeWithCustomFixUp fixUp rawPart = let+ (BridgeBuilder bridgePart) = fixTypeParameters rawPart+ mayBridge :: TypeInfo 'Haskell -> Maybe (TypeInfo 'PureScript)+ mayBridge inType = runReaderT bridgePart $ BridgeData inType bridge+ bridge inType = fromMaybe (fixUp inType) (mayBridge inType)+ in+ bridge+++-- | Translate types that come from any module named "Something.TypeParameters" to lower case:+--+-- Also drop the 1 at the end if present.+-- This method gets called by 'buildBridge' and buildBridgeWithCustomFixUp for you - you should not need to call it.+--+-- It enables you to even bridge type constructor definitions, see "Language.PureScript.Bridge.TypeParameters" for more details.+fixTypeParameters :: BridgePart -> BridgePart+fixTypeParameters br = (needsFix >> fixIt) <|> br+ where+ needsFix = doCheck typeModule ("TypeParameters" `T.isSuffixOf`)+ fixIt = do+ r <- br+ return r {+ _typePackage = "" -- Don't suggest any packages+ , _typeModule = "" -- Don't import any modules+ , _typeName = r ^. typeName . to (stripNum . T.toLower)+ }+ stripNum v = fromMaybe v (T.stripSuffix "1" v)+++-- | Alternative instance for BridgeBuilder so you can construct bridges with '<|>',+-- which behaves like a logical 'or' ('||'). If the left-hand side results in Nothing+-- the right-hand side is used, otherwise the left-hand side.+-- For usage examples see "Language.PureScript.Bridge.Primitives".+instance Alternative BridgeBuilder where+ empty = BridgeBuilder . ReaderT $ const Nothing+ BridgeBuilder a <|> BridgeBuilder b = BridgeBuilder . ReaderT $ \bridgeData -> let+ ia = runReaderT a bridgeData+ ib = runReaderT b bridgeData+ in+ ia <|> ib++instance MonadPlus BridgeBuilder where+ mzero = empty+ mplus = (<|>)++-- | Do some check on properties of 'haskType'.+doCheck :: Getter (TypeInfo 'Haskell) a -> (a -> Bool) -> BridgeBuilder ()+doCheck l check = guard =<< views (haskType . l) check++-- | Check parts of 'haskType' for equality:+--+-- > textBridge :: BridgePart+-- > textBridge = do+-- > typeName ^== "Text"+-- > typeModule ^== "Data.Text.Internal" <|> typeModule ^== "Data.Text.Internal.Lazy"+-- > return psString+(^==) :: Eq a => Getter (TypeInfo 'Haskell) a -> a -> BridgeBuilder ()+l ^== a = doCheck l (== a)++infix 4 ^==++-- | Bridge 'haskType' 'typeParameters' over to PureScript types.+--+-- To be used for bridging type constructors.+psTypeParameters :: BridgeBuilder [TypeInfo 'PureScript]+psTypeParameters = map <$> view fullBridge <*> view (haskType . typeParameters)
src/Language/PureScript/Bridge/PSTypes.hs view
@@ -1,75 +1,67 @@-{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE TypeSynonymInstances #-}+ -- | PureScript types to be used for bridges, e.g. in "Language.PureScript.Bridge.Primitives". module Language.PureScript.Bridge.PSTypes where -import Data.Monoid-import qualified Data.Text as T+import Control.Lens (views)+import Data.Monoid+import qualified Data.Text as T -import Language.PureScript.Bridge.TypeInfo+import Language.PureScript.Bridge.Builder+import Language.PureScript.Bridge.TypeInfo --- | Uses type parameters from existing TypeInfo:-psArray :: TypeInfo -> TypeInfo-psArray t = t {- typePackage = "purescript-prim"- , typeModule = "Prim"- , typeName = "Array"- }+-- | Uses type parameters from 'haskType' (bridged).+psArray :: BridgePart+psArray = TypeInfo "purescript-prim" "Prim" "Array" <$> psTypeParameters -psBool :: TypeInfo+psBool :: TypeInfo 'PureScript psBool = TypeInfo {- typePackage = "purescript-prim"- , typeModule = "Prim"- , typeName = "Boolean"- , typeParameters = []+ _typePackage = "purescript-prim"+ , _typeModule = "Prim"+ , _typeName = "Boolean"+ , _typeParameters = [] } --- | Uses type parameters from existing TypeInfo:-psEither :: TypeInfo -> TypeInfo-psEither t = t {- typePackage = "purescript-either"- , typeModule = "Data.Either"- , typeName = "Either"- }+-- | Uses type parameters from 'haskType' (bridged).+psEither :: BridgePart+psEither = TypeInfo "purescript-either" "Data.Either" "Either" <$> psTypeParameters -psInt :: TypeInfo+psInt :: TypeInfo 'PureScript psInt = TypeInfo {- typePackage = "purescript-prim"- , typeModule = "Prim"- , typeName = "Int"- , typeParameters = []- }---- | Uses type parameters from existing TypeInfo:-psMaybe :: TypeInfo -> TypeInfo-psMaybe t = t {- typePackage = "purescript-maybe"- , typeModule = "Data.Maybe"- , typeName = "Maybe"+ _typePackage = "purescript-prim"+ , _typeModule = "Prim"+ , _typeName = "Int"+ , _typeParameters = [] } +-- | Uses type parameters from 'haskType' (bridged).+psMaybe :: BridgePart+psMaybe = TypeInfo "purescript-maybe" "Data.Maybe" "Maybe" <$> psTypeParameters -psString :: TypeInfo+psString :: TypeInfo 'PureScript psString = TypeInfo {- typePackage = "purescript-prim"- , typeModule = "Prim"- , typeName = "String"- , typeParameters = []+ _typePackage = "purescript-prim"+ , _typeModule = "Prim"+ , _typeName = "String"+ , _typeParameters = [] } --- | Uses type parameters from existing TypeInfo:-psTuple :: TypeInfo -> TypeInfo-psTuple t = t {- typePackage = "purescript-tuples"- , typeModule = if size == 2 then "Data.Tuple" else "Data.Tuple.Nested"- , typeName = "Tuple" <> if size == 2 then "" else T.pack (show size)- }- where- size = length (typeParameters t)+-- | Uses type parameters from 'haskType' (bridged).+psTuple :: BridgePart+psTuple = do+ size <- views (haskType . typeParameters) length+ let+ tupleModule = if size == 2 then "Data.Tuple" else "Data.Tuple.Nested"+ tupleName = "Tuple" <> if size == 2 then "" else T.pack (show size)+ TypeInfo "purescript-tuples" tupleModule tupleName <$> psTypeParameters -psUnit :: TypeInfo+psUnit :: TypeInfo 'PureScript psUnit = TypeInfo {- typePackage = "purescript-prelude"- , typeModule = "Prelude"- , typeName = "Unit"- , typeParameters = []+ _typePackage = "purescript-prelude"+ , _typeModule = "Prelude"+ , _typeName = "Unit"+ , _typeParameters = [] }
src/Language/PureScript/Bridge/Primitives.hs view
@@ -2,31 +2,34 @@ module Language.PureScript.Bridge.Primitives where -import Language.PureScript.Bridge.TypeInfo-import Language.PureScript.Bridge.PSTypes+import Data.Proxy+import Language.PureScript.Bridge.Builder+import Language.PureScript.Bridge.PSTypes+import Language.PureScript.Bridge.TypeInfo +boolBridge :: BridgePart+boolBridge = typeName ^== "Bool" >> return psBool -boolBridge :: TypeBridge-boolBridge = mkBridgeTo (eqTypeName "Bool") psBool+eitherBridge :: BridgePart+eitherBridge = typeName ^== "Either" >> psEither -eitherBridge :: TypeBridge-eitherBridge = mkBridgeTo1 (eqTypeName "Either") psEither+intBridge :: BridgePart+intBridge = typeName ^== "Int" >> return psInt -intBridge :: TypeBridge-intBridge = mkBridgeTo (eqTypeName "Int") psInt+listBridge :: BridgePart+listBridge = typeName ^== "[]" >> psArray -listBridge :: TypeBridge-listBridge = mkBridgeTo1 (eqTypeName "[]") psArray+maybeBridge :: BridgePart+maybeBridge = typeName ^== "Maybe" >> psMaybe -maybeBridge :: TypeBridge-maybeBridge = mkBridgeTo1 (eqTypeName "Maybe") psMaybe+stringBridge :: BridgePart+stringBridge = haskType ^== mkTypeInfo (Proxy :: Proxy String ) >> return psString -stringBridge :: TypeBridge-stringBridge = mkBridgeTo isStringLike psString- where- isStringLike t = isText t || isString t- isText t = typeName t == "Text"- isString t = typeName t == "[]" && all ((==) "Char" . typeName) (typeParameters t)+textBridge :: BridgePart+textBridge = do+ typeName ^== "Text"+ typeModule ^== "Data.Text.Internal" <|> typeModule ^== "Data.Text.Internal.Lazy"+ return psString -unitBridge :: TypeBridge-unitBridge = mkBridgeTo (eqTypeName "()") psUnit+unitBridge :: BridgePart+unitBridge = typeName ^== "()" >> return psUnit
src/Language/PureScript/Bridge/Printer.hs view
@@ -1,32 +1,37 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE KindSignatures #-} {-# LANGUAGE OverloadedStrings #-}+ module Language.PureScript.Bridge.Printer where -import Data.Map.Strict (Map)-import qualified Data.Map.Strict as M-import Data.Monoid-import Data.Set (Set)-import qualified Data.Set as S-import Data.Text (Text)-import qualified Data.Text as T-import qualified Data.Text.IO as T-import System.Directory-import System.FilePath-import Control.Monad+import Control.Monad+import Data.Map.Strict (Map)+import qualified Data.Map.Strict as Map+import Data.Monoid+import Data.Set (Set)+import qualified Data.Set as Set+import Data.Text (Text)+import qualified Data.Text as T+import qualified Data.Text.IO as T+import System.Directory+import System.FilePath -import Language.PureScript.Bridge.SumType-import Language.PureScript.Bridge.TypeInfo+import Language.PureScript.Bridge.SumType+import Language.PureScript.Bridge.TypeInfo -data PSModule = PSModule {- psModuleName :: !Text+data Module (lang :: Language) = PSModule {+ psModuleName :: !Text , psImportLines :: !(Map Text ImportLine)-, psTypes :: ![SumType]+, psTypes :: ![SumType lang] } deriving Show +type PSModule = Module 'PureScript+ data ImportLine = ImportLine { importModule :: !Text-, importTypes :: !(Set Text)+, importTypes :: !(Set Text) } deriving Show type Modules = Map Text PSModule@@ -41,20 +46,21 @@ mPath = root </> mFile mDir = takeDirectory mPath -sumTypesToNeededPackages :: [SumType] -> Set Text-sumTypesToNeededPackages = S.unions . map sumTypeToNeededPackages+sumTypesToNeededPackages :: [SumType lang] -> Set Text+sumTypesToNeededPackages = Set.unions . map sumTypeToNeededPackages -sumTypeToNeededPackages :: SumType -> Set Text+sumTypeToNeededPackages :: SumType lang -> Set Text sumTypeToNeededPackages st = let types = getUsedTypes st- packages = filter (not . T.null) . map typePackage $ types+ packages = filter (not . T.null) . map _typePackage $ types in- S.fromList packages+ Set.fromList packages -moduleToText :: PSModule -> Text+moduleToText :: Module 'PureScript -> Text moduleToText m = T.unlines $- "module " <> psModuleName m <> " where\n"- : map importLineToText (M.elems (psImportLines m))+ "-- File auto generated by purescript-bridge! --"+ : "module " <> psModuleName m <> " where\n"+ : map importLineToText (Map.elems (psImportLines m)) ++ [ "\nimport Data.Generic (class Generic)\n\n" ] ++ map sumTypeToText (psTypes m) @@ -62,16 +68,16 @@ importLineToText :: ImportLine -> Text importLineToText l = "import " <> importModule l <> " (" <> typeList <> ")" where- typeList = T.intercalate ", " (S.toList (importTypes l))+ typeList = T.intercalate ", " (Set.toList (importTypes l)) -sumTypeToText :: SumType -> Text+sumTypeToText :: SumType 'PureScript -> Text sumTypeToText (SumType t cs) = T.unlines $ "data " <> typeInfoToText True t <> " ="- : [ " " <> T.intercalate "\n | " (map (constructorToText 4) cs) ]- ++ [ "\nderive instance generic" <> typeName t <> " :: Generic " <> typeName t ]+ : " " <> T.intercalate "\n | " (map (constructorToText 4) cs)+ : [ "\nderive instance generic" <> _typeName t <> " :: Generic " <> _typeName t ] -constructorToText :: Int -> DataConstructor -> Text+constructorToText :: Int -> DataConstructor 'PureScript -> Text constructorToText _ (DataConstructor n (Left ts)) = n <> " " <> T.intercalate " " (map (typeInfoToText False) ts) constructorToText indentation (DataConstructor n (Right rs)) = n <> " {\n"@@ -81,49 +87,61 @@ intercalation = "\n" <> spaces indentation <> "," <> " " spaces c = T.replicate c " " -recordEntryToText :: RecordEntry -> Text-recordEntryToText e = recLabel e <> " :: " <> typeInfoToText True (recValue e)+recordEntryToText :: RecordEntry 'PureScript -> Text+recordEntryToText e = _recLabel e <> " :: " <> typeInfoToText True (_recValue e) -typeInfoToText :: Bool -> TypeInfo -> Text+typeInfoToText :: Bool -> TypeInfo 'PureScript -> Text typeInfoToText topLevel t = if needParens then "(" <> inner <> ")" else inner where- inner = typeName t <>+ inner = _typeName t <> if pLength > 0 then " " <> T.intercalate " " textParameters else ""- params = typeParameters t+ params = _typeParameters t pLength = length params needParens = not topLevel && pLength > 0 textParameters = map (typeInfoToText False) params -sumTypesToModules :: Modules -> [SumType] -> Modules+sumTypesToModules :: Modules -> [SumType 'PureScript] -> Modules sumTypesToModules = foldr sumTypeToModule -sumTypeToModule :: SumType -> Modules -> Modules-sumTypeToModule st@(SumType t _) = M.alter (Just . updateModule) (typeModule t)+sumTypeToModule :: SumType 'PureScript -> Modules -> Modules+sumTypeToModule st@(SumType t _) = Map.alter (Just . updateModule) (_typeModule t) where updateModule Nothing = PSModule {- psModuleName = typeModule t- , psImportLines = dropSelf $ typesToImportLines M.empty (getUsedTypes st)+ psModuleName = _typeModule t+ , psImportLines = dropSelf $ typesToImportLines Map.empty (getUsedTypes st) , psTypes = [st] } updateModule (Just m) = m { psImportLines = dropSelf $ typesToImportLines (psImportLines m) (getUsedTypes st) , psTypes = st : psTypes m }- dropSelf = M.delete (typeModule t)+ dropSelf = Map.delete (_typeModule t) -typesToImportLines :: ImportLines -> [TypeInfo] -> ImportLines+typesToImportLines :: ImportLines -> [TypeInfo 'PureScript] -> ImportLines typesToImportLines = foldr typeToImportLines -typeToImportLines :: TypeInfo -> ImportLines -> ImportLines-typeToImportLines t = if not (T.null (typeModule t))- then M.alter (Just . updateLine) (typeModule t)+typeToImportLines :: TypeInfo 'PureScript -> ImportLines -> ImportLines+typeToImportLines t = if not (T.null (_typeModule t))+ then Map.alter (Just . updateLine) (_typeModule t) else id where- updateLine Nothing = ImportLine (typeModule t) (S.singleton (typeName t))- updateLine (Just (ImportLine m types)) = ImportLine m $ S.insert (typeName t) types+ updateLine Nothing = ImportLine (_typeModule t) (Set.singleton (_typeName t))+ updateLine (Just (ImportLine m types)) = ImportLine m $ Set.insert (_typeName t) types++importsFromList :: [ImportLine] -> Map Text ImportLine+importsFromList ls = let+ pairs = zip (map importModule ls) ls+ merge a b = ImportLine (importModule a) (importTypes a `Set.union` importTypes b)+ in+ Map.fromListWith merge pairs++mergeImportLines :: ImportLines -> ImportLines -> ImportLines+mergeImportLines = Map.unionWith mergeLines+ where+ mergeLines a b = ImportLine (importModule a) (importTypes a `Set.union` importTypes b) unlessM :: Monad m => m Bool -> m () -> m () unlessM mbool action = mbool >>= flip unless action
src/Language/PureScript/Bridge/SumType.hs view
@@ -1,47 +1,73 @@-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE KindSignatures #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeOperators #-} {-# LANGUAGE TypeSynonymInstances #-} -module Language.PureScript.Bridge.SumType where -import Generics.Deriving-import Data.Text (Text)-import qualified Data.Text as T-import Data.Proxy-import Data.Typeable+module Language.PureScript.Bridge.SumType (+ SumType (..)+, mkSumType+, DataConstructor (..)+, RecordEntry (..)+, getUsedTypes+, constructorToType+, sigConstructor+, sigValues+, sumTypeInfo+, sumTypeConstructors+, recLabel+, recValue+) where -import Language.PureScript.Bridge.TypeInfo+import Control.Lens hiding (from, to)+import Data.Proxy+import Data.Text (Text)+import qualified Data.Text as T+import Data.Typeable+import Generics.Deriving --- | Generic representation of your Haskell types, the contained (leaf) types can be modified to match--- compatible PureScript types, by using 'TypeBridge' functions like 'defaultBridge' with 'writePSTypes'.-data SumType = SumType TypeInfo [DataConstructor] deriving Show+import Language.PureScript.Bridge.TypeInfo +-- | Generic representation of your Haskell types.+data SumType (lang :: Language) = SumType (TypeInfo lang) [DataConstructor lang] deriving Show++-- | TypInfo lens for 'SumType'.+sumTypeInfo :: Functor f => (TypeInfo lang -> f (TypeInfo lang) ) -> SumType lang -> f (SumType lang)+sumTypeInfo inj (SumType info constrs) = flip SumType constrs <$> inj info++-- | DataConstructor lens for 'SumType'.+sumTypeConstructors :: Functor f => ([DataConstructor lang] -> f [DataConstructor lang]) -> SumType lang -> f (SumType lang)+sumTypeConstructors inj (SumType info constrs) = SumType info <$> inj constrs+ -- | Create a representation of your sum (and product) types, -- for doing type translations and writing it out to your PureScript modules.--- In order to get the type information we use a dummy variable of type Proxy (YourType).-toSumType :: forall t. (Generic t, Typeable t, GDataConstructor (Rep t)) => Proxy t -> SumType-toSumType p = SumType (mkTypeInfo p) constructors+-- In order to get the type information we use a dummy variable of type 'Proxy' (YourType).+mkSumType :: forall t. (Generic t, Typeable t, GDataConstructor (Rep t)) => Proxy t -> SumType 'Haskell+mkSumType p = SumType (mkTypeInfo p) constructors where constructors = gToConstructors (from (undefined :: t)) -data DataConstructor = DataConstructor {- sigConstructor :: !Text-, sigValues :: !(Either [TypeInfo] [RecordEntry])+data DataConstructor (lang :: Language) = DataConstructor {+ _sigConstructor :: !Text+, _sigValues :: !(Either [TypeInfo lang] [RecordEntry lang]) } deriving Show -data RecordEntry = RecordEntry {- recLabel :: !Text-, recValue :: !TypeInfo++data RecordEntry (lang :: Language) = RecordEntry {+ _recLabel :: !Text+, _recValue :: !(TypeInfo lang) } deriving Show class GDataConstructor f where- gToConstructors :: f a -> [DataConstructor]+ gToConstructors :: f a -> [DataConstructor 'Haskell] class GRecordEntry f where- gToRecordEntries :: f a -> [RecordEntry]+ gToRecordEntries :: f a -> [RecordEntry 'Haskell] instance (Datatype a, GDataConstructor c) => GDataConstructor (D1 a c) where gToConstructors (M1 c) = gToConstructors c@@ -52,15 +78,15 @@ instance (Constructor a, GRecordEntry b) => GDataConstructor (C1 a b) where gToConstructors c@(M1 r) = [ DataConstructor {- sigConstructor = constructor- , sigValues = values+ _sigConstructor = constructor+ , _sigValues = values } ] where constructor = T.pack $ conName c values = if conIsRecord c then Right $ gToRecordEntries r- else Left $ map recValue $ gToRecordEntries r+ else Left $ map _recValue $ gToRecordEntries r instance (GRecordEntry a, GRecordEntry b) => GRecordEntry (a :*: b) where gToRecordEntries (_ :: (a :*: b) f) = gToRecordEntries (undefined :: a f) ++ gToRecordEntries (undefined :: b f)@@ -71,14 +97,18 @@ instance (Selector a, Typeable t) => GRecordEntry (S1 a (K1 R t)) where gToRecordEntries e = [- RecordEntry { recLabel = T.pack (selName e)- , recValue = mkTypeInfo (Proxy :: Proxy t)+ RecordEntry { _recLabel = T.pack (selName e)+ , _recValue = mkTypeInfo (Proxy :: Proxy t) } ] -getUsedTypes :: SumType -> [TypeInfo]+getUsedTypes :: SumType lang -> [TypeInfo lang] getUsedTypes (SumType _ cs) = foldr constructorToType [] cs -constructorToType :: DataConstructor -> [TypeInfo] -> [TypeInfo]+constructorToType :: DataConstructor lang -> [TypeInfo lang] -> [TypeInfo lang] constructorToType (DataConstructor _ (Left myTs)) ts = concatMap flattenTypeInfo myTs ++ ts-constructorToType (DataConstructor _ (Right rs)) ts = concatMap (flattenTypeInfo . recValue) rs ++ ts+constructorToType (DataConstructor _ (Right rs)) ts = concatMap (flattenTypeInfo . _recValue) rs ++ ts++-- Lenses:+makeLenses ''DataConstructor+makeLenses ''RecordEntry
src/Language/PureScript/Bridge/Tuple.hs view
@@ -1,14 +1,17 @@+{-# LANGUAGE DataKinds #-} {-# LANGUAGE OverloadedStrings #-}+ module Language.PureScript.Bridge.Tuple where -import qualified Data.Text as T+import qualified Data.Text as T -import Language.PureScript.Bridge.TypeInfo-import Language.PureScript.Bridge.PSTypes (psTuple)+import Language.PureScript.Bridge.Builder+import Language.PureScript.Bridge.PSTypes (psTuple)+import Language.PureScript.Bridge.TypeInfo -tupleBridge :: TypeBridge-tupleBridge = mkBridgeTo1 isTuple psTuple+tupleBridge :: BridgePart+tupleBridge = doCheck haskType isTuple >> psTuple data TupleParserState =@@ -25,5 +28,5 @@ step Tuple _ = NoTuple step NoTuple _ = NoTuple -isTuple :: TypeInfo -> Bool-isTuple = (== Tuple) . T.foldl' step Start . typeName+isTuple :: TypeInfo 'Haskell -> Bool+isTuple = (== Tuple) . T.foldl' step Start . _typeName
src/Language/PureScript/Bridge/TypeInfo.hs view
@@ -1,57 +1,69 @@-{-# LANGUAGE OverloadedStrings #-}--module Language.PureScript.Bridge.TypeInfo where+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE KindSignatures #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeSynonymInstances #-} -import Data.Text (Text)-import qualified Data.Text as T-import Data.Proxy-import Data.Typeable+module Language.PureScript.Bridge.TypeInfo (+ TypeInfo (..)+ , mkTypeInfo+ , mkTypeInfo'+ , Language (..)+ , typePackage+ , typeModule+ , typeName+ , typeParameters+ , HasHaskType+ , haskType+ , flattenTypeInfo+) where --- | Translates a Haskell type info to a PureScript type info:-type TypeBridge = TypeInfo -> Maybe TypeInfo+import Control.Lens+import Data.Proxy+import Data.Text (Text)+import qualified Data.Text as T+import Data.Typeable +data Language = Haskell | PureScript -- | Basic info about a data type:-data TypeInfo = TypeInfo {+data TypeInfo (lang :: Language) = TypeInfo { -- | Hackage package- typePackage :: !Text+ _typePackage :: !Text -- | Full Module path-, typeModule :: !Text-, typeName :: !Text-, typeParameters :: ![TypeInfo]-} deriving (Eq, Show)+, _typeModule :: !Text+, _typeName :: !Text+, _typeParameters :: ![TypeInfo lang]+} deriving (Eq, Ord, Show) -mkTypeInfo :: Typeable t => Proxy t -> TypeInfo+makeLenses ''TypeInfo++-- | Types that have a lens for accessing a 'TypeInfo Haskell'.+class HasHaskType t where+ haskType :: Lens' t (TypeInfo 'Haskell)++-- | Simple 'id' instance: Get the 'TypeInfo' itself.+instance HasHaskType (TypeInfo 'Haskell) where+ haskType inj = inj+++mkTypeInfo :: Typeable t => Proxy t -> TypeInfo 'Haskell mkTypeInfo = mkTypeInfo' . typeRep -mkTypeInfo' :: TypeRep -> TypeInfo+mkTypeInfo' :: TypeRep -> TypeInfo 'Haskell mkTypeInfo' rep = let con = typeRepTyCon rep in TypeInfo {- typePackage = T.pack $ tyConPackage con- , typeModule = T.pack $ tyConModule con- , typeName = T.pack $ tyConName con- , typeParameters = map mkTypeInfo' (typeRepArgs rep)+ _typePackage = T.pack $ tyConPackage con+ , _typeModule = T.pack $ tyConModule con+ , _typeName = T.pack $ tyConName con+ , _typeParameters = map mkTypeInfo' (typeRepArgs rep) } --- | Put the TypeInfo in a list together with all its typeParameters (recursively)-flattenTypeInfo :: TypeInfo -> [TypeInfo]-flattenTypeInfo t = t : concatMap flattenTypeInfo (typeParameters t)---- | Little helper for type bridge implementers-eqTypeName :: Text -> TypeInfo -> Bool-eqTypeName name = (== name) . typeName---- | Helper for simple bridge creation for basic types-mkBridgeTo :: (TypeInfo -> Bool) -> TypeInfo -> TypeBridge-mkBridgeTo match r t- | match t = Just r- | otherwise = Nothing---- | Helper for simple bridge creation for type constructors-mkBridgeTo1 :: (TypeInfo -> Bool) -> (TypeInfo -> TypeInfo) -> TypeBridge-mkBridgeTo1 match r t- | match t = Just $ r t- | otherwise = Nothing+-- | Put the TypeInfo in a list together with all its '_typeParameters' (recursively)+flattenTypeInfo :: TypeInfo lang -> [TypeInfo lang]+flattenTypeInfo t = t : concatMap flattenTypeInfo (_typeParameters t)
src/Language/PureScript/Bridge/TypeParameters.hs view
@@ -1,15 +1,22 @@ -- | As we translate types and not type constructors, we have to pass dummy types--- to any type constructor. doBridge will translate all parameter types which+-- to any type constructor.+--+-- 'buildBridge' will translate all parameter types which -- come from a module TypeParameters (e.g. this one) to lower case.--- E.g. for translating something like Maybe:+--+-- For translating something like Maybe:+-- -- @ -- data Maybe' a = Nothing' | Just' a -- @+-- -- you would use:+-- -- @--- import 'Language.PureScript.Bridge'--- import 'Language.PureScript.Bridge.TypeParameters'--- toSumType (Proxy :: Proxy (Maybe A)) -- Note the capital A, which comes from the TypeParameters module.+-- import "Language.PureScript.Bridge"+-- import "Language.PureScript.Bridge.TypeParameters"+--+-- st = mkSumType ('Proxy' :: 'Proxy' (Maybe' A)) -- Note that we use "Maybe' A" instead of just Maybe - which would not work. -- @ module Language.PureScript.Bridge.TypeParameters where@@ -44,7 +51,7 @@ -- | You can use those if your type parameters are actually type constructors as well: -- @--- toSumType (Proxy :: Proxy ('ReaderT' R M1 A))+-- st = mkSumType (Proxy :: Proxy ('ReaderT' R M1 A)) -- @ data A1 a data B1 a
+ test/Spec.hs view
@@ -0,0 +1,55 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE DeriveGeneric #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE TypeSynonymInstances #-}+++module Main where++import qualified Data.Map as Map+import Data.Proxy+import Data.Text (Text)+import qualified Data.Text as T+import Data.Typeable+import GHC.Generics (Generic)+import Language.PureScript.Bridge+import Language.PureScript.Bridge.PSTypes+import Language.PureScript.Bridge.TypeParameters++++-- Check that examples compile:+textBridge :: BridgePart+textBridge = do+ typeName ^== "Text"+ typeModule ^== "Data.Text.Internal" <|> typeModule ^== "Data.Text.Internal.Lazy"+ return psString++stringBridge :: BridgePart+stringBridge = do+ haskType ^== mkTypeInfo (Proxy :: Proxy String)+ return psString++data Foo = Foo | Bar Int | FooBar Int Text deriving (Generic, Typeable, Show)++data Bar a b m = Bar1 (Maybe a) | Bar2 (Either a b) | Bar3 a+ | Bar4 {+ myMonadicResult :: m b+ } deriving (Generic, Typeable, Show)++main :: IO ()+main = do+ let r = buildBridge defaultBridge (mkTypeInfo (Proxy :: Proxy Int))+ let r2 = bridgeSumType (buildBridge defaultBridge) (mkSumType (Proxy :: Proxy Foo))+ putStrLn "Bridge a single int: "+ print r+ putStrLn "\nBridge Foo:"+ print r2+ let advanced = bridgeSumType (buildBridge defaultBridge) (mkSumType (Proxy :: Proxy (Bar A B M1)))+ let modules = sumTypeToModule advanced Map.empty+ let m = head . map moduleToText . Map.elems $ modules+ putStrLn "\n Complete module for Bar type:\n"+ putStrLn $ T.unpack m