packages feed

mulang 0.1.0.0 → 3.5.2

raw patch · 42 files changed

+3371/−528 lines, 42 filesdep +ParsecToolsdep +containersdep +hashabledep ~aesondep ~basedep ~bytestringnew-component:exe:mulang

Dependencies added: ParsecTools, containers, hashable, inflections, language-java, language-javascript, neat-interpolation, parsec, process, scientific, split, text, unordered-containers, vector

Dependency ranges changed: aeson, base, bytestring, haskell-src, hspec

Files

− LICENSE 
@@ -1,20 +0,0 @@-Copyright (c) 2016 Franco Leonardo Bulgarelli--Permission is hereby granted, free of charge, to any person obtaining-a copy of this software and associated documentation files (the-"Software"), to deal in the Software without restriction, including-without limitation the rights to use, copy, modify, merge, publish,-distribute, sublicense, and/or sell copies of the Software, and to-permit persons to whom the Software is furnished to do so, subject to-the following conditions:--The above copyright notice and this permission notice shall be included-in all copies or substantial portions of the Software.--THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ LICENSE.txt view
@@ -0,0 +1,674 @@+                    GNU GENERAL PUBLIC LICENSE+                       Version 3, 29 June 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 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 <http://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:++    {project}  Copyright (C) {year}  {fullname}+    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+<http://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+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+ app/Main.hs view
@@ -0,0 +1,58 @@+{-# LANGUAGE DeriveGeneric, QuasiQuotes, OverloadedStrings #-}++module Main (main) where++import Language.Mulang.Analyzer (analyse)+import Language.Mulang.Analyzer.Analysis.Json ()+import Data.Aeson (eitherDecode, encode)+import System.Environment (getArgs)+import Control.Fallible (orFail)++import           Data.List (intercalate)+import           Version (prettyVersion)+import           Data.Text.Lazy.Encoding (encodeUtf8)+import qualified Data.ByteString.Lazy as LBS (putStrLn)+import qualified Data.Text.Lazy as T (pack)+import           Data.Text (unpack)+import           NeatInterpolation (text)+++main :: IO ()+main = do+  argsBody <- fmap parseArgs $ getArgs+  streamBody <- getContents+  let body = if argsBody == "-s" then streamBody else argsBody+  result <- analyseJson body+  LBS.putStrLn result++analyseJson = fmap encode . analyse . decode . encodeUtf8 . T.pack++parseArgs :: [String] -> String+parseArgs [jsonBody] = jsonBody+parseArgs _          = error (intercalate "\n" [prettyVersion, usage])++decode = orFail . eitherDecode++usage = unpack [text|+        Wrong usage.++         #read from STDIN+         $ mulang -s++         #read from argument+         $ mulang '{+             "sample" : {+                "tag" : "CodeSample",+                "language" : "Haskell",+                "content" : "x = 1"+             },+             "spec" : {+                "expectations" : [+                   {+                      "binding" : ":Intransitive:x",+                      "inspection" : "Uses:*"+                   }+                ],+                "smellsSet" : { "tag" : "NoSmells" }+             }+          }'|]
mulang.cabal view
@@ -1,9 +1,9 @@ name:                mulang-version:             0.1.0.0-synopsis:            The Mu Language, a non-computable extended Lambda Calculus--- description:-license:             MIT-license-file:        LICENSE+version:             3.5.2+synopsis:            An intermediate language designed to perform advanced code analysis+description:         Mulang is an intermediate language, a combinators library for static code analysis and a multilanguage comand line tool+license:             GPL+license-file:        LICENSE.txt author:              Franco Leonardo Bulgarelli maintainer:          franco@mumuki.org category:            Language@@ -11,46 +11,137 @@ cabal-version:       >=1.10  library-  build-depends:       base >=4.6 && <4.7+  hs-source-dirs:      src   default-language:    Haskell2010++-- TODO recheck this is actuall necessary   ghc-options:-      -Wall-      -fno-warn-missing-signatures-      -fno-warn-orphans-      -fno-warn-name-shadowing-  hs-source-dirs:-      src+    -Wall+    -fno-warn-missing-signatures+    -fno-warn-unused-do-bind+    -fno-warn-orphans+    -fno-warn-name-shadowing+    -fno-warn-incomplete-patterns+    -fno-warn-missing-pattern-synonym-signatures+    -fwarn-tabs+    -funbox-strict-fields+   exposed-modules:+    Control.Fallible+    Text.Dictionary+    Text.SimpleParser+    Text.Inflections.Tokenizer     Language.Mulang-    Language.Mulang.Explorer-    Language.Mulang.Inspector.Smell-    Language.Mulang.Inspector.Combiner+    Language.Mulang.Ast+    Language.Mulang.Identifier+    Language.Mulang.Builder+    Language.Mulang.Generator+    Language.Mulang.Signature+    Language.Mulang.DomainLanguage     Language.Mulang.Inspector+    Language.Mulang.Inspector.Generic+    Language.Mulang.Inspector.ObjectOriented+    Language.Mulang.Inspector.Functional+    Language.Mulang.Inspector.Logic+    Language.Mulang.Inspector.Procedural+    Language.Mulang.Inspector.Combiner+    Language.Mulang.Inspector.Generic.Duplication+    Language.Mulang.Inspector.Generic.Smell+    Language.Mulang.Parsers     Language.Mulang.Parsers.Haskell-    Language.Mulang.Parsers.Json+    Language.Mulang.Parsers.Prolog+    Language.Mulang.Parsers.Java+    Language.Mulang.Parsers.JavaScript+    Language.Mulang.Analyzer+    Language.Mulang.Analyzer.Analysis+    Language.Mulang.Analyzer.Analysis.Json+    Language.Mulang.Analyzer.SampleParser+    Language.Mulang.Analyzer.ExpectationsAnalyzer+    Language.Mulang.Analyzer.ExpectationsCompiler+    Language.Mulang.Analyzer.SignaturesAnalyzer+    Language.Mulang.Analyzer.SignatureStyleCompiler+    Language.Mulang.Analyzer.DomainLanguageCompiler+    Language.Mulang.Analyzer.SmellsAnalyzer   build-depends:-    base                      >= 4     && < 5,-    bytestring                == 0.10.6.0,-    haskell-src               >= 1     && < 1.1,-    aeson                     == 0.8.1.1+    base                      <= 5,+    bytestring                ,+    text                      ,+    unordered-containers      ,+    containers                ,+    scientific                ,+    vector                    ,+    haskell-src               ,+    language-java             ,+    language-javascript       ,+    aeson                     ,+    inflections               ,+    parsec                    ,+    ParsecTools               ,+    split                     ,+    hashable                  ,+    process+  build-tools:+    happy,+    alex +executable mulang+  hs-source-dirs:      app+  main-is:             Main.hs+  default-language:    Haskell2010 +  build-depends:+    base                      <= 5,+    bytestring                ,+    text                      ,+    aeson                     ,+    process                   ,+    neat-interpolation        ,+    mulang+  build-tools:+    happy,+    alex++  ghc-options:+    -Wall+    -fno-warn-missing-signatures+    -fno-warn-unused-do-bind+    -fno-warn-orphans+    -fno-warn-name-shadowing+    -fno-warn-incomplete-patterns+    -fno-warn-missing-pattern-synonym-signatures+    -fwarn-tabs+    -funbox-strict-fields+    -threaded+ test-suite spec-  type:-      exitcode-stdio-1.0+  hs-source-dirs: spec+  default-language:    Haskell2010++  type: exitcode-stdio-1.0   ghc-options:-      -Wall-      -fno-warn-missing-signatures-      -fno-warn-orphans-      -fno-warn-name-shadowing-  hs-source-dirs:-      spec-  main-is:-      Spec.hs+    -Wall+    -fno-warn-missing-signatures+    -fno-warn-unused-do-bind+    -fno-warn-orphans+    -fno-warn-name-shadowing+    -fno-warn-incomplete-patterns+    -fno-warn-missing-pattern-synonym-signatures+    -fwarn-tabs+    -funbox-strict-fields+    -threaded+  main-is:        Spec.hs   build-depends:-    base                      >= 4     && < 5,-    bytestring                == 0.10.6.0,-    aeson                     == 0.8.1.1,-    haskell-src               >= 1     && < 1.1,-    hspec                     >= 2     && < 3,+    base                      <= 5,+    bytestring                ,+    text                      ,+    aeson                     ,+    hspec                     ,+    neat-interpolation        ,     mulang+  build-tools:+    happy,+    alex++source-repository head+  type:     git+  location: https://github.com/mumuki/mulang
+ src/Control/Fallible.hs view
@@ -0,0 +1,28 @@+module Control.Fallible where++class Fallible f where+  failure :: f v -> Either v String++instance Show e => Fallible (Either e) where+  failure (Left e)  = Right . show $ e+  failure (Right v) = (Left v)+++orFail :: Fallible f => f v -> v+orFail f = case failure f of+            (Left v)  -> v+            (Right e) -> error e++orNothing :: Fallible f => f v -> Maybe v+orNothing f = case failure f of+            (Left v) -> Just v+            _        -> Nothing++orLeft :: Fallible f => f v -> Either String v+orLeft f = case failure f of+            (Right e) -> Left e+            (Left v)  -> Right v++++
src/Language/Mulang.hs view
@@ -1,97 +1,11 @@-{-# LANGUAGE DeriveGeneric #-}- module Language.Mulang (-    Program(..),-    Declaration(..),-    Equation(..),-    Rhs(..),-    GuardedRhs(..),-    Expression(..),-    ComprehensionStatement(..),-    Alternative(..),-    GuardedAlternatives(..),-    GuardedAlternative(..),-    Pattern(..),-    LiteralValue(..)-  ) where--import           GHC.Generics--data Program = Program [Declaration] deriving (Eq, Show, Read, Generic)--type Identifier = String---- declaration or directive-data Declaration-         = TypeAlias Identifier-         | RecordDeclaration Identifier-         | TypeSignature Identifier-         | FunctionDeclaration Identifier [Equation]    -- functional, maybe pure,-                                                        -- optionally guarded,-                                                        -- optionally pattern matched function-         | ProcedureDeclaration Identifier              -- classic imperative-style procedure-         | ConstantDeclaration Identifier Rhs [Declaration]-  deriving (Eq, Show, Read, Generic)--data Equation = Equation [Pattern] Rhs [Declaration] deriving (Eq, Show, Read, Generic)--data Rhs-         = UnguardedRhs Expression-         | GuardedRhss  [GuardedRhs]-  deriving (Eq, Show, Read, Generic)--data GuardedRhs = GuardedRhs Expression Expression deriving (Eq, Show, Read, Generic)---- expression or statement--- may have effects-data Expression-        = Variable Identifier-        | Literal LiteralValue-        | InfixApplication Expression String Expression-        | Application Expression Expression-        | Lambda [Pattern] Expression-        | Let [Declaration] Expression-        | If Expression Expression Expression-        | Match Expression [Alternative]-        | MuTuple [Expression]-        | MuList [Expression]-        | Comprehension Expression [ComprehensionStatement]-        | Sequence [Expression]                   -- sequence of statements-        | ExpressionOther-  deriving (Eq, Show, Read, Generic)--data Pattern-        = VariablePattern String                 -- ^ variable-        | LiteralPattern String              -- ^ literal constant-        | InfixApplicationPattern Pattern String Pattern-        | ApplicationPattern String [Pattern]        -- ^ data constructor and argument-        | TuplePattern [Pattern]              -- ^ tuple pattern-        | ListPattern [Pattern]               -- ^ list pattern-        | AsPattern String Pattern         -- ^ @\@@-pattern-        | WildcardPattern                   -- ^ wildcard pattern (@_@)-        | OtherPattern-  deriving (Eq, Show, Read, Generic)--data ComprehensionStatement-        = MuGenerator Pattern Expression-        | MuQualifier Expression-        | LetStmt [Declaration]-  deriving (Eq, Show, Read, Generic)---data Alternative = Alternative Pattern GuardedAlternatives [Declaration] deriving (Eq, Show, Read, Generic)--data GuardedAlternatives-        = UnguardedAlternative Expression          -- ^ @->@ /exp/-        | GuardedAlternatives  [GuardedAlternative] -- ^ /gdpat/-  deriving (Eq, Show, Read, Generic)---data GuardedAlternative = GuardedAlternative Expression Expression deriving (Eq, Show, Read, Generic)+  module Language.Mulang.Ast,+  module Language.Mulang.Identifier,+  module Language.Mulang.Inspector,+  module Language.Mulang.Generator+) where -data LiteralValue-          = MuBool Bool-          | MuInteger Integer-          | MuFloat Rational-          | MuString String-    deriving (Eq, Show, Read, Generic)+import Language.Mulang.Ast+import Language.Mulang.Identifier+import Language.Mulang.Inspector+import Language.Mulang.Generator
+ src/Language/Mulang/Analyzer.hs view
@@ -0,0 +1,72 @@+module Language.Mulang.Analyzer (+  noSmells,+  allSmells,++  emptyDomainLanguage,+  emptyAnalysisSpec,++  emptyAnalysis,+  domainLanguageAnalysis,+  expectationsAnalysis,+  smellsAnalysis,+  signaturesAnalysis,++  analyse,++  module Language.Mulang.Analyzer.Analysis) where++import Language.Mulang+import Language.Mulang.Analyzer.Analysis+import Language.Mulang.Analyzer.SampleParser (parseSample)+import Language.Mulang.Analyzer.SignaturesAnalyzer  (analyseSignatures)+import Language.Mulang.Analyzer.ExpectationsAnalyzer (analyseExpectations)+import Language.Mulang.Analyzer.SmellsAnalyzer (analyseSmells)+import Language.Mulang.Analyzer.DomainLanguageCompiler (emptyDomainLanguage, compileDomainLanguage)+import Data.Maybe (fromMaybe)+--+-- Builder functions+--+noSmells :: SmellsSet+noSmells = NoSmells Nothing++allSmells :: SmellsSet+allSmells = AllSmells Nothing++emptyAnalysisSpec :: AnalysisSpec+emptyAnalysisSpec = AnalysisSpec [] noSmells Nothing Nothing Nothing++emptyAnalysis :: Sample -> Analysis+emptyAnalysis code = Analysis code emptyAnalysisSpec++domainLanguageAnalysis :: Sample -> DomainLanguage -> Analysis+domainLanguageAnalysis code domainLanguage = Analysis code (emptyAnalysisSpec { domainLanguage = Just domainLanguage, smellsSet = allSmells })++expectationsAnalysis :: Sample -> [Expectation] -> Analysis+expectationsAnalysis code es = Analysis code (emptyAnalysisSpec { expectations = es })++smellsAnalysis :: Sample -> SmellsSet -> Analysis+smellsAnalysis code set = Analysis code (emptyAnalysisSpec { smellsSet = set })++signaturesAnalysis :: Sample -> SignatureStyle -> Analysis+signaturesAnalysis code style = Analysis code (emptyAnalysisSpec { signatureAnalysisType = Just (StyledSignatures style) })++--+-- Analysis running+--+analyse :: Analysis -> IO AnalysisResult+analyse (Analysis sample spec) = analyseSample (parseSample sample)+  where analyseSample (Right ast)    = analyseAst ast spec+        analyseSample (Left message) = return $ AnalysisFailed message++analyseAst :: Expression -> AnalysisSpec -> IO AnalysisResult+analyseAst ast spec = do+  language <- compileDomainLanguage (domainLanguage spec)+  return $ AnalysisCompleted (analyseExpectations ast (expectations spec))+                             (analyseSmells ast language (smellsSet spec))+                             (analyseSignatures ast (signatureAnalysisType spec))+                             (analyzeIntermediateLanguage ast spec)++analyzeIntermediateLanguage :: Expression -> AnalysisSpec -> Maybe Expression+analyzeIntermediateLanguage ast spec+  | fromMaybe False (includeIntermediateLanguage spec) = Just ast+  | otherwise = Nothing
+ src/Language/Mulang/Analyzer/Analysis.hs view
@@ -0,0 +1,106 @@+{-# LANGUAGE DeriveGeneric #-}++module Language.Mulang.Analyzer.Analysis (+  Expectation(..),++  Analysis(..),+  AnalysisSpec(..),+  SmellsSet(..),+  DomainLanguage(..),+  CaseStyle(..),+  Smell,+  SignatureAnalysisType(..),+  SignatureStyle(..),+  Sample(..),+  Language(..),++  AnalysisResult(..),+  ExpectationResult(..)) where++import GHC.Generics++import Language.Mulang.Ast++---+-- Common structures+--++type Smell = String+type Inspection = String++data Expectation+  = Expectation { binding :: String, inspection :: Inspection } deriving (Show, Eq, Generic)++--+-- Analysis input structures+--++data Analysis = Analysis {+  sample :: Sample,+  spec :: AnalysisSpec+} deriving (Show, Eq, Generic)++data AnalysisSpec = AnalysisSpec {+  expectations :: [Expectation],+  smellsSet :: SmellsSet,+  signatureAnalysisType :: Maybe SignatureAnalysisType,+  domainLanguage :: Maybe DomainLanguage,+  includeIntermediateLanguage :: Maybe Bool+} deriving (Show, Eq, Generic)++data DomainLanguage+  = DomainLanguage {+      dictionaryFilePath :: Maybe FilePath,+      caseStyle :: Maybe CaseStyle,+      minimumIdentifierSize :: Maybe Int,+      jargon :: Maybe [String]+    }  deriving (Show, Eq, Generic)++data CaseStyle+  = CamelCase+  | SnakeCase+  | RubyCase deriving (Show, Eq, Generic)++data SmellsSet+  = NoSmells { include :: Maybe [Smell] }+  | AllSmells { exclude :: Maybe [Smell] } deriving (Show, Eq, Generic)++data SignatureAnalysisType+  = NoSignatures+  | DefaultSignatures+  | StyledSignatures { style :: SignatureStyle } deriving (Show, Eq, Generic)++data SignatureStyle+  = MulangStyle+  | UntypedCStyle+  | HaskellStyle+  | PrologStyle deriving (Show, Eq, Generic)++data Sample+  = MulangSample { ast :: Expression }+  | CodeSample { language :: Language, content :: Code } deriving (Show, Eq, Generic)++data Language+  =  Json+  |  Java+  |  JavaScript+  |  Prolog+  |  Haskell deriving (Show, Eq, Generic)++--+-- Analysis Output structures+--++data AnalysisResult+  = AnalysisCompleted { expectationResults :: [ExpectationResult],+                        smells :: [Expectation],+                        signatures :: [Code],+                        intermediateLanguage :: Maybe Expression }+  | AnalysisFailed { reason :: String } deriving (Show, Eq, Generic)++data ExpectationResult = ExpectationResult {+  expectation :: Expectation,+  result :: Bool+} deriving (Show, Eq, Generic)++
+ src/Language/Mulang/Analyzer/Analysis/Json.hs view
@@ -0,0 +1,38 @@+module Language.Mulang.Analyzer.Analysis.Json () where++import Data.Aeson+import Language.Mulang+import Language.Mulang.Analyzer.Analysis++instance FromJSON Analysis+instance FromJSON AnalysisSpec++instance FromJSON Expectation++instance FromJSON SmellsSet+instance FromJSON DomainLanguage+instance FromJSON CaseStyle++instance FromJSON SignatureAnalysisType+instance FromJSON SignatureStyle++instance FromJSON Sample+instance FromJSON Language++instance FromJSON Equation+instance FromJSON EquationBody+instance FromJSON Expression+instance FromJSON Pattern+instance FromJSON ComprehensionStatement++instance ToJSON AnalysisResult+instance ToJSON ExpectationResult++instance ToJSON Expectation++instance ToJSON Equation+instance ToJSON EquationBody+instance ToJSON Expression+instance ToJSON Pattern+instance ToJSON ComprehensionStatement+
+ src/Language/Mulang/Analyzer/DomainLanguageCompiler.hs view
@@ -0,0 +1,31 @@+module Language.Mulang.Analyzer.DomainLanguageCompiler (+  emptyDomainLanguage,+  compileDomainLanguage) where++import           Data.Maybe (fromMaybe)+import           Language.Mulang.Analyzer.Analysis+import qualified Language.Mulang.DomainLanguage as DL+import           Text.Inflections.Tokenizer (camelCase, rubyCase, snakeCase)+import           Text.Dictionary (fromFile, toDictionary)+++emptyDomainLanguage :: DomainLanguage+emptyDomainLanguage = DomainLanguage Nothing Nothing Nothing Nothing++compileDomainLanguage :: Maybe DomainLanguage -> IO DL.DomainLanguage+compileDomainLanguage Nothing                                 = compileDomainLanguage (Just emptyDomainLanguage)+compileDomainLanguage (Just (DomainLanguage path style size jargon)) = do+  dictionary <- compileDictionay path+  return $ DL.DomainLanguage dictionary (compileStyle style) (compileSize size) (compileJargon jargon)++  where+    compileDictionay (Just path) = fromFile path+    compileDictionay _           = return $ toDictionary []++    compileSize = fromMaybe 3++    compileStyle (Just SnakeCase) = snakeCase+    compileStyle (Just RubyCase)  = rubyCase+    compileStyle _                = camelCase++    compileJargon = fromMaybe []
+ src/Language/Mulang/Analyzer/ExpectationsAnalyzer.hs view
@@ -0,0 +1,15 @@+module Language.Mulang.Analyzer.ExpectationsAnalyzer (+  analyseExpectations) where+++import Language.Mulang+import Language.Mulang.Analyzer.Analysis (Expectation, ExpectationResult(..))+import Language.Mulang.Analyzer.ExpectationsCompiler (compileExpectation)++analyseExpectations :: Expression -> [Expectation]-> [ExpectationResult]+analyseExpectations content = map (analyseExpectation content)++analyseExpectation :: Expression -> Expectation -> ExpectationResult+analyseExpectation ast e = ExpectationResult e (compileAndEval e)+  where compileAndEval e = (compileExpectation e) ast+
+ src/Language/Mulang/Analyzer/ExpectationsCompiler.hs view
@@ -0,0 +1,111 @@+module Language.Mulang.Analyzer.ExpectationsCompiler(+  compileExpectation) where++import Language.Mulang+import Language.Mulang.Analyzer.Analysis (Expectation(..))++import Data.Maybe (fromMaybe)+import Data.List.Split (splitOn)++type Modifiers = (Scope, PredicateModifier)+type Scope = (Inspection -> Inspection)+type PredicateModifier = (IdentifierPredicate -> IdentifierPredicate)++compileExpectation :: Expectation -> Inspection+compileExpectation = fromMaybe (\_ -> True) . compileMaybe++compileMaybe :: Expectation -> Maybe Inspection+compileMaybe (Expectation b i) = do+  let inspectionParts = splitOn ":" i+  let negator = compileNegator inspectionParts+  (scope, predicateModifier) <- compileModifiers (splitOn ":" b)+  baseInspection             <- compileBaseInspection predicateModifier inspectionParts+  return . negator . scope $ baseInspection++compileModifiers :: [String] -> Maybe Modifiers+compileModifiers ["*"]                 = Just (id, id)+compileModifiers ["Intransitive",name] = justScopeFor scopedList name+compileModifiers [name]                = justScopeFor transitiveList name+compileModifiers _                     = Nothing++justScopeFor f name = Just (flip f names, andAlso (except (last names)))+  where names = splitOn "." name++compileNegator :: [String] -> Scope+compileNegator ("Not":_) = negative+compileNegator _         = id++compileBaseInspection :: PredicateModifier -> [String] -> Maybe (Inspection)+compileBaseInspection p ("Not":parts)         = compileBaseInspection p parts+compileBaseInspection p [verb]                = compileBaseInspection p [verb, "*"]+compileBaseInspection p [verb, object]        = compileInspectionPrimitive verb (compileObject p object)+compileBaseInspection _ _                     = Nothing++compileObject :: PredicateModifier -> String -> IdentifierPredicate+compileObject p "*"        = p $ anyone+compileObject p ('~':name) = p $ like name+compileObject _ ('=':name) = named name+compileObject _ ('^':name) = except name+compileObject _ ('[':ns)   | last ns == ']' = anyOf . splitOn "|" . init $ ns+compileObject _ name       = named name+++compileInspectionPrimitive :: String -> IdentifierPredicate -> Maybe Inspection+compileInspectionPrimitive = f+  where+  f "Assigns"                        = binded assigns+  f "Calls"                          = binded calls+  f "Declares"                       = binded declares+  f "DeclaresAttribute"              = binded declaresAttribute+  f "DeclaresClass"                  = binded declaresClass+  f "DeclaresComputation"            = binded declaresComputation+  f "DeclaresComputationWithArity0"  = binded (declaresComputationWithArity 0)+  f "DeclaresComputationWithArity1"  = binded (declaresComputationWithArity 1)+  f "DeclaresComputationWithArity2"  = binded (declaresComputationWithArity 2)+  f "DeclaresComputationWithArity3"  = binded (declaresComputationWithArity 3)+  f "DeclaresComputationWithArity4"  = binded (declaresComputationWithArity 4)+  f "DeclaresComputationWithArity5"  = binded (declaresComputationWithArity 5)+  f "DeclaresEntryPoint"             = binded declaresEntryPoint+  f "DeclaresEnumeration"            = binded declaresEnumeration+  f "DeclaresFact"                   = binded declaresFact+  f "DeclaresFunction"               = binded declaresFunction+  f "DeclaresInterface"              = binded declaresInterface+  f "DeclaresMethod"                 = binded declaresMethod+  f "DeclaresObject"                 = binded declaresObject+  f "DeclaresPredicate"              = binded declaresPredicate+  f "DeclaresProcedure"              = binded declaresProcedure+  f "DeclaresRecursively"            = binded declaresRecursively+  f "DeclaresRule"                   = binded declaresRule+  f "DeclaresSuperclass"             = binded declaresSuperclass+  f "DeclaresTypeAlias"              = binded declaresTypeAlias+  f "DeclaresTypeSignature"          = binded declaresTypeSignature+  f "DeclaresVariable"               = binded declaresVariable+  f "Implements"                     = binded implements+  f "Includes"                       = binded includes+  f "Inherits"                       = binded inherits+  f "Instantiates"                   = binded instantiates+  f "Raises"                         = binded raises+  f "Rescues"                        = binded rescues+  f "Uses"                           = binded uses+  f "UsesAnonymousVariable"          = simple usesAnonymousVariable+  f "UsesComposition"                = simple usesComposition+  f "UsesComprehension"              = simple usesComprehension+  f "UsesConditional"                = simple usesConditional+  f "UsesExceptionHandling"          = simple usesExceptionHandling+  f "UsesExceptions"                 = simple usesExceptions+  f "UsesFindall"                    = simple usesFindall+  f "UsesForall"                     = simple usesForall+  f "UsesGuards"                     = simple usesGuards+  f "UsesIf"                         = simple usesIf+  f "UsesInheritance"                = simple usesInheritance+  f "UsesLambda"                     = simple usesLambda+  f "UsesMixins"                     = simple usesMixins+  f "UsesNot"                        = simple usesNot+  f "UsesPatternMatching"            = simple usesPatternMatching+  f "UsesRepeat"                     = simple usesRepeat+  f "UsesSwitch"                     = simple usesSwitch+  f "UsesWhile"                      = simple usesWhile+  f _                                = const Nothing++  simple i _ = Just i+  binded i b = Just $ i b
+ src/Language/Mulang/Analyzer/SampleParser.hs view
@@ -0,0 +1,20 @@+module        Language.Mulang.Analyzer.SampleParser (+  parseSample) where++import        Language.Mulang+import        Language.Mulang.Parsers (EitherParser, maybeToEither)+import        Language.Mulang.Parsers.Haskell+import        Language.Mulang.Parsers.JavaScript (parseJavaScript)+import        Language.Mulang.Parsers.Prolog (parseProlog)+import        Language.Mulang.Parsers.Java (parseJava)+import        Language.Mulang.Analyzer.Analysis (Sample(..), Language(..))++parseSample :: Sample -> Either String Expression+parseSample (CodeSample language content) = (parserFor language) content+parseSample (MulangSample ast)            = Right ast++parserFor :: Language -> EitherParser+parserFor Haskell        = parseHaskell+parserFor Java           = parseJava+parserFor JavaScript     = maybeToEither parseJavaScript+parserFor Prolog         = parseProlog
+ src/Language/Mulang/Analyzer/SignatureStyleCompiler.hs view
@@ -0,0 +1,13 @@+module Language.Mulang.Analyzer.SignatureStyleCompiler (+  compileSignatureStyle) where++import Language.Mulang.Signature as Signature (SignatureStyle,+                                               mulangStyle, untypedCStyle,+                                               haskellStyle, prologStyle)+import Language.Mulang.Analyzer.Analysis as Analysis (SignatureStyle(..))++compileSignatureStyle :: Analysis.SignatureStyle -> Signature.SignatureStyle+compileSignatureStyle MulangStyle = mulangStyle+compileSignatureStyle UntypedCStyle = untypedCStyle+compileSignatureStyle HaskellStyle = haskellStyle+compileSignatureStyle PrologStyle = prologStyle
+ src/Language/Mulang/Analyzer/SignaturesAnalyzer.hs view
@@ -0,0 +1,15 @@+module Language.Mulang.Analyzer.SignaturesAnalyzer (+  analyseSignatures) where++import Language.Mulang+import Language.Mulang.Signature+import Language.Mulang.Analyzer.Analysis (SignatureAnalysisType(..))+import Language.Mulang.Analyzer.SignatureStyleCompiler (compileSignatureStyle)+import Data.Maybe (fromMaybe)++analyseSignatures :: Expression -> Maybe SignatureAnalysisType -> [Code]+analyseSignatures e analysis = analyseSignatures' e (fromMaybe NoSignatures analysis)++analyseSignatures' _ NoSignatures             = []+analyseSignatures' e DefaultSignatures        = codeSignaturesOf e+analyseSignatures' e (StyledSignatures style) = styledCodeSignaturesOf (compileSignatureStyle style) e
+ src/Language/Mulang/Analyzer/SmellsAnalyzer.hs view
@@ -0,0 +1,89 @@+module Language.Mulang.Analyzer.SmellsAnalyzer (+  analyseSmells) where++import Language.Mulang+import Language.Mulang.Inspector.Generic.Smell+import Language.Mulang.DomainLanguage+import Language.Mulang.Analyzer.Analysis hiding (DomainLanguage)+import Data.List+import Data.Maybe (fromMaybe)++analyseSmells :: Expression -> DomainLanguage -> SmellsSet -> [Expectation]+analyseSmells ast language set = concatMap (\smell -> detectSmell smell language ast) (smellsFor set)++detectSmell :: Smell -> DomainLanguage -> Expression -> [Expectation]+detectSmell smell language =  map (exectationFor smell) . detectionFor smell language++smellsFor :: SmellsSet -> [Smell]+smellsFor (NoSmells included)    = fromMaybe [] included+smellsFor (AllSmells excluded)   = allSmells \\ (fromMaybe [] excluded)++allSmells :: [Smell]+allSmells = [+  "DiscardsExceptions",+  "DoesConsolePrint",+  "DoesNullTest",+  "DoesTypeTest",+  "HasAssignmentReturn",+  "HasCodeDuplication",+  "HasLongParameterList",+  "HasMisspelledIdentifiers",+  "HasRedundantBooleanComparison",+  "HasRedundantGuards",+  "HasRedundantIf",+  "HasRedundantLambda",+  "HasRedundantLocalVariableReturn",+  "HasRedundantParameter",+  "HasRedundantReduction",+  "HasTooManyMethods",+  "HasTooShortIdentifiers",+  "HasWrongCaseIdentifiers",+  "IsLongCode",+  "OverridesEqualOrHashButNotBoth",+  "ReturnsNull",+  "UsesCut",+  "UsesFail",+  "UsesUnificationOperator" ]++detectionFor :: Smell -> Detection+detectionFor "DiscardsExceptions"              = simple discardsExceptions+detectionFor "DoesConsolePrint"                = simple doesConsolePrint+detectionFor "DoesNullTest"                    = simple doesNullTest+detectionFor "DoesTypeTest"                    = simple doesTypeTest+detectionFor "HasAssignmentReturn"             = simple hasAssignmentReturn+detectionFor "HasCodeDuplication"              = unsupported+detectionFor "HasLongParameterList"            = simple hasLongParameterList+detectionFor "HasMisspelledIdentifiers"        = withLanguage hasMisspelledIdentifiers+detectionFor "HasMisspelledBindings"           = withLanguage hasMisspelledIdentifiers+detectionFor "HasRedundantBooleanComparison"   = simple hasRedundantBooleanComparison+detectionFor "HasRedundantGuards"              = simple hasRedundantGuards+detectionFor "HasRedundantIf"                  = simple hasRedundantIf+detectionFor "HasRedundantLambda"              = simple hasRedundantLambda+detectionFor "HasRedundantLocalVariableReturn" = simple hasRedundantLocalVariableReturn+detectionFor "HasRedundantParameter"           = simple hasRedundantParameter+detectionFor "HasRedundantReduction"           = simple hasRedundantReduction+detectionFor "HasTooManyMethods"               = simple hasTooManyMethods+detectionFor "HasTooShortIdentifiers"          = withLanguage hasTooShortIdentifiers+detectionFor "HasTooShortBindings"             = withLanguage hasTooShortIdentifiers+detectionFor "HasWrongCaseIdentifiers"         = withLanguage hasWrongCaseIdentifiers+detectionFor "HasWrongCaseBinding"             = withLanguage hasWrongCaseIdentifiers+detectionFor "IsLongCode"                      = unsupported+detectionFor "OverridesEqualOrHashButNotBoth"  = simple overridesEqualOrHashButNotBoth+detectionFor "ReturnsNull"                     = simple returnsNull+detectionFor "UsesCut"                         = simple usesCut+detectionFor "UsesFail"                        = simple usesFail+detectionFor "UsesUnificationOperator"         = simple usesUnificationOperator+detectionFor _                                 = unsupported++type Detection = DomainLanguage -> Expression -> [Identifier]+unsupported :: Detection+unsupported _ _ = []++simple :: Inspection -> Detection+simple inspection _ = detect inspection++withLanguage :: (DomainLanguage -> Inspection) -> Detection+withLanguage inspection language = detect (inspection language)++exectationFor :: Smell -> Identifier -> Expectation+exectationFor smell identifier = Expectation identifier smell
+ src/Language/Mulang/Ast.hs view
@@ -0,0 +1,227 @@+{-# LANGUAGE DeriveGeneric, PatternSynonyms, ViewPatterns #-}++-- | The Ast module describes a generic, abstract language AST.+-- |+-- | Since it only describes the AST, but not many aspects of its semantics, Mulang is non-computable, but just a target+-- | for code analysis.+-- |+-- | Mulang AST itself is the combination of other abstract, paradigmatic languages that express the structures of:+-- |    * imperative programing+-- |    * object-oriented programing+-- |    * functional programing+-- |    * logic programing+-- |+module Language.Mulang.Ast (+    equationParams,+    Code,+    Equation(..),+    EquationBody(..),+    Expression(..),+    ComprehensionStatement(..),+    Pattern(..),+    Identifier,+    pattern SimpleEquation,+    pattern SimpleFunction,+    pattern SimpleProcedure,+    pattern SimpleMethod,+    pattern SimpleSend,+    pattern MuTrue,+    pattern MuFalse,+    pattern Subroutine,+    pattern Clause,+    pattern Call,+    pattern Params+  ) where++import           GHC.Generics+import           Language.Mulang.Identifier (Identifier)++type Code = String++-- | An equation. See @Function@ and @Procedure@ above+data Equation = Equation [Pattern] EquationBody deriving (Eq, Show, Read, Generic)++data EquationBody+         = UnguardedBody Expression+         | GuardedBody  [(Expression, Expression)]+  deriving (Eq, Show, Read, Generic)+++-- | Expression is the root element of a Mulang program.+-- | With the exception of Patterns, nearly everything is an Expression: variable declarations, literals,+-- | control structures, even object oriented classes declarations.+-- |+-- | However, although all those elements can be used as subexpressions and have an dohave an associated value,+-- | Mulang does not state WHICH is that value.+data Expression+    = TypeAlias Identifier+    -- ^ Functional programming type alias.+    --   Only the type alias identifier is parsed+    | Record Identifier+    -- ^ Imperative / Functional programming struct declaration.+    --   Only the record name is parsed+    | TypeSignature Identifier [Identifier] Identifier+    -- ^ Generic type signature for a computation,+    --   composed by a name, parameter types and return type+    | EntryPoint Identifier Expression+    -- ^ Entry point with its body+    | Function Identifier [Equation]+    -- ^ Functional / Imperative programming function declaration.+    --   It is is composed by an identifier and one or more equations+    | Procedure Identifier [Equation]+    -- ^ Imperative programming procedure declaration. It is composed by a name and one or more equations+    | Method Identifier [Equation]+    | EqualMethod [Equation]+    | HashMethod [Equation]+    | Variable Identifier Expression+    | Assignment Identifier Expression+    | Attribute Identifier Expression+    -- ^ Object oriented programming attribute declaration, composed by an identifier and an initializer+    | Object Identifier Expression+    -- ^ Object oriented programming global, named object declaration,+    --   composed by a name and a body+    | Class Identifier (Maybe Identifier) Expression+    -- ^ Object oriented programming global, class declaration,+    --   composed by a name, an optional superclass, implemented interfaces and a body+    | Enumeration Identifier [Identifier]+    -- ^ Imperative named enumeration of values+    | Interface Identifier [Identifier] Expression+    -- ^ Object oriented programming global interface or contract declaration,+    --   composed by a name, superinterfaces and a body+    | Rule Identifier [Pattern] [Expression]+    -- ^ Logic programming declaration of a fact, composed by the rue name, rule arguments, and rule body+    | Fact Identifier [Pattern]+    -- ^ Logic programming declaration of a fact , composed by the fact name and fact arguments+    | Exist Identifier [Pattern]+    -- ^ Logic programming existential cuantification / consult+    | Not Expression+    -- ^ Logic programming negation+    | Findall Expression Expression Expression+    -- ^ Logic programming findall+    | Forall Expression Expression+    -- ^ Logic programming universal cuantification+    | Reference Identifier+    -- ^ Generic variable+    | Application Expression [Expression]+    -- ^ Generic, non-curried application of a function or procedure, composed by the applied element itself, and the application arguments+    | Send Expression Expression [Expression]+    -- ^ Object oriented programming message send, composed by the reciever, selector and arguments+    | New Identifier [Expression]+    -- ^ Object oriented instantiation, composed by the class reference and instantiation arguments+    | Implement Identifier+    -- ^ Object oriented instantiation, interface implementation+    | Include Identifier+    -- ^ Object oriented instantiation, mixin inclusion+    | Lambda [Pattern] Expression+    | If Expression Expression Expression+    | Return Expression+    | While Expression Expression+    -- ^ Imperative programming conditional repetition control structure, composed by a condition and a body+    | Repeat Expression Expression+    -- ^ Imperative programming fixed repetition control structure, composed by a repetition count expression, and a body+    | Match Expression [Equation]+    | Switch Expression [(Expression, Expression)]+    | Try Expression [(Pattern, Expression)] Expression+    -- ^ Generic try expression, composed by a body, a list of exception-handling patterns and statments, and a finally expression+    | Raise Expression+    -- ^ Generic raise expression, like a throw or raise statament, composed by the raised expression+    | Print Expression+    -- ^ Generic print expression+    | Comprehension Expression [ComprehensionStatement]+    | Sequence [Expression]+    -- ^ Generic sequence of statements+    | Other+    | Equal+    | NotEqual+    | Self+    | MuNull+    -- ^ Generic nothing value literal - nil, null, undefined or unit+    | MuObject Expression+    -- ^ Object oriented unnamed object literal+    | MuNumber Double+    -- ^ Generic number literal+    | MuBool Bool+    -- ^ Generic boolean literal+    | MuString String+    -- ^ Generic string literal+    | MuSymbol String+    -- ^ Generic symbol/atom literal+    | MuTuple [Expression]+    | MuList [Expression]+  deriving (Eq, Show, Read, Generic)++-- | Mulang Patterns are not expressions, but are aimed to match them.+-- | They are modeled after Haskell, Prolog, Elixir, Scala and Erlang patterns+data Pattern+    = VariablePattern String+    -- ^ variable pattern like @X@+    | LiteralPattern String+    -- ^ literal constant pattern like @4@+    | InfixApplicationPattern Pattern String Pattern+    -- ^ infix application pattern like @4:X@+    | ApplicationPattern String [Pattern]+    -- ^ prefix application pattern like @f _@+    | TuplePattern [Pattern]+    -- ^ tuple pattern like @(3, _)@+    | ListPattern [Pattern]+    -- ^ list pattern like @[x, y, _]@+    | FunctorPattern Identifier [Pattern]+    -- ^ prolog-like functor pattern, like @f(X, 6)@+    | AsPattern Identifier Pattern+    | TypePattern Identifier+    -- ^ @\@@-pattern+    | WildcardPattern+    -- ^ wildcard pattern @_@+    | UnionPattern [Pattern]+    | OtherPattern+    -- ^ Other unrecognized pattern+  deriving (Eq, Show, Read, Generic)++data ComprehensionStatement+        = MuGenerator Pattern Expression+        | MuQualifier Expression+        | LetStmt     Expression+  deriving (Eq, Show, Read, Generic)+++pattern SimpleEquation params body = Equation params (UnguardedBody body)++pattern SimpleSend receptor selector args = Send receptor (Reference selector) args++pattern SimpleFunction name params body  = Function  name [SimpleEquation params body]+pattern SimpleProcedure name params body = Procedure name [SimpleEquation params body]+pattern SimpleMethod name params body    = Method    name [SimpleEquation params body]++pattern MuTrue  = MuBool True+pattern MuFalse = MuBool False++pattern Subroutine name equations <- (extractSubroutine -> Just (name, equations))+pattern Clause name patterns expressions <- (extractClause -> Just (name, patterns, expressions))++pattern Call operation arguments <- (extractCall -> Just (operation, arguments))++pattern Params params <- (extractParams -> Just params)++equationParams :: Equation -> [Pattern]+equationParams (Equation p _) = p++extractSubroutine :: Expression -> Maybe (Identifier, [Equation])+extractSubroutine (Function name equations)  = Just (name, equations)+extractSubroutine (Procedure name equations) = Just (name, equations)+extractSubroutine (Method name equations)    = Just (name, equations)+extractSubroutine _                          = Nothing++extractParams :: Expression -> Maybe ([Pattern])+extractParams (Subroutine _ equations) = Just (equationParams.head $ equations)+extractParams (Clause _ params _)      = Just params+extractParams _                        = Nothing++extractCall :: Expression -> Maybe (Expression, [Expression])+extractCall (Application op args)   = Just (op, args)+extractCall (Send receptor op args) = Just (op, (receptor:args))+extractCall _                       = Nothing++extractClause :: Expression -> Maybe (Identifier, [Pattern], [Expression])+extractClause (Fact name patterns)             = Just (name, patterns, [])+extractClause (Rule name patterns expressions) = Just (name, patterns, expressions)+extractClause _                                = Nothing
+ src/Language/Mulang/Builder.hs view
@@ -0,0 +1,52 @@+module Language.Mulang.Builder (compact, compactMap, compactConcatMap, normalize) where++import Language.Mulang.Ast++compactConcatMap :: (a -> [Expression]) -> [a] -> Expression+compactConcatMap f = compact . concat . map f++compactMap :: (a -> Expression) -> [a] -> Expression+compactMap f = compact . map f++compact :: [Expression] -> Expression+compact []  = MuNull+compact [e] = e+compact es  = Sequence es++normalize :: Expression -> Expression+normalize (Variable n (MuObject e))        = Object n (normalizeInObject e)+normalize (Variable n (Lambda vars e))     = SimpleFunction n vars (normalize e)+normalize (Variable n e)                   = Variable n (normalize e)+normalize (Function n equations)           = Function n (map normalizeEquation equations)+normalize (Procedure n equations)          = Procedure n (map normalizeEquation equations)+normalize (Fact n args)                    = Fact n args+normalize (Rule n args es)                 = Rule n args (map normalize es)+normalize (Method n equations)             = Method n (map normalizeEquation equations)+normalize (Attribute n e)                  = Attribute n (normalize e)+normalize (Object n e)                     = Object n (normalizeInObject e)+normalize (Application (Send r m []) args) = Send (normalize r) (normalize m) (map normalize args)+normalize (Application e es)               = Application (normalize e) (map normalize es)+normalize (Send r e es)                    = Send (normalize r) (normalize e) (map normalize es)+normalize (Lambda ps e2)                   = Lambda ps (normalize e2)+normalize (If e1 e2 e3)                    = If (normalize e1) (normalize e2) (normalize e3)+normalize (While e1 e2)                    = While (normalize e1) (normalize e2)+normalize (Match e1 equations)             = Match (normalize e1) (map normalizeEquation equations)+normalize (Comprehension e1 stms)          = Comprehension (normalize e1) stms+normalize (Return e)                       = Return (normalize e)+normalize (Not e)                          = Not (normalize e)+normalize (Forall e1 e2)                   = Forall (normalize e1) (normalize e2)+normalize (Sequence es)                    = Sequence (map normalize es)+normalize (MuObject e)                     = MuObject (normalize e)+normalize (MuTuple es)                     = MuTuple (map normalize es)+normalize (MuList es)                      = MuList (map normalize es)+normalize e = e++normalizeInObject (Function n eqs)             = Method n (map normalizeEquation eqs)+normalizeInObject (Variable n (Lambda vars e)) = SimpleMethod n vars (normalize e)+normalizeInObject (Variable n e)               = Attribute n (normalize e)+normalizeInObject (Sequence es)                = Sequence (map normalizeInObject es)+normalizeInObject e                            = normalize e++normalizeEquation :: Equation -> Equation+normalizeEquation (Equation ps (UnguardedBody e))   = Equation ps (UnguardedBody (normalize e))+normalizeEquation (Equation ps (GuardedBody b))     = Equation ps (GuardedBody (map (\(c, e) -> (normalize c, normalize e)) b))
+ src/Language/Mulang/DomainLanguage.hs view
@@ -0,0 +1,42 @@+module Language.Mulang.DomainLanguage (+  hasTooShortIdentifiers,+  hasWrongCaseIdentifiers,+  hasMisspelledIdentifiers,+  DomainLanguage(..)) where++import Language.Mulang.Inspector (Inspection)+import Language.Mulang.Ast (Expression)+import Language.Mulang.Generator (mainDeclaredIdentifiers)++import Text.Dictionary (Dictionary, exists)++import Text.Inflections.Tokenizer (CaseStyle, tokenize, canTokenize)+++data DomainLanguage = DomainLanguage {+                          dictionary :: Dictionary,+                          caseStyle :: CaseStyle,+                          minimumIdentifierSize :: Int,+                          jargon :: [String] }++type DomainLanguageInspection = DomainLanguage -> Inspection++hasTooShortIdentifiers :: DomainLanguageInspection+hasTooShortIdentifiers language = any isShort . mainDeclaredIdentifiers+  where isShort identifier = length identifier < (minimumIdentifierSize language) && notJargonOf identifier language++hasMisspelledIdentifiers :: DomainLanguageInspection+hasMisspelledIdentifiers language | emptyDictionary language = const False+hasMisspelledIdentifiers language = any isMisspelled  . wordsOf language+  where isMisspelled identifier = not (identifier `exists` dictionary language) && notJargonOf identifier language++hasWrongCaseIdentifiers :: DomainLanguageInspection+hasWrongCaseIdentifiers (DomainLanguage _ style _ _)+  = any (not . canTokenize style) . mainDeclaredIdentifiers++wordsOf :: DomainLanguage -> Expression -> [String]+wordsOf (DomainLanguage _ style _ _) = concatMap (tokenize style) . mainDeclaredIdentifiers++emptyDictionary = null . dictionary++notJargonOf identifier language = notElem identifier (jargon language)
− src/Language/Mulang/Explorer.hs 
@@ -1,92 +0,0 @@-module Language.Mulang.Explorer (-  parseDecls,-  parseBindings,-  declsOf,-  rhssOf,-  bindingsOf,-  transitiveBindingsOf,-  expressionsOf,-  expressionToBinding,-  Expression(..),-  Binding) where--import Language.Mulang-import Data.Maybe (maybeToList)-import Data.List (nub)--type Binding = String--declName :: Declaration -> String-declName (TypeSignature b ) = b-declName (TypeAlias b ) = b-declName (ConstantDeclaration n _ _) = n-declName (FunctionDeclaration n _)  = n-declName _                  = []--declsOf :: Binding -> Program -> [Declaration]-declsOf binding = filter (isBinding binding) . parseDecls--rhssOf :: Binding -> Program -> [Rhs]-rhssOf binding = concatMap rhsForBinding . declsOf binding--expressionsOf :: Binding -> Program -> [Expression]-expressionsOf binding code = do-  rhs <- rhssOf binding code-  top <- topExpressions rhs-  unfoldExpression top--bindingsOf :: Binding -> Program -> [Binding]-bindingsOf binding code = nub $ do-          expr <- expressionsOf binding code-          maybeToList . expressionToBinding $ expr--transitiveBindingsOf :: Binding -> Program -> [Binding]-transitiveBindingsOf binding code =  expand (`bindingsOf` code) binding--parseDecls :: Program -> [Declaration]-parseDecls (Program decls) = decls--parseBindings :: Program -> [Binding]-parseBindings = map declName . parseDecls--expressionToBinding :: Expression -> Maybe Binding-expressionToBinding (Variable    q) = Just q-expressionToBinding _                = Nothing---- private--topExpressions :: Rhs -> [Expression]-topExpressions (UnguardedRhs e) = [e]-topExpressions (GuardedRhss rhss) = rhss >>= \(GuardedRhs es1 es2) -> [es1, es2]--unfoldExpression :: Expression -> [Expression]-unfoldExpression expr = expr : concatMap unfoldExpression (subExpressions expr)--subExpressions :: Expression -> [Expression]-subExpressions (InfixApplication a b c) = [a, (Variable b), c]-subExpressions (Application a b)        = [a, b]-subExpressions (Lambda _ a)   = [a]-subExpressions (MuList as)      = as-subExpressions (Comprehension a _)   = [a] --TODO-subExpressions (MuTuple as)      = as-subExpressions (If a b c)       = [a, b, c]-subExpressions _ = []--isBinding :: Binding -> Declaration -> Bool-isBinding binding = (==binding).declName--rhsForBinding :: Declaration -> [Rhs]-rhsForBinding (ConstantDeclaration _ rhs localDecls) = concatRhs rhs localDecls-rhsForBinding (FunctionDeclaration _ cases) = cases >>= \(Equation _ rhs localDecls) -> concatRhs rhs localDecls-rhsForBinding _ = []--concatRhs rhs l = [rhs] ++ concatMap rhsForBinding l---expand :: Eq a => (a-> [a]) -> a -> [a]-expand f x = expand' [] f [x]--expand' _ _ [] = []-expand' ps f (x:xs) | elem x ps = expand' ps f xs-                    | otherwise = [x] ++ expand' (x:ps) f (xs ++ f x)-
+ src/Language/Mulang/Generator.hs view
@@ -0,0 +1,139 @@+module Language.Mulang.Generator (+  boundDeclarations,+  declarations,+  declarationsOf,+  declaredIdentifiers,+  mainDeclaredIdentifiers,+  equationBodies,+  expressions,+  referencedIdentifiers,+  identifierReferences,+  transitiveReferencedIdentifiers,+  Generator,+  Expression(..)) where++import Language.Mulang.Ast+import Language.Mulang.Identifier++import Data.Maybe (mapMaybe)+import Data.List (nub)++type Generator a = Expression -> [a]++-- | Returns all the declarations their identifiers -+-- | classes, methods, functions, records, local and global variables, and so on+-- |+-- | For example, in 'f x = g x where x = y', it returns '(f, f x = ...)' and '(x, x = y)'+declarations :: Generator (Identifier, Expression)+declarations (Sequence es)          = concatMap declarations es+declarations e@(Attribute n _)      = [(n, e)]+declarations e@(Class n _ b)        = (n, e) : declarations b+declarations e@(Clause n _ es)      = (n, e) : concatMap declarations es+declarations e@(Enumeration n _)    = [(n, e)]+declarations e@(Interface n _ b)    = (n, e) : declarations b+declarations e@(EntryPoint n b)     = (n, e) : declarations b+declarations e@(Subroutine n b)     = (n, e) : concatMap declarations (equationExpressions b)+declarations e@(Object n b)         = (n, e) : declarations b+declarations e@(Clause n _ _)       = [(n, e)]+declarations e@(Record n)           = [(n, e)]+declarations e@(TypeAlias n)        = [(n, e)]+declarations e@(TypeSignature n _ _)= [(n, e)]+declarations e@(Variable n _)       = [(n, e)]+declarations _                      = []++-- | Returns all declarations bound to the given identifier predicate+-- |+boundDeclarations :: IdentifierPredicate -> Generator Expression+boundDeclarations f = map snd . filter (f.fst) . declarations++-- | Returns the given expression and all its subexpressions+-- For example: in 'f x = x + 1', it returns 'f x = x + 1', 'x + 1', 'x' and '1'+expressions :: Generator Expression+expressions expr = expr : concatMap expressions (subExpressions expr)+  where+    subExpressions :: Generator Expression+    subExpressions (Assignment _ e)        = [e]+    subExpressions (Attribute _ v)         = [v]+    subExpressions (Call op args)          = op:args+    subExpressions (Class _ _ v)           = [v]+    subExpressions (Clause _ _ es)         = es+    subExpressions (Comprehension a _)     = [a] --TODO+    subExpressions (EntryPoint _ e)        = [e]+    subExpressions (Forall e1 e2)          = [e1, e2]+    subExpressions (If a b c)              = [a, b, c]+    subExpressions (Interface _ _ v)       = [v]+    subExpressions (Lambda _ a)            = [a]+    subExpressions (Match e1 equations)    = e1:equationExpressions equations+    subExpressions (MuList as)             = as+    subExpressions (MuObject es)           = [es]+    subExpressions (MuTuple as)            = as+    subExpressions (New _ es)              = es+    subExpressions (Not e)                 = [e]+    subExpressions (Object _ v)            = [v]+    subExpressions (Repeat e1 e2)          = [e1, e2]+    subExpressions (Return v)              = [v]+    subExpressions (Sequence es)           = es+    subExpressions (Subroutine _ es)       = equationExpressions es+    subExpressions (Switch e1 list)        = e1 : concatMap (\(x,y) -> [x,y]) list+    subExpressions (Try t cs f)            = t : map snd cs ++ [f]+    subExpressions (Variable _ v)          = [v]+    subExpressions (While e1 e2)           = [e1, e2]+    subExpressions _                       = []+++-- | Returns all the referenced identifiers+-- For example, in 'f (x + 1)', it returns 'f' and 'x'+referencedIdentifiers :: Generator Identifier+referencedIdentifiers = nub . identifierReferences++identifierReferences :: Generator Identifier+identifierReferences = mapMaybe extractReference . expressions+++-- | Returns all the identifiers transitively referenced by the given one+-- |+transitiveReferencedIdentifiers :: Identifier -> Generator Identifier+transitiveReferencedIdentifiers identifier code =  expand (concatMap referencedIdentifiers . (`declarationsOf` code)) identifier+  where+    expand :: Eq a => (a-> [a]) -> a -> [a]+    expand f x = expand' [] f [x]++    expand' _ _ [] = []+    expand' ps f (x:xs) | elem x ps = expand' ps f xs+                        | otherwise = [x] ++ expand' (x:ps) f (xs ++ f x)+++-- | Returns all the declared identifiers+-- For example, in 'f x = g x where x = y', it returns 'f' and 'x'+declaredIdentifiers :: Generator Identifier+declaredIdentifiers = map fst . declarations++mainDeclaredIdentifiers :: Generator Identifier+mainDeclaredIdentifiers (Sequence _) = []+mainDeclaredIdentifiers expression   = take 1 . declaredIdentifiers $ expression++-- | Returns all the body equations of functions, procedures and methods+equationBodies :: Generator EquationBody+equationBodies = concatMap (bodiesOf . snd) . declarations+  where+    bodiesOf :: Generator EquationBody+    bodiesOf (Subroutine  _ equations) = equationBodies equations+    bodiesOf _ = []++    equationBodies = map (\(Equation _ body) -> body)++declarationsOf :: Identifier -> Generator Expression+declarationsOf b = boundDeclarations (named b)++extractReference :: Expression -> Maybe Identifier+extractReference (Reference n)        = Just n+extractReference (Exist n _)          = Just n+extractReference (New n _)            = Just n+extractReference (Implement n)        = Just n+extractReference (Include n)          = Just n+extractReference _                    = Nothing++equationExpressions = concatMap (\(Equation _ body) -> bodyExpressions body)+  where+    bodyExpressions (UnguardedBody e)      = [e]+    bodyExpressions (GuardedBody b)        = b >>= \(es1, es2) -> [es1, es2]
+ src/Language/Mulang/Identifier.hs view
@@ -0,0 +1,34 @@+module Language.Mulang.Identifier (+  andAlso,+  anyOf,+  anyone,+  except,+  like,+  named,+  Identifier,+  IdentifierPredicate) where++import  Data.List (isInfixOf)++-- | An identifier+-- | Mulang does not assume any special naming convention or format+type Identifier = String+type IdentifierPredicate = Identifier -> Bool++andAlso :: IdentifierPredicate -> IdentifierPredicate -> IdentifierPredicate+andAlso p1 p2 identifier = p1 identifier && p2 identifier++anyOf :: [Identifier] -> IdentifierPredicate+anyOf options identifier = any (== identifier) options++anyone :: IdentifierPredicate+anyone = const True++except :: String -> IdentifierPredicate+except = (/=)++like :: String -> IdentifierPredicate+like = isInfixOf++named :: String -> IdentifierPredicate+named = (==)
src/Language/Mulang/Inspector.hs view
@@ -1,133 +1,15 @@ module Language.Mulang.Inspector (-  hasComposition,-  hasGuards,-  hasIf,-  hasConditional,-  hasLambda,-  hasDirectRecursion,-  hasUsage,-  hasComprehension,-  hasBinding,-  hasFunctionDeclaration,-  hasArity,-  hasTypeDeclaration,-  hasTypeSignature,-  hasAnonymousVariable,-  hasExpression,-  hasDecl,-  hasRhs,-  Inspection,-  GlobalInspection-  ) where--import  Language.Mulang-import  Language.Mulang.Explorer--type Inspection = Binding -> Program  -> Bool-type GlobalInspection = Program  -> Bool---- | Inspection that tells whether a binding uses the composition operator '.'--- in its definition-hasComposition :: Inspection-hasComposition = hasExpression f-  where f (Variable ".") = True-        f _ = False---- | Inspection that tells whether a binding uses guards--- in its definition-hasGuards :: Inspection-hasGuards = hasRhs f-  where f (GuardedRhss _) = True-        f _ = False---- | Inspection that tells whether a binding uses ifs--- in its definition-hasIf :: Inspection-hasIf = hasExpression f-  where f (If _ _ _) = True-        f _ = False---- | Inspection that tells whether a binding uses ifs or guards--- in its definition-hasConditional :: Inspection-hasConditional target code = hasIf target code || hasGuards target code---- | Inspection that tells whether a binding uses a lambda expression--- in its definition-hasLambda :: Inspection-hasLambda = hasExpression f-  where f (Lambda _ _) = True-        f _ = False----- | Inspection that tells whether a binding is direct recursive-hasDirectRecursion :: Inspection-hasDirectRecursion binding = hasUsage binding binding---- | Inspection that tells whether a binding uses the the given target binding--- in its definition-hasUsage :: String -> Inspection-hasUsage target = hasExpression f-  where f expr | (Just n) <- expressionToBinding expr = n == target-               | otherwise = False---- | Inspection that tells whether a binding uses--- comprehensions - list comprehension, for comprehension, do-syntax, etc ---- in its definitions-hasComprehension :: Inspection-hasComprehension = hasExpression f-  where f (Comprehension _ _) = True-        f _ = False---- | Inspection that tells whether a top level binding exists-hasBinding :: Inspection-hasBinding binding = not.null.rhssOf binding--hasFunctionDeclaration :: Inspection-hasFunctionDeclaration funBinding = has f (declsOf funBinding)-  where f (FunctionDeclaration _ _) = True-        f (ConstantDeclaration _ (UnguardedRhs (Lambda _ _)) _) = True-        f (ConstantDeclaration _ (UnguardedRhs (Variable _)) _) = True -- not actually always true-        f _  = False--hasArity :: Int -> Inspection-hasArity arity funBinding = has f (declsOf funBinding)-  where f (FunctionDeclaration _ equations) = any equationHasArity equations-        f (ConstantDeclaration _ (UnguardedRhs (Lambda args _)) _) = argsHaveArity args-        f _  = False--        equationHasArity = \(Equation args _ _) -> argsHaveArity args--        argsHaveArity args = length args == arity--hasTypeDeclaration :: Inspection-hasTypeDeclaration binding = hasDecl f-  where f (TypeAlias name) = binding == name-        f _                   = False--hasTypeSignature :: Inspection-hasTypeSignature binding = hasDecl f-  where f (TypeSignature name)  = binding == name-        f _                       = False--hasAnonymousVariable :: Inspection-hasAnonymousVariable binding = has f (declsOf binding)-  where f (FunctionDeclaration _ equations)    = any (any (== WildcardPattern) . p) equations-        f _                        = False-        p (Equation params _ _) = params--hasExpression :: (Expression -> Bool) -> Inspection-hasExpression f binding = has f (expressionsOf binding)--hasRhs :: (Rhs -> Bool)-> Inspection-hasRhs f binding = has f (rhssOf binding)--hasDecl :: (Declaration -> Bool) -> GlobalInspection-hasDecl f = has f parseDecls---- private--has f g = any f . g-+  module Language.Mulang.Inspector.Generic,+  module Language.Mulang.Inspector.Combiner,+  module Language.Mulang.Inspector.ObjectOriented,+  module Language.Mulang.Inspector.Functional,+  module Language.Mulang.Inspector.Logic,+  module Language.Mulang.Inspector.Procedural) where  +import Language.Mulang.Inspector.Generic+import Language.Mulang.Inspector.Combiner+import Language.Mulang.Inspector.ObjectOriented+import Language.Mulang.Inspector.Functional+import Language.Mulang.Inspector.Logic+import Language.Mulang.Inspector.Procedural
src/Language/Mulang/Inspector/Combiner.hs view
@@ -1,18 +1,36 @@ module Language.Mulang.Inspector.Combiner (   detect,   negative,-  transitive) where+  alternative,+  scoped,+  scopedList,+  transitive,+  transitiveList) where -import Language.Mulang-import Language.Mulang.Inspector-import Language.Mulang.Explorer+import Language.Mulang.Ast+import Language.Mulang.Generator (transitiveReferencedIdentifiers, declarationsOf, declaredIdentifiers)+import Language.Mulang.Inspector.Generic -detect :: Inspection -> Program -> [Binding]-detect inspection code = filter (`inspection` code) $ parseBindings code+detect :: Inspection -> Expression -> [Identifier]+detect i expression =+  filter (`inspection` expression) $ declaredIdentifiers expression+    where inspection = scoped i +alternative :: Inspection -> Inspection -> Inspection+alternative i1 i2 expression = i1 expression || i2 expression+ negative :: Inspection -> Inspection-negative f code = not . f code+negative f = not . f -transitive :: Inspection -> Inspection-transitive inspection binding code = inspection binding code || inUsage-  where inUsage = any (`inspection` code) . transitiveBindingsOf binding $ code+scoped :: Inspection -> Identifier -> Inspection+scoped inspection scope =  any inspection . declarationsOf scope++scopedList :: Inspection -> [Identifier] -> Inspection+scopedList i =  foldl scoped i . reverse++transitive :: Inspection -> Identifier -> Inspection+transitive inspection identifier code = any (`scopedInspection` code) . transitiveReferencedIdentifiers identifier $ code+  where scopedInspection = scoped inspection++transitiveList :: Inspection -> [Identifier] -> Inspection+transitiveList i identifiers = transitive (scopedList i (init identifiers)) (last identifiers)
+ src/Language/Mulang/Inspector/Functional.hs view
@@ -0,0 +1,58 @@+module Language.Mulang.Inspector.Functional (+  usesGuards,+  usesComposition,+  usesLambda,+  usesPatternMatching,+  usesComprehension,+  usesConditional) where++import Language.Mulang.Ast+import Language.Mulang.Inspector.Generic+import Language.Mulang.Inspector.Combiner++usesConditional :: Inspection+usesConditional = alternative usesIf usesGuards+++-- | Inspection that tells whether an expression uses the composition operator '.'+-- in its definition+usesComposition :: Inspection+usesComposition = containsExpression f+  where f (Reference ".") = True+        f _ = False++-- | Inspection that tells whether an expression uses pattern matching+-- in its definition+usesPatternMatching :: Inspection+usesPatternMatching = containsExpression f+  where f (Function _ equations) = any nonVariablePattern (patterns equations)+        f _ = False++        patterns = concatMap (\(Equation ps _) -> ps)++        nonVariablePattern :: Pattern -> Bool+        nonVariablePattern (VariablePattern _) = False+        nonVariablePattern _                   = True+++-- | Inspection that tells whether an expression uses+-- comprehensions - list comprehension, for comprehension, do-syntax, etc -+-- in its definitions+usesComprehension :: Inspection+usesComprehension = containsExpression f+  where f (Comprehension _ _) = True+        f _ = False++-- | Inspection that tells whether an expression uses a lambda expression+-- in its definition+usesLambda :: Inspection+usesLambda = containsExpression f+  where f (Lambda _ _) = True+        f _ = False++-- | Inspection that tells whether an expression uses guards+-- in its definition+usesGuards :: Inspection+usesGuards = containsBody f+  where f (GuardedBody _) = True+        f _ = False
+ src/Language/Mulang/Inspector/Generic.hs view
@@ -0,0 +1,191 @@+module Language.Mulang.Inspector.Generic (+  parses,+  assigns,+  calls,+  uses,+  usesIf,+  declares,+  declaresVariable,+  declaresRecursively,+  declaresEntryPoint,+  declaresFunction,+  declaresComputation,+  declaresComputationWithArity,+  declaresComputationWithArity',+  declaresTypeAlias,+  declaresTypeSignature,+  usesAnonymousVariable,+  raises,+  rescues,+  usesExceptions,+  usesExceptionHandling,+  containsExpression,+  containsDeclaration,+  containsBoundDeclaration,+  containsBody,+  matchesType,+  Inspection,+  IdentifierInspection) where++import Language.Mulang.Ast+import Language.Mulang.Identifier+import Language.Mulang.Generator (expressions, boundDeclarations, equationBodies, declarations, referencedIdentifiers)++import Data.Maybe (listToMaybe)++type Inspection = Expression  -> Bool+type IdentifierInspection = IdentifierPredicate -> Inspection++-- | Inspection that tells whether an expression is equal to a given piece of code after being parsed+parses :: (String -> Expression) -> String -> Inspection+parses parser code = (== (parser code))++assigns :: IdentifierInspection+assigns predicate = containsExpression f+  where f (Assignment name _)  = predicate name+        f (Variable name _)    = predicate name+        f (Attribute name _)   = predicate name+        f _                    = False++-- | Inspection that tells whether an expression uses the the given target identifier+-- in its definition+uses :: IdentifierInspection+uses p = containsExpression f+  where f = any p . referencedIdentifiers++calls :: IdentifierInspection+calls p = containsExpression f+  where f (Call (Reference id) _ ) = p id+        f _                        = False+++-- | Inspection that tells whether an expression uses ifs+-- in its definition+usesIf :: Inspection+usesIf = containsExpression f+  where f (If _ _ _) = True+        f _          = False++-- | Inspection that tells whether a top level declaration exists+declares :: IdentifierInspection+declares = containsBoundDeclaration f+  where f (TypeSignature _ _ _) = False+        f _                     = True++-- | Inspection that tells whether an expression is direct recursive+declaresRecursively :: IdentifierInspection+declaresRecursively = containsBoundDeclaration f+  where f e | (Just name) <- (nameOf e) = uses (named name) e+            | otherwise = False++        nameOf :: Expression -> Maybe Identifier+        nameOf = fmap fst . listToMaybe . declarations+++declaresFunction :: IdentifierInspection+declaresFunction = containsBoundDeclaration f+  where f (Function _ _) = True+        f _              = False++declaresVariable :: IdentifierInspection+declaresVariable = containsBoundDeclaration f+  where f (Variable _ _)  = True+        f _               = False++declaresEntryPoint :: IdentifierInspection+declaresEntryPoint = containsBoundDeclaration f+  where f (EntryPoint _ _)  = True+        f _                 = False++-- | Inspection that tells whether a top level computation declaration exists+declaresComputation :: IdentifierInspection+declaresComputation = declaresComputationWithArity' (const True)++declaresComputationWithArity :: Int -> IdentifierInspection+declaresComputationWithArity arity = declaresComputationWithArity' (== arity)++declaresComputationWithArity' :: (Int -> Bool) -> IdentifierInspection+declaresComputationWithArity' arityPredicate = containsBoundDeclaration f+  where f (Subroutine _ es)       = any equationArityIs es+        f (Clause _ args _)       = argsHaveArity args+        f _  = False++        equationArityIs (Equation args _) = argsHaveArity args++        argsHaveArity = arityPredicate.length++declaresTypeAlias :: IdentifierInspection+declaresTypeAlias = containsBoundDeclaration f+  where f (TypeAlias _) = True+        f _             = False++declaresTypeSignature :: IdentifierInspection+declaresTypeSignature = containsBoundDeclaration f+  where f (TypeSignature _ _ _) = True+        f _                     = False++raises :: IdentifierInspection+raises predicate = containsExpression f+  where f (Raise (New n _))     = predicate n+        f (Raise (Reference n)) = predicate n+        f _                     = False++usesExceptions :: Inspection+usesExceptions = containsExpression f+  where f (Raise _)     = True+        f _             = False++rescues :: IdentifierInspection+rescues predicate = containsExpression f+  where f (Try _ rescues _) = any (matchesType predicate) . map fst  $ rescues+        f _                 = False++usesExceptionHandling :: Inspection+usesExceptionHandling  = containsExpression f+  where f (Try _ _ _) = True+        f _           = False++usesAnonymousVariable :: Inspection+usesAnonymousVariable = containsExpression f+  where f (Subroutine _ equations)    = equationContainsWildcard equations+--TODO        f (Lambda args _)                      = equationContainsWildcard equations+        f (Clause _ params _)         = paramsContainsWildcard params+        f _                           = False++        equationContainsWildcard = any (paramsContainsWildcard . equationParams)+        paramsContainsWildcard = any isOrContainsWildcard++        isOrContainsWildcard (InfixApplicationPattern p1 _ p2) = any isOrContainsWildcard [p1, p2]+        isOrContainsWildcard (ApplicationPattern _ ps)         = any isOrContainsWildcard ps+        isOrContainsWildcard (TuplePattern ps)                 = any isOrContainsWildcard ps+        isOrContainsWildcard (ListPattern ps)                  = any isOrContainsWildcard ps+        isOrContainsWildcard (FunctorPattern _ ps)             = any isOrContainsWildcard ps+        isOrContainsWildcard (AsPattern _ p)                   = isOrContainsWildcard p+        isOrContainsWildcard WildcardPattern                   = True+        isOrContainsWildcard _                                 = False+++containsExpression :: (Expression -> Bool) -> Inspection+containsExpression f = has f expressions++containsBody :: (EquationBody -> Bool)-> Inspection+containsBody f = has f equationBodies++containsBoundDeclaration :: (Expression -> Bool) -> IdentifierInspection+containsBoundDeclaration f b  = has f (boundDeclarations b)++containsDeclaration :: (Expression -> Bool) -> Inspection+containsDeclaration f = has f (map snd . declarations)++matchesType :: IdentifierPredicate -> Pattern -> Bool+matchesType predicate (TypePattern n)               = predicate n+matchesType predicate (AsPattern _ (TypePattern n)) = predicate n+matchesType predicate (UnionPattern patterns)       = any (matchesType predicate) patterns+matchesType _         _                             = False++-- private++has f g = any f . g+++
+ src/Language/Mulang/Inspector/Generic/Duplication.hs view
@@ -0,0 +1,62 @@+module Language.Mulang.Inspector.Generic.Duplication (hasCodeDuplication) where++import           Language.Mulang.Ast+import           Language.Mulang.Inspector+import           Language.Mulang.Generator (expressions)+import qualified Data.Hashable as H (hash)+import           Data.List (nub, subsequences)++hasCodeDuplication :: Inspection+hasCodeDuplication e =  hasDuplicates $ map hash $ filter (not . isLightweight) $ concat $ stripesOf 2 e++isLightweight :: Inspection+isLightweight (MuNumber _)              = True+isLightweight (MuString _)              = True+isLightweight (MuBool _)                = True+isLightweight (Reference _)             = True+isLightweight Self                      = True+isLightweight MuNull                    = True+isLightweight Equal                     = True+isLightweight (Application _ es)        = not $ any isApplication es+isLightweight (Return e)                = isLightweight e+isLightweight (Assignment _ e)  = isLightweight e+isLightweight (Variable _ e) = isLightweight e+isLightweight _                         = False++isApplication (Application _ _) = True+isApplication _                 = False+++hasDuplicates ::Eq a => [a] -> Bool+hasDuplicates xs = nub xs /= xs+++hash :: Expression -> Int+hash (Return e)                    = 1 * (37 + hash e)+hash (MuNumber e)                  = 2 * H.hash e+hash (MuString e)                  = 3 * H.hash e+hash (Reference i)                 = 5 * H.hash i+hash (MuBool e)                    = 7 * H.hash e+hash (Application i es)            = 11 * (37 + hash i) * (positionalHash es)+hash (SimpleFunction _ _ body)     = 13 * (37 + hash body)+hash Self                          = 15+hash (SimpleProcedure _ _ body)    = 17 * (37 + hash body)+hash (Sequence es)                 = 19 * (37 + positionalHash es)+hash _                             = 1++positionalHash :: [Expression] -> Int+positionalHash = sum . zipWith hashElement [1..] . reverse+        where+          hashElement :: Int -> Expression -> Int+          hashElement index expression = (31^index) * hash expression++stripesOf :: Int -> Expression -> [[Expression]]+stripesOf n = concatMap (makeStripes n) . expressions++makeStripes :: Int -> Expression -> [[Expression]]+makeStripes n (Sequence xs) = stripes n xs+makeStripes _ e             = [[e]]++stripes :: Int -> [a] -> [[a]]+stripes n = filter ( (>n) . length) . subsequences+
+ src/Language/Mulang/Inspector/Generic/Smell.hs view
@@ -0,0 +1,142 @@+module Language.Mulang.Inspector.Generic.Smell (+  hasRedundantBooleanComparison,+  hasRedundantIf,+  hasRedundantGuards,+  hasRedundantLambda,+  hasRedundantParameter,+  hasRedundantLocalVariableReturn,+  hasAssignmentReturn,+  doesNullTest,+  doesTypeTest,+  isLongCode,+  returnsNull,+  discardsExceptions,+  doesConsolePrint,+  hasLongParameterList,+  hasTooManyMethods,+  overridesEqualOrHashButNotBoth) where++import Language.Mulang.Ast+import Language.Mulang.Inspector+import Language.Mulang.Generator(identifierReferences)++-- | Inspection that tells whether an identifier has expressions like 'x == True'+hasRedundantBooleanComparison :: Inspection+hasRedundantBooleanComparison = compares isBooleanLiteral++doesNullTest :: Inspection+doesNullTest = compares f+  where f MuNull = True+        f _      = False++doesTypeTest :: Inspection+doesTypeTest = compares f+  where f (MuString _) = True+        f _            = False++isLongCode :: Inspection+isLongCode = containsExpression f+  where f (Sequence xs)  = (length xs) >= 16+        f  _             = False++compares :: (Expression -> Bool) -> Inspection+compares f = containsExpression (any f.comparisonOperands)++comparisonOperands (Call Equal    [a1, a2])   = [a1, a2]+comparisonOperands (Call NotEqual [a1, a2])   = [a1, a2]+comparisonOperands _                          = []++returnsNull :: Inspection+returnsNull = containsExpression f+  where f (Return MuNull) = True+        f _               = False++-- | Inspection that tells whether an identifier has an if expression where both branches return+-- boolean literals+hasRedundantIf :: Inspection+hasRedundantIf = containsExpression f+  where f (If _ (Assignment v1 x) (Assignment v2 y)) = all isBooleanLiteral [x, y] && v1 == v2+        f (If _ (Variable v1 x) (Variable v2 y))     = all isBooleanLiteral [x, y] && v1 == v2+        f (If _ (Return x) (Return y))               = all isBooleanLiteral [x, y]+        f (If _ x y)                                 = all isBooleanLiteral [x, y]+        f _                                          = False++-- | Inspection that tells whether an identifier has guards where both branches return+-- boolean literals+hasRedundantGuards :: Inspection+hasRedundantGuards = containsBody f -- TODO not true when condition is a pattern+  where f (GuardedBody [+            (_, Return x),+            (Reference "otherwise", Return y)]) = all isBooleanLiteral [x, y]+        f _ = False+++-- | Inspection that tells whether an identifier has lambda expressions like '\x -> g x'+hasRedundantLambda :: Inspection+hasRedundantLambda = containsExpression f+  where f (Lambda [VariablePattern (x)] (Return (Call _ [Reference (y)]))) = x == y+        f _ = False+++-- | Inspection that tells whether an identifier has parameters that+-- can be avoided using point-free+hasRedundantParameter :: Inspection+hasRedundantParameter = containsExpression f+  where f function@(SimpleFunction _ params (Return (Application _ args))) | (VariablePattern param) <- last params,+                                                                             (Reference arg) <- last args = param == arg && showsUpOnlyOnce param (identifierReferences function)+        f _ = False+        showsUpOnlyOnce p = (==1).countElem p+        countElem p = length.filter (==p)++isBooleanLiteral (MuBool _) = True+isBooleanLiteral _          = False++hasRedundantLocalVariableReturn :: Inspection+hasRedundantLocalVariableReturn = containsExpression f+  where f (Sequence [ Variable declaredVariable _,+                      Return (Reference returnedVariable)]) = returnedVariable == declaredVariable+        f _                                                 = False++hasAssignmentReturn :: Inspection+hasAssignmentReturn = containsExpression f+  where f (Return (Assignment _ _)) = True+        f (Return (Variable _ _))   = True+        f _                         = False++discardsExceptions :: Inspection+discardsExceptions = containsExpression f+  where f (Try _ [(_, MuNull)] _)  = True+        f (Try _ [(_, Print _)] _) = True+        f _                        = False+++doesConsolePrint :: Inspection+doesConsolePrint = containsExpression f+  where f (Print _) = True+        f _         = False++hasLongParameterList :: Inspection+hasLongParameterList = containsExpression f+  where f (Params p) = (>4).length $ p+        f _ = False++hasTooManyMethods :: Inspection+hasTooManyMethods = containsExpression f+  where f (Sequence expressions) = (>15).length.filter isMethod $ expressions+        f _ = False+        +        isMethod (Method _ _) = True+        isMethod _ = False++overridesEqualOrHashButNotBoth :: Inspection+overridesEqualOrHashButNotBoth = containsExpression f+  where f (Sequence expressions) = (any isEqual expressions) /= (any isHash expressions)+        f (Class _ _ (EqualMethod _)) = True+        f (Class _ _ (HashMethod _)) = True+        f _ = False++        isEqual (EqualMethod _) = True+        isEqual _ = False+        +        isHash (HashMethod _) = True+        isHash _ = False
+ src/Language/Mulang/Inspector/Logic.hs view
@@ -0,0 +1,59 @@+module Language.Mulang.Inspector.Logic (+  usesNot,+  usesFindall,+  usesForall,+  usesUnificationOperator,+  hasRedundantReduction,+  usesCut,+  usesFail,+  declaresFact,+  declaresRule,+  declaresPredicate) where++import Language.Mulang.Ast+import Language.Mulang.Identifier+import Language.Mulang.Inspector.Generic+import Language.Mulang.Inspector.Combiner++declaresFact :: IdentifierPredicate -> Inspection+declaresFact = containsBoundDeclaration f+  where f (Fact _ _) = True+        f _          = False++declaresRule :: IdentifierPredicate -> Inspection+declaresRule = containsBoundDeclaration f+  where f (Rule _ _ _) = True+        f _            = False++usesNot :: Inspection+usesNot = containsExpression f+  where f (Not  _) = True+        f _ = False++usesFindall :: Inspection+usesFindall = containsExpression f+  where f (Findall  _ _ _) = True+        f _ = False++usesForall :: Inspection+usesForall = containsExpression f+  where f (Forall  _ _) = True+        f _ = False++usesUnificationOperator :: Inspection+usesUnificationOperator = uses (named "=")++usesCut :: Inspection+usesCut = uses (named "!")++usesFail :: Inspection+usesFail = uses (named "fail")++hasRedundantReduction :: Inspection+hasRedundantReduction = containsExpression f+  where f (Exist "is" [(VariablePattern _), (ApplicationPattern _ _)]) = False+        f (Exist "is" [(VariablePattern _), _]) = True+        f _ = False++declaresPredicate :: IdentifierPredicate -> Inspection+declaresPredicate pred = alternative (declaresFact pred) (declaresRule pred)
+ src/Language/Mulang/Inspector/ObjectOriented.hs view
@@ -0,0 +1,77 @@+module Language.Mulang.Inspector.ObjectOriented (+  implements,+  includes,+  inherits,+  instantiates,+  usesInheritance,+  usesMixins,+  declaresObject,+  declaresSuperclass,+  declaresClass,+  declaresInterface,+  declaresEnumeration,+  declaresAttribute,+  declaresMethod)  where++import Language.Mulang.Ast+import Language.Mulang.Identifier+import Language.Mulang.Inspector.Generic++implements :: IdentifierInspection+implements predicate = containsExpression f+  where f (Implement name) = predicate name+        f _                = False++includes :: IdentifierInspection+includes predicate = containsExpression f+  where f (Include name) = predicate name+        f _              = False++inherits :: IdentifierInspection+inherits predicate = containsDeclaration f+  where f (Class _ (Just name) _) = predicate name+        f _                       = False++instantiates :: IdentifierInspection+instantiates predicate = containsExpression f+  where f (New name _) = predicate name+        f _            = False++usesInheritance :: Inspection+usesInheritance = declaresSuperclass anyone++usesMixins :: Inspection+usesMixins = includes anyone++declaresObject :: IdentifierInspection+declaresObject =  containsBoundDeclaration f+  where f (Object _ _) = True+        f _            = False++declaresSuperclass :: IdentifierInspection+declaresSuperclass = inherits++declaresClass :: IdentifierInspection+declaresClass =  containsBoundDeclaration f+  where f (Class _ _ _) = True+        f _             = False++declaresEnumeration :: IdentifierInspection+declaresEnumeration =  containsBoundDeclaration f+  where f (Enumeration _ _) = True+        f _                 = False++declaresInterface :: IdentifierInspection+declaresInterface =  containsBoundDeclaration f+  where f (Interface _ _ _) = True+        f _                 = False++declaresAttribute :: IdentifierInspection+declaresAttribute =  containsBoundDeclaration f+  where f (Attribute _ _) = True+        f _               = False++declaresMethod :: IdentifierInspection+declaresMethod =  containsBoundDeclaration f+  where f (Method _ _) = True+        f _            = False
+ src/Language/Mulang/Inspector/Procedural.hs view
@@ -0,0 +1,36 @@+module Language.Mulang.Inspector.Procedural (+  usesRepeat,+  usesWhile,+  usesSwitch,+  declaresProcedure) where++import Language.Mulang.Ast+import Language.Mulang.Identifier+import Language.Mulang.Inspector.Generic++declaresProcedure :: IdentifierPredicate -> Inspection+declaresProcedure = containsBoundDeclaration f+  where f (Procedure _ _) = True+        f _                          = False+++-- | Inspection that tells whether an expression uses while+-- in its definition+usesWhile :: Inspection+usesWhile = containsExpression f+  where f (While _ _) = True+        f _ = False+-- | Inspection that tells whether an expression uses Switch+-- in its definition+usesSwitch :: Inspection+usesSwitch = containsExpression f+  where f (Switch _ _) = True+        f _ = False++-- | Inspection that tells whether an expression uses reoeat+-- in its definition+usesRepeat :: Inspection+usesRepeat = containsExpression f+  where f (Repeat _ _) = True+        f _ = False+
− src/Language/Mulang/Inspector/Smell.hs 
@@ -1,54 +0,0 @@-module Language.Mulang.Inspector.Smell (-  hasRedundantBooleanComparison,-  hasRedundantIf,-  hasRedundantGuards,-  hasRedundantLambda,-  hasRedundantParameter) where--import Language.Mulang-import Language.Mulang.Explorer-import Language.Mulang.Inspector----- | Inspection that tells whether a binding has expressions like 'x == True'-hasRedundantBooleanComparison :: Inspection-hasRedundantBooleanComparison = hasExpression f-  where f (InfixApplication x c y) = any isBooleanLiteral [x, y] && isComp c-        f _ = False--        isComp c = c == "==" || c == "/="---- | Inspection that tells whether a binding has an if expression where both branches return--- boolean literals-hasRedundantIf :: Inspection-hasRedundantIf = hasExpression f-  where f (If _ x y) = all isBooleanLiteral [x, y]-        f _            = False----- | Inspection that tells whether a binding has guards where both branches return--- boolean literals-hasRedundantGuards :: Inspection-hasRedundantGuards = hasRhs f -- TODO not true when condition is a pattern-  where f (GuardedRhss [-            GuardedRhs _ x,-            GuardedRhs (Variable "otherwise") y]) = all isBooleanLiteral [x, y]-        f _ = False----- | Inspection that tells whether a binding has lambda expressions like '\x -> g x'-hasRedundantLambda :: Inspection-hasRedundantLambda = hasExpression f-  where f (Lambda [VariablePattern (x)] (Application _ (Variable (y)))) = x == y-        f _ = False -- TODO consider parenthesis and symbols---- | Inspection that tells whether a binding has parameters that--- can be avoided using point-free-hasRedundantParameter :: Inspection-hasRedundantParameter binding = any f . declsOf binding-  where f (FunctionDeclaration _ [-             Equation params (UnguardedRhs (Application _ (Variable arg))) _ ]) | (VariablePattern param) <- last params = param == arg-        f _ = False--isBooleanLiteral (Literal (MuBool _)) = True-isBooleanLiteral _                  = False
+ src/Language/Mulang/Parsers.hs view
@@ -0,0 +1,13 @@+module Language.Mulang.Parsers+  (Parser, EitherParser, MaybeParser, maybeToEither) where++import           Language.Mulang.Ast+import qualified Text.SimpleParser as S (SimpleParser, EitherParser, MaybeParser)++type Parser = S.SimpleParser Expression+type EitherParser = S.EitherParser Expression+type MaybeParser = S.MaybeParser Expression++maybeToEither :: MaybeParser -> EitherParser+maybeToEither parser input | (Just result) <- parser input = Right result+                           | otherwise = Left "Sample code parsing error"
src/Language/Mulang/Parsers/Haskell.hs view
@@ -1,84 +1,111 @@-module Language.Mulang.Parsers.Haskell (parseHaskell) where+module Language.Mulang.Parsers.Haskell (hs, parseHaskell) where -import Language.Mulang+import Language.Mulang.Ast+import Language.Mulang.Builder+import Language.Mulang.Parsers+ import Language.Haskell.Syntax import Language.Haskell.Parser -import Data.String (IsString(..))-import Data.Maybe (fromJust) import Data.List (intercalate) -instance IsString Program where-  fromString = fromJust.parseHaskell+import Control.Fallible -parseHaskell :: String -> Maybe Program-parseHaskell code | ParseOk ast <- parseModule code = Just (mu ast)-                  | otherwise = Nothing+instance Fallible ParseResult where+  failure (ParseOk v)       = Left v+  failure (ParseFailed _ m) = Right m -mu :: HsModule -> Program-mu (HsModule _ _ _ _ decls) = (Program (concatMap muDecls decls))+hs :: Parser+hs = orFail . parseHaskell'++parseHaskell :: EitherParser+parseHaskell = orLeft . parseHaskell'++parseHaskell' :: String -> ParseResult Expression+parseHaskell' = fmap (normalize . mu) . parseModule . (++"\n")++mu :: HsModule -> Expression+mu (HsModule _ _ _ _ decls) = compact (concatMap muDecls decls)   where+    mergeDecls decls exp = compact (decls ++ [exp])+     muDecls (HsTypeDecl _ name _ _)      = [TypeAlias (muName name)]-    muDecls (HsDataDecl _ _ name _ _ _ ) = [RecordDeclaration (muName name)]-    muDecls (HsTypeSig _ names _) = map (\name -> TypeSignature (muName name)) names+    muDecls (HsDataDecl _ _ name _ _ _ ) = [Record (muName name)]+    muDecls (HsTypeSig _ names (HsQualType _ t)) = map (muTypeSignature t) names     muDecls (HsFunBind equations) | (HsMatch _ name _ _ _) <- head equations =-                                        [FunctionDeclaration (muName name) (map muEquation equations)]-    muDecls (HsPatBind _ (HsPVar name) rhs decls) = [ConstantDeclaration (muName name) (muRhs rhs) (concatMap muDecls decls)]+                                        [Function (muName name) (map muEquation equations)]+    muDecls (HsPatBind _ (HsPVar name) (HsUnGuardedRhs exp) _) = [Variable (muName name) (muExp exp)]     muDecls _ = []      muEquation :: HsMatch -> Equation-    muEquation (HsMatch _ _ patterns rhs locals) =-         Equation (map muPat patterns) (muRhs rhs) (concatMap muDecls locals)+    muEquation (HsMatch _ _ patterns rhs decls) =+         Equation (map muPat patterns) (muRhs (concatMap muDecls decls) rhs) -    muRhs (HsUnGuardedRhs exp)          = UnguardedRhs (muExp exp)-    muRhs (HsGuardedRhss  guards) = GuardedRhss (map muGuardedRhs guards)+    muRhs decls (HsUnGuardedRhs body)        = UnguardedBody (mergeDecls decls (muBody body))+    muRhs decls (HsGuardedRhss  guards)      = GuardedBody (map (muGuardedRhs decls) guards ) -    muGuardedRhs (HsGuardedRhs _ condition body) = (GuardedRhs (muExp condition) (muExp body))+    muGuardedRhs decls (HsGuardedRhs _ condition body) = (mergeDecls decls (muExp condition), muBody body) -    muPat (HsPVar name) = VariablePattern (muName name)                 -- ^ variable-    muPat (HsPLit _) = LiteralPattern ""              -- ^ literal constant-    --Pattern HsPInfixApp = InfixApplicationPattern Pattern MuQName Pattern-    --Pattern HsPApp = ApplicationPattern MuQName [Pattern]        -- ^ data constructor and argument+    muBody = Return . muExp++    muPat (HsPVar name) = VariablePattern (muName name)+    muPat (HsPLit _) = LiteralPattern ""+    muPat (HsPInfixApp e1 name e2) = InfixApplicationPattern (muPat e1) (muQName name) (muPat e2)+    muPat (HsPApp name elements) = ApplicationPattern (muQName name) (map muPat elements)     muPat (HsPTuple elements) = TuplePattern (map muPat elements)     muPat (HsPList elements) = ListPattern (map muPat elements)     muPat (HsPParen pattern) = muPat pattern-    --Pattern HsPAsPat = AsPattern String Pattern+    muPat (HsPAsPat name pattern) = AsPattern (muName name) (muPat pattern)     muPat HsPWildCard = WildcardPattern     muPat _ = OtherPattern -    muExp (HsVar name) = Variable (muQName name)-    muExp (HsCon (UnQual (HsIdent "True")))  = Literal (MuBool True)-    muExp (HsCon (UnQual (HsIdent "False"))) = Literal (MuBool False)-    muExp (HsCon name)                       = Variable (muQName name)-    muExp (HsLit lit) = Literal (muLit lit)-    muExp (HsInfixApp e1 op e2) = InfixApplication (muExp e1) (muQOp op) (muExp e2)  -- ^ infix application-    muExp (HsApp e1 e2) = Application (muExp e1) (muExp e2)             -- ^ ordinary application-    muExp (HsNegApp e) = Application (Variable "-") (muExp e)-    muExp (HsLambda _ args exp) = Lambda (map muPat args) (muExp exp)+    muExp (HsVar (UnQual (HsIdent "undefined"))) = Raise (MuString "undefined")++    muExp (HsVar name) = muVar (muQName name)+    muExp (HsCon (UnQual (HsIdent "True")))  = MuTrue+    muExp (HsCon (UnQual (HsIdent "False"))) = MuFalse+    muExp (HsCon name)                       = Reference (muQName name)+    muExp (HsLit lit) = muLit lit++    muExp (HsInfixApp e1 op e2)                                  = Application ((muVar.muQOp) op) [muExp e1, muExp e2]+    muExp (HsApp (HsVar (UnQual (HsIdent "error"))) e1)          = Raise (muExp e1)+    muExp (HsApp (HsApp (HsApp (HsApp e1 e2) e3) e4) e5)         = Application (muExp e1) [muExp e2, muExp e3, muExp e4, muExp e5]+    muExp (HsApp (HsApp (HsApp e1 e2) e3) e4)                    = Application (muExp e1) [muExp e2, muExp e3, muExp e4]+    muExp (HsApp (HsApp e1 e2) e3)                               = Application (muExp e1) [muExp e2, muExp e3]+    muExp (HsApp e1 e2)                                          = Application (muExp e1) [muExp e2]+    muExp (HsLeftSection e1 e2)                                  = Application (muVar $ muQOp e2) [muExp e1]+    muExp (HsRightSection e1 e2)                                 = Application (muVar $ muQOp e1) [muExp e2]+    muExp (HsNegApp e) = Application (Reference "-") [muExp e]+    muExp (HsLambda _ args body) = Lambda (map muPat args) (muBody body)     --muExp HsLet = Let [Declaration] Expression          -- ^ local declarations with @let@     muExp (HsIf e1 e2 e3) = If (muExp e1) (muExp e2) (muExp e3)     --muExp HsMatch = Match Expression [Alternative]          -- ^ @case@ /exp/ @of@ /alts/     muExp (HsTuple elements) = MuTuple (map muExp elements)               -- ^ tuple Expression     muExp (HsList elements) = MuList (map muExp elements)     muExp (HsParen e) = (muExp e)-    muExp (HsEnumFrom from)              = Application (Variable "enumFrom") (muExp from)-    muExp (HsEnumFromTo from to)         = Application (Application (Variable "enumFromTo") (muExp from)) (muExp to)-    muExp (HsEnumFromThen from thn)      = Application (Application (Variable "enumFromThen") (muExp from)) (muExp thn)-    muExp (HsEnumFromThenTo from thn to) = Application (Application (Application (Variable "enumFromThenTo") (muExp from)) (muExp thn)) (muExp to)+    muExp (HsEnumFrom from)              = Application (Reference "enumFrom") [(muExp from)]+    muExp (HsEnumFromTo from to)         = Application (Reference "enumFromTo") [(muExp from), (muExp to)]+    muExp (HsEnumFromThen from thn)      = Application (Reference "enumFromThen") [(muExp from), (muExp thn)]+    muExp (HsEnumFromThenTo from thn to) = Application (Reference "enumFromThenTo") [(muExp from), (muExp thn), (muExp to)]     muExp (HsListComp exp stmts)         = Comprehension (muExp exp) (map muStmt stmts)     muExp (HsDo stmts) | (HsQualifier exp) <- last stmts  = Comprehension (muExp exp) (map muStmt stmts)-    muExp _ = ExpressionOther+    muExp _ = Other -    muLit (HsChar        v) = MuString [v]-    muLit (HsString      v) = MuString v-    muLit (HsInt         v) = MuInteger v-    muLit (HsFrac        v) = MuFloat v     muLit (HsCharPrim    v) = MuString [v]     muLit (HsStringPrim  v) = MuString v-    muLit (HsIntPrim     v) = MuInteger v-    muLit (HsFloatPrim   v) = MuFloat v-    muLit (HsDoublePrim  v) = MuFloat v+    muLit (HsChar        v) = MuString [v]+    muLit (HsString      v) = MuString v+    muLit (HsIntPrim     v) = MuNumber . fromIntegral $ v+    muLit (HsInt         v) = MuNumber . fromIntegral $ v+    muLit (HsFrac        v) = MuNumber . fromRational $ v+    muLit (HsFloatPrim   v) = MuNumber . fromRational $ v+    muLit (HsDoublePrim  v) = MuNumber . fromRational $ v +    muVar :: String -> Expression+    muVar "==" = Equal+    muVar "/=" = NotEqual+    muVar v = Reference v+     muName :: HsName -> String     muName (HsSymbol n) = n     muName (HsIdent  n) = n@@ -96,3 +123,17 @@      muStmt (HsGenerator _ pat exp) = MuGenerator (muPat pat) (muExp exp)     muStmt (HsQualifier exp) = MuQualifier (muExp exp)++    muTypeSignature t name = TypeSignature (muName name) (init topTypes) (last topTypes)+      where topTypes = muTopTypes t++    muTopTypes (HsTyFun i o) = muType i : muTopTypes o+    muTopTypes t             = [muType t]++    muType (HsTyFun i o)                              = muType i ++ " -> " ++ muType o+    muType (HsTyCon name)                             = muQName name+    muType (HsTyVar name)                             = muName name+    muType (HsTyTuple ts)                             = "(" ++ (intercalate ", " . map muType $ ts) ++ ")"+    muType (HsTyApp (HsTyCon (Special HsListCon)) t2) = "[" ++ muType t2 ++ "]"+    muType (HsTyApp t1 t2)                            = muType t1 ++ " " ++ muType t2+
+ src/Language/Mulang/Parsers/Java.hs view
@@ -0,0 +1,184 @@+{-# LANGUAGE ViewPatterns #-}+++module Language.Mulang.Parsers.Java (java, parseJava) where++import Language.Mulang.Ast hiding (While, Return, Equal, Lambda, Try)+import qualified Language.Mulang.Ast as M (Expression(While, Return, Equal, Lambda, Try))+import Language.Mulang.Parsers+import Language.Mulang.Builder (compact, compactMap, compactConcatMap)++import Language.Java.Parser+import Language.Java.Syntax++import Control.Fallible++import Data.Maybe (fromMaybe)+import Data.List (intercalate)+import Data.Char (toLower)++java :: Parser+java = orFail . parseJava'++parseJava :: EitherParser+parseJava = orLeft . parseJava'++parseJava' = fmap m . j++m (CompilationUnit _ _ typeDecls) = compactMap muTypeDecl $ typeDecls++muTypeDecl (ClassTypeDecl decl)    = muClassTypeDecl decl+muTypeDecl (InterfaceTypeDecl decl) = muInterfaceTypeDecl decl++muClassTypeDecl (ClassDecl _ name _ superclass interfaces (ClassBody body)) =+  Class (i name) (fmap muRefType superclass) (compact (map muImplements interfaces ++ concatMap muDecl body))+muClassTypeDecl (EnumDecl _ name _ (EnumBody constants _))                   =+  Enumeration (i name) (map muEnumConstant constants)++muImplements interface = Implement $ muRefType interface++muInterfaceTypeDecl (InterfaceDecl _ name _ interfaces (InterfaceBody body)) =+  Interface (i name) (map muRefType interfaces) (compactConcatMap muMemberDecl body )++muDecl :: Decl -> [Expression]+muDecl (MemberDecl memberDecl) = muMemberDecl memberDecl+muDecl (InitDecl _ _)          = return Other++muMemberDecl :: MemberDecl -> [Expression]+muMemberDecl (FieldDecl _ _type varDecls)                            = map (variableToAttribute.muVarDecl) varDecls+muMemberDecl (MethodDecl _ _ typ name params _ (MethodBody Nothing)) = return $ TypeSignature (i name) (map muFormalParamType params) (muMaybeType typ)+muMemberDecl (MethodDecl (elem Static -> True) _ Nothing (Ident "main") [_] _ body)+                                                                     = return $ EntryPoint "main" (muMethodBody body)+muMemberDecl (MethodDecl _ _ _ (Ident "equals") params _ body)       = return $ EqualMethod [SimpleEquation (map muFormalParam params) (muMethodBody body)]+muMemberDecl (MethodDecl _ _ _ (Ident "hashCode") params _ body)     = return $ HashMethod [SimpleEquation (map muFormalParam params) (muMethodBody body)]+muMemberDecl (MethodDecl _ _ _ name params _ body)                   = return $ SimpleMethod (i name) (map muFormalParam params) (muMethodBody body)+muMemberDecl (ConstructorDecl _ _ _ _params _ _constructorBody)      = return $ Other+muMemberDecl (MemberClassDecl decl)                                  = return $ muClassTypeDecl decl+muMemberDecl (MemberInterfaceDecl decl)                              = return $ muInterfaceTypeDecl decl++muEnumConstant (EnumConstant name _ _) = i name++muFormalParam (FormalParam _ _ _ id)      = VariablePattern (v id)+muFormalParamType (FormalParam _ typ _ _) = (muType typ)++muBlock (Block statements) = compactConcatMap muBlockStmt statements++muBlockStmt (BlockStmt stmt) = [muStmt stmt]+muBlockStmt (LocalClass decl) = [muClassTypeDecl decl]+muBlockStmt (LocalVars _ _type vars) = map muVarDecl vars++muMaybeType Nothing    = "void"+muMaybeType (Just typ) = muType typ++muType (PrimType t) = muPrimType t+muType (RefType t)  = muRefType t++muStmt (StmtBlock block)               = muBlock block+muStmt (IfThen exp ifTrue)             = If (muExp exp) (muStmt ifTrue) MuNull+muStmt (IfThenElse exp ifTrue ifFalse) = If (muExp exp) (muStmt ifTrue) (muStmt ifFalse)+muStmt (While cond body)               = M.While (muExp cond) (muStmt body)+muStmt (Return exp)                    = M.Return $ fmapOrNull muExp exp+muStmt (ExpStmt exp)                   = muExp exp+muStmt Empty                           = MuNull+muStmt (Assert exp _)                  = SimpleSend Self "assert" [muExp exp]+muStmt (Synchronized _ block)          = muBlock block+muStmt (Labeled _ stmt)                = muStmt stmt+muStmt (Throw exp)                     = Raise $ muExp exp+muStmt (Try block catches finally)     = M.Try (muBlock block) (map muCatch catches) (fmapOrNull muBlock finally)+--muStmt (EnhancedFor _ _ name gen body) = Other+--Switch Exp [SwitchBlock]+muStmt _                               = Other++muExp (Lit lit)                         = muLit lit+muExp (MethodInv invoke)                = muMethodInvocation invoke+muExp This                              = Self+muExp (BinOp arg1 op arg2)              = Send (muExp arg1) (muOp op) [muExp arg2]+muExp (Cond cond ifTrue ifFalse)        = If (muExp cond) (muExp ifTrue) (muExp ifFalse)+muExp (ExpName name)                    = muName name+muExp (Assign lhs EqualA exp)           = Assignment (muLhs lhs) (muExp exp)+muExp (InstanceCreation _ clazz args _) = New (r clazz) (map muExp args)+muExp (PreNot exp)                      = SimpleSend (muExp exp) "!" []+muExp (Lambda params exp)               = M.Lambda (muLambdaParams params) (muLambdaExp exp)+muExp (MethodRef _ message)             = M.Lambda [VariablePattern "it"] (SimpleSend (Reference "it") (i message) [])+muExp _                                 = Other++muLambdaExp (LambdaExpression exp) = muExp exp+muLambdaExp (LambdaBlock block) = muBlock block++muLambdaParams (LambdaSingleParam name)     = [VariablePattern (i name)]+muLambdaParams (LambdaInferredParams names) = map (VariablePattern . i) names+muLambdaParams (LambdaFormalParams params)  = map muFormalParam params++muCatch :: Catch -> (Pattern, Expression)+muCatch (Catch param block) = (TypePattern (muFormalParamType param), muBlock block)++muLhs (NameLhs (Name names)) = ns names++muName (Name names) = Reference . ns $ names++muLit (String s)  = MuString s+muLit (Char c)    = MuString [c]+muLit (Int i)     = MuNumber (fromIntegral i)+muLit (Float d)   = MuNumber d+muLit (Double d)  = MuNumber d+muLit (Boolean b) = MuBool   b+muLit Null        = MuNull+muLit _           = Other++muOp Mult   = Reference "*"+muOp Div    = Reference "/"+muOp Rem    = Reference "rem"+muOp Add    = Reference "+"+muOp Sub    = Reference "-"+muOp LThan  = Reference "<"+muOp LThanE = Reference "<="+muOp GThan  = Reference ">"+muOp GThanE = Reference ">="+muOp And    = Reference "&&"+muOp Or     = Reference "||"+muOp Equal  = M.Equal+muOp NotEq  = NotEqual+muOp _      = Other++muVarDecl (VarDecl id init) = Variable (v id) (fmapOrNull muVarInit init)++muMethodBody (MethodBody (Just block)) = muBlock block++muVarInit (InitExp exp) = muExp exp+muVarInit (InitArray _ArrayInit) = Other++muMethodInvocation (MethodCall (Name [Ident "System", Ident "out", Ident "println"]) [expr])  = Print (muExp expr)+muMethodInvocation (MethodCall (Name [Ident "System", Ident "out", Ident "print"]) [expr])    = Print (muExp expr)+muMethodInvocation (MethodCall (Name [Ident "System", Ident "out", Ident "printf"]) (expr:_)) = Print (muExp expr)++muMethodInvocation (MethodCall (Name [message]) args)           =  SimpleSend Self (i message) (map muExp args)+muMethodInvocation (MethodCall (Name receptorAndMessage) args)  =  SimpleSend (Reference  (ns . init $ receptorAndMessage)) (i . last $ receptorAndMessage) (map muExp args)+muMethodInvocation (PrimaryMethodCall receptor _ selector args) =  SimpleSend (muExp receptor) (i selector) (map muExp args)+muMethodInvocation _ = Other++muRefType (ClassRefType clazz) = r clazz+muRefType (ArrayType t)        = (muType t) ++ "[]"++muPrimType = map toLower . dropLast 1 . show++-- Combinators++fmapOrNull f = fromMaybe MuNull . fmap f++-- Helpers++variableToAttribute (Variable id init) = Attribute id init++v (VarId name) = i name+v (VarDeclArray id) =  (v id) ++ "[]"++i (Ident name) = name+r (ClassType [(name, _)]) = i name++j = parser compilationUnit++ns = intercalate "." . map i++-- list helpers++dropLast n xs = take (length xs - n) xs
+ src/Language/Mulang/Parsers/JavaScript.hs view
@@ -0,0 +1,164 @@+module Language.Mulang.Parsers.JavaScript (js, parseJavaScript) where++import Language.Mulang.Ast+import Language.Mulang.Builder+import Language.Mulang.Parsers++import Language.JavaScript.Parser.Parser (parse)+import Language.JavaScript.Parser.AST++import Data.Either ()++import Control.Fallible++js :: Parser+js = orFail . parseJavaScript'++parseJavaScript :: MaybeParser+parseJavaScript = orNothing . parseJavaScript'++parseJavaScript' :: String -> Either String Expression+parseJavaScript' = fmap (normalize . mu) . (`parse` "src")++mu :: JSNode -> Expression+mu = compact . muNode . gc+  where+    muNode (JSSourceElementsTop statements)                  = [compactMapMu statements]+    muNode (JSIdentifier "undefined")                        = [MuNull]+    muNode (JSIdentifier n)                                  = [Reference n]+    muNode (JSDecimal val)                                   = [MuNumber (read val)]+    muNode (JSExpression xs)                                 = [compactMapMu xs]+    muNode (JSLiteral "null")                                = [MuNull]+    muNode (JSLiteral "true")                                = [MuTrue]+    muNode (JSLiteral "false")                               = [MuFalse]+    muNode (JSLiteral _)                                     = []+    muNode (JSElision _)                                     = []+    muNode (JSHexInteger v)                                  = muNode (JSStringLiteral '\'' v)+    muNode (JSOctal v)                                       = muNode (JSStringLiteral '"' v)+    muNode (JSExpressionPostfix "++" [var] _)                = [muVarAssignment var (muPlus var (MuNumber 1))]+    muNode (JSExpressionPostfix "--" [var] _)                = [muVarAssignment var (muMinus var (MuNumber 1))]+    muNode (JSStringLiteral _ v)                             = [MuString v]+    muNode (JSVariables _ decls _)                           = mapMu decls+    muNode (JSArrayLiteral _ es _)                           = [MuList (mapMu es)]+    muNode (JSVarDecl var initial)                           = [muVarDeclaration var initial]+    muNode (JSWith _ _ _ _ _)                                = [Other]+    muNode (JSExpressionTernary cond _ true _ false)         = [muIf cond   true false]+    muNode (JSIf _ _ cond _ true false)                      = [muIf [cond] true false]+    muNode (JSWhile _ _ cond _ action)                       = [muWhile cond action]+    muNode (JSBlock _ exps _)                                = [compactMapMu exps]+    muNode (JSFunctionExpression _ [] _ params _ body)       = [Lambda (muParams params) (mu body)]+    muNode (JSFunctionExpression _ [name] _ params _ body)   = [muFunction  name params body]+    muNode (JSReturn _ e _)                                  = [Return (compactMapMu e)]+    muNode (JSExpressionParen _ e _)                         = [mu e]+    muNode (JSObjectLiteral _ es _)                          = [MuObject (compactMapMu es)]+    muNode (JSLabelled _ _ e)                                = [mu e]+    muNode (JSPropertyNameandValue var _ initial)            = [muVarDeclaration var initial]+    muNode (JSFunction _ name _ params _ body)               = [muFunction name params body]+    muNode (JSExpressionBinary op l _ r)                     = [Application (muOp op) [compactMapMu l, compactMapMu r]]+    muNode (JSMemberDot receptor _ selector)                 = [Send (compactMapMu receptor) (mu selector) []]+    muNode (JSThrow _ e)                                     = [Raise (mu e)]+    muNode e                                                 = [Other]++++    mapMu :: [JSNode] -> [Expression]+    mapMu [] = []+    mapMu (x:y:xs)   | (JSArguments _ args _) <- gc y =  [Application (mu x) (mapMu args)] ++ mapMu xs+    mapMu (x:y:z:xs) | (JSOperator (NT (JSLiteral "=") _ _))  <- gc y =  [muVarAssignment x (mu z)] ++ mapMu xs+                     | (JSOperator (NT (JSLiteral "+=") _ _))  <- gc y =  [muVarAssignment x (muPlus x (mu z))] ++ mapMu xs+    mapMu (x:xs) = (muNode.gc) x ++ mapMu xs++    muParams :: [JSNode] -> [Pattern]+    muParams params = concatMap (muPattern.gc) params++    muOp :: String -> Expression+    muOp "=="  = Equal+    muOp "===" = Equal+    muOp "!="  = NotEqual+    muOp "!==" = NotEqual+    muOp v    = Reference v++    muPattern (JSLiteral _)    = []+    muPattern (JSIdentifier i) = [VariablePattern i]+    muPattern e                = error (show e)++    gc (NN n) = n+    gc (NT n _ _) = n++    muId = f.gc+           where f (JSIdentifier id) = id+++    muEquation params body = [SimpleEquation params body]++    compactMapMu :: [JSNode] -> Expression+    compactMapMu  = compact . mapMu++    muIf :: [JSNode] -> [JSNode] -> [JSNode] -> Expression+    muIf cond true false = If (compactMapMu cond) (compactMapMu true) (compactMapMu false)++    muWhile cond action  = While (mu cond) (mu action)++    muVarDeclaration var initial = Variable (muId var) (compactMapMu initial)+    muVarAssignment  var value  = Assignment (muId var)  value++    muPlus var delta = (Application (Reference "+") [Reference (muId var), delta])+    muMinus var delta = (Application (Reference "-") [Reference (muId var), delta])++    muFunction :: JSNode -> [JSNode] -> JSNode -> Expression+    muFunction name params body = muComputation (muId name) (muParams params) (mu body)+                            where+                                muComputation name params body = (computationFor body) name (muEquation params body)++                                computationFor :: Expression -> Identifier -> [Equation] -> Expression+                                computationFor body | containsReturn body = Function+                                                    | otherwise = Procedure++                                containsReturn :: Expression -> Bool+                                containsReturn (Return _)    = True+                                containsReturn (Sequence xs) = any containsReturn xs+                                containsReturn _             = False++{-JSRegEx String+optional lb,optional block statements,optional rb+JSBreak JSNode [JSNode] JSNode+break, optional identifier, autosemi+JSCallExpression String [JSNode] [JSNode] [JSNode]+type : ., (), []; opening [ or ., contents, closing+JSCase JSNode JSNode JSNode [JSNode]+case,expr,colon,stmtlist+JSCatch JSNode JSNode JSNode [JSNode] JSNode JSNode+catch,lb,ident,[if,expr],rb,block+JSContinue JSNode [JSNode] JSNode+continue,optional identifier,autosemi+JSDefault JSNode JSNode [JSNode]+default,colon,stmtlist+JSDoWhile JSNode JSNode JSNode JSNode JSNode JSNode JSNode+do,stmt,while,lb,expr,rb,autosemi+JSExpressionPostfix String [JSNode] JSNode+type, expression, operator+JSExpressionTernary [JSNode] JSNode [JSNode] JSNode [JSNode]+cond, ?, trueval, :, falseval+JSFinally JSNode JSNode+finally,block+JSFor JSNode JSNode [JSNode] JSNode [JSNode] JSNode [JSNode] JSNode JSNode+for,lb,expr,semi,expr,semi,expr,rb.stmt+JSForIn JSNode JSNode [JSNode] JSNode JSNode JSNode JSNode+for,lb,expr,in,expr,rb,stmt+JSForVar JSNode JSNode JSNode [JSNode] JSNode [JSNode] JSNode [JSNode] JSNode JSNode+for,lb,var,vardecl,semi,expr,semi,expr,rb,stmt+JSForVarIn JSNode JSNode JSNode JSNode JSNode JSNode JSNode JSNode+for,lb,var,vardecl,in,expr,rb,stmt+JSMemberSquare [JSNode] JSNode JSNode JSNode+firstpart, lb, expr, rb+JSPropertyAccessor JSNode JSNode JSNode [JSNode] JSNode JSNode+(get|set), name, lb, params, rb, block+JSSwitch JSNode JSNode JSNode JSNode JSNode+switch,lb,expr,rb,caseblock+JSThrow JSNode JSNode+throw val+JSTry JSNode JSNode [JSNode]+try,block,rest+JSUnary String JSNode+type, operator+ -}
− src/Language/Mulang/Parsers/Json.hs 
@@ -1,46 +0,0 @@-module Language.Mulang.Parsers.Json (parseJson) where--import Language.Mulang--import Data.Aeson--import qualified Data.ByteString.Lazy.Char8 as LBS (pack)--parseJson :: String -> Maybe Program-parseJson  = decode . LBS.pack--instance FromJSON Program-instance ToJSON Program--instance FromJSON Declaration-instance ToJSON Declaration--instance FromJSON Equation-instance ToJSON Equation--instance FromJSON Rhs-instance ToJSON Rhs--instance FromJSON GuardedRhs-instance ToJSON GuardedRhs--instance FromJSON Expression-instance ToJSON Expression--instance FromJSON Pattern-instance ToJSON Pattern--instance FromJSON ComprehensionStatement-instance ToJSON ComprehensionStatement--instance FromJSON Alternative-instance ToJSON Alternative--instance FromJSON GuardedAlternatives-instance ToJSON GuardedAlternatives--instance FromJSON GuardedAlternative-instance ToJSON GuardedAlternative--instance FromJSON LiteralValue-instance ToJSON LiteralValue
+ src/Language/Mulang/Parsers/Prolog.hs view
@@ -0,0 +1,161 @@+{-# LANGUAGE RankNTypes #-}++module Language.Mulang.Parsers.Prolog  (pl, parseProlog) where++import Text.Parsec+import Text.Parsec.Expr+import Text.Parsec.Numbers++import Language.Mulang.Ast+import Language.Mulang.Builder+import Language.Mulang.Parsers++import Data.Maybe (fromMaybe)+import Data.Char (isUpper)++import Control.Fallible++type ParsecParser a = forall x . Parsec String x a++pl :: Parser+pl = orFail . parseProlog'++parseProlog :: EitherParser+parseProlog = orLeft . parseProlog'++parseProlog' = fmap compact . parse program ""++program :: ParsecParser [Expression]+program = many predicate++pattern :: ParsecParser Pattern+pattern = buildExpressionParser optable (term <* spaces)+  where+    optable = [ [ Infix (op "^") AssocLeft ],+                [ Infix (op "*") AssocLeft ],+                [ Infix (op "/") AssocLeft ],+                [ Infix (op "+") AssocLeft ],+                [ Infix (op "-") AssocLeft ] ]+    term    = try number <|> wildcard <|> tuple <|> (fmap otherToPattern phead)++    otherToPattern (name, []) | isUpper . head $ name = VariablePattern name+                              | otherwise = LiteralPattern name+    otherToPattern ("abs", [p])           = ApplicationPattern "abs" [p]+    otherToPattern ("mod", [p1, p2])      = ApplicationPattern "mod" [p1, p2]+    otherToPattern ("div", [p1, p2])      = ApplicationPattern "div" [p1, p2]+    otherToPattern ("rem", [p1, p2])      = ApplicationPattern "rem" [p1, p2]+    otherToPattern (name, args)           = FunctorPattern name args++op :: String -> ParsecParser (Pattern -> Pattern -> Pattern)+op symbol = string symbol <* spaces >> return (\x y -> ApplicationPattern symbol [x, y])++tuple :: ParsecParser Pattern+tuple = fmap compact patternsList+  where compact [p] = p+        compact ps  = TuplePattern ps++wildcard :: ParsecParser Pattern+wildcard = string "_" >> return WildcardPattern++number :: ParsecParser Pattern+number = fmap (LiteralPattern . show) parseFloat++fact :: ParsecParser Expression+fact = do+  (name, args) <- phead+  end+  return $ Fact name args++rule :: ParsecParser Expression+rule = do+  (name, args) <- phead+  def+  consults <- body+  end+  return $ Rule name args consults++phead :: ParsecParser (Identifier, [Pattern])+phead = do+  name <- identifier+  args <- optionMaybe patternsList+  spaces+  return (name, fromMaybe [] args)++forall :: ParsecParser Expression+forall = do+  string "forall"+  startTuple+  c1 <- consult+  separator+  c2 <- consult+  endTuple+  return $ Forall c1 c2++findall :: ParsecParser Expression+findall = do+  string "findall"+  startTuple+  c1 <- consult+  separator+  c2 <- consult+  separator+  c3 <- consult+  endTuple+  return $ Findall c1 c2 c3++cut :: ParsecParser Expression+cut = do+  bang+  return $ Exist "!" []++pnot :: ParsecParser Expression+pnot = do+  c <- operator <|> functor+  return $ Not c+  where+    functor = string "not" >> startTuple >> consult <* endTuple+    operator = negation >> consult++exist :: ParsecParser Expression+exist = fmap (\(name, args) -> Exist name args) phead++body :: ParsecParser [Expression]+body =  sepBy1 consult separator++inlineBody :: ParsecParser Expression+inlineBody = do+  startTuple+  queries <- body+  endTuple+  return $ Sequence queries++pinfix :: ParsecParser Expression+pinfix = do+  p1 <- pattern+  spaces+  operator <- choice . map try . map string $ ["is", "|", ">=", "=<", "\\=", ">", "<", "=:=", "==", "=\\=", ":=", "=..", "=@=", "\\\\=@=", "="]+  spaces+  p2 <- pattern+  return $ Exist operator [p1, p2]+++consult :: ParsecParser Expression+consult = choice [try findall, try forall, try pnot, try pinfix, inlineBody, cut, exist]++predicate :: ParsecParser Expression+predicate = try fact <|> rule++patternsList :: ParsecParser [Pattern]+patternsList = startTuple >> sepBy1 pattern separator <* endTuple++bang = string "!" >> spaces+negation = string "\\+" >> spaces+identifier = many1 letter+def = string ":-" >> spaces+startTuple = lparen >> spaces+endTuple = rparen >> spaces+separator = (char ',' <|> char ';') >> spaces+end = char '.' >> spaces++lparen = char '('+rparen = char ')'
+ src/Language/Mulang/Signature.hs view
@@ -0,0 +1,116 @@+module Language.Mulang.Signature (+  arity,+  name,+  nameAndArity,+  parameterNames,+  signatureOf,+  signaturesOf,+  codeSignaturesOf,+  styledCodeSignaturesOf,+  mulangStyle,+  haskellStyle,+  prologStyle,+  untypedCStyle,+  Signature(..),+  SignatureStyle) where++import Language.Mulang.Identifier+import Language.Mulang.Ast+import Language.Mulang.Generator (declarations)++import Data.List (transpose, intercalate, nub, groupBy)+import Data.Maybe (fromMaybe, mapMaybe)+import Control.Monad (msum)+import Data.Function (on)++type SignatureStyle = [Signature] -> [String]++data Signature = AritySignature Identifier Int+               | TypedSignature Identifier [Identifier] Identifier+               | NamedSignature Identifier [Maybe Identifier] deriving (Show, Eq)+++arity :: Signature -> Int+arity (AritySignature _ a)    = a+arity (TypedSignature _ ps _) = length ps+arity (NamedSignature _ ps)   = length ps++name :: Signature -> Identifier+name (AritySignature n _)   = n+name (TypedSignature n _ _) = n+name (NamedSignature n _)   = n++nameAndArity :: Signature -> (Identifier, Int)+nameAndArity signature = (name signature, arity signature)++parameterNames :: Signature -> [Maybe Identifier]+parameterNames (AritySignature _ arity)   = replicate arity Nothing+parameterNames (TypedSignature _ types _) = map (const Nothing) types+parameterNames (NamedSignature _ names)   = names++signaturesOf :: Expression -> [Signature]+signaturesOf = nub . mapMaybe (signatureOf.snd) . declarations++signatureOf :: Expression -> Maybe Signature+signatureOf (Subroutine name es)          = Just $ NamedSignature name (parameterNamesOf es)+signatureOf (Clause name args _)          = Just $ AritySignature name (length args)+signatureOf (TypeSignature name args ret) = Just $ TypedSignature name args ret+signatureOf (Variable name _)             = Just $ AritySignature name 0+signatureOf _                             = Nothing++parameterNamesOf :: [Equation] -> [Maybe Identifier]+parameterNamesOf = map msum . transpose . map (map parameterNameOf . equationParams)++parameterNameOf :: Pattern -> Maybe Identifier+parameterNameOf (VariablePattern v) = Just v+parameterNameOf _                   = Nothing++codeSignaturesOf :: Expression -> [Code]+codeSignaturesOf = styledCodeSignaturesOf mulangStyle++styledCodeSignaturesOf :: SignatureStyle -> Expression -> [Code]+styledCodeSignaturesOf style = style . signaturesOf++-- Styles++mulangStyle :: SignatureStyle+mulangStyle = makeLines "--" (return.s)+  where s :: Signature -> String+        s (AritySignature name arity)     = name ++ "/" ++ show arity+        s (NamedSignature name names)     = name ++ "(" ++ (intercalate ", " . makeParamNames $ names) ++ ")"+        s (TypedSignature name types ret) = name ++ "(" ++ (intercalate ", " types) ++ "): " ++ ret++untypedCStyle :: SignatureStyle+untypedCStyle = makeLines "//" s+  where s (AritySignature name 0)     = Just name+        s (NamedSignature name names) = Just $ name ++ "(" ++ (intercalate ", " . makeParamNames $ names) ++ ")"+        s _                           = Nothing++haskellStyle :: SignatureStyle+haskellStyle = groupAndMakeLinesOn "--" name s+  where s (NamedSignature name names)     = Just $ name ++ " " ++ (intercalate " " . makeParamNames $ names)+        s (TypedSignature name types ret) = Just $ name ++ " :: " ++ (intercalate " -> " (types ++ [ret]))+        s (AritySignature name 0)         = Just name+        s _                               = Nothing++prologStyle :: SignatureStyle+prologStyle = groupAndMakeLinesOn "%%" nameAndArity s+  where s (AritySignature name arity) = Just $ name ++ "/" ++ show arity+        s _                           = Nothing++--Style helper functions++makeParamNames :: [Maybe String] -> [String]+makeParamNames = map (fromMaybe "?")++makeLines :: String -> (Signature -> Maybe String) -> [Signature] -> [String]+makeLines comment f = prefixCodeSignaturesWithComment comment . mapMaybe f++groupAndMakeLinesOn :: Eq a => String -> (Signature -> a) -> (Signature -> Maybe String) -> [Signature] -> [String]+groupAndMakeLinesOn comment groupFunction s = map (intercalate "\n" . makeLines comment s) . groupSignaturesOn groupFunction++prefixCodeSignaturesWithComment :: String -> [String] -> [String]+prefixCodeSignaturesWithComment comment = map (\s -> comment ++ " " ++ s)++groupSignaturesOn :: Eq a => (Signature -> a) -> [Signature] -> [[Signature]]+groupSignaturesOn f = groupBy ((==) `on` f)
+ src/Text/Dictionary.hs view
@@ -0,0 +1,31 @@+module Text.Dictionary (+  prepareFile,+  fromFile,+  toDictionary,+  exists,+  Dictionary) where++import Data.Set (Set, member, fromList, toList, fromDistinctAscList)+import Data.Char (toLower)++type Dictionary = Set String++prepareFile :: FilePath -> FilePath -> IO ()+prepareFile old new = edit old new (unlines . uniq . lines . lowercase)++fromFile :: FilePath -> IO Dictionary+fromFile path = fmap (toDictionary . lines) (readFile path)++toDictionary :: [String] -> Dictionary+toDictionary = fromDistinctAscList++exists :: String -> Dictionary -> Bool+exists e = member (lowercase e)++lowercase :: String -> String+lowercase = map toLower++uniq = toList . fromList++edit :: FilePath -> FilePath -> (String -> String) -> IO ()+edit old new f = readFile old >>= (return . f) >>= writeFile new
+ src/Text/Inflections/Tokenizer.hs view
@@ -0,0 +1,43 @@+module Text.Inflections.Tokenizer (+  CaseStyle,+  camelCase,+  snakeCase,+  rubyCase,+  canTokenize,+  tokenize) where++import Data.Char (toLower, isDigit, isLower)+import Data.Either (isRight)++import Text.Inflections+import Text.Inflections.Parse.Types+import Text.Parsec.Error (ParseError)++import Control.Fallible++type CaseStyle = String -> Either Text.Parsec.Error.ParseError [Text.Inflections.Parse.Types.Word]++camelCase      :: CaseStyle+camelCase      = parseCamelCase [] . filter (not.isDigit)++snakeCase      :: CaseStyle+snakeCase      = parseSnakeCase []++rubyCase       :: CaseStyle+rubyCase  word | (isLower.head) word = snakeCase baseWord+               | otherwise           = camelCase baseWord++               where baseWord = filter (`notElem` "!?+-=[]<>|&*/") word++canTokenize :: CaseStyle -> String -> Bool+canTokenize style = isRight . style++tokenize :: CaseStyle -> String -> [String]+tokenize style s | Just words <- (wordsOrNothing . style) s = concatMap toToken words+                 | otherwise = []+                  where toToken = return . map toLower+++wordsOrNothing = fmap (concatMap c) . orNothing+                where c (Word w) = [w]+                      c _        = []
+ src/Text/SimpleParser.hs view
@@ -0,0 +1,8 @@+module Text.SimpleParser (+  SimpleParser,+  MaybeParser,+  EitherParser) where++type SimpleParser a = String -> a+type MaybeParser a = String -> Maybe a+type EitherParser a = String -> Either String a