packages feed

x-dsp (empty) → 0.2

raw patch · 23 files changed

+18139/−0 lines, 23 filesdep +arraydep +basedep +bytestringsetup-changed

Dependencies added: array, base, bytestring, containers, monads-tf, text, transformers, type-level

Files

+ LICENSE 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:++    <program>  Copyright (C) <year>  <name of author>+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.+    This is free software, and you are welcome to redistribute it+    under certain conditions; type `show c' for details.++The hypothetical commands `show w' and `show c' should show the appropriate+parts of the General Public License.  Of course, your program's commands+might be different; for a GUI interface, you would use an "about box".++  You should also get your employer (if you work as a programmer) or school,+if any, to sign a "copyright disclaimer" for the program, if necessary.+For more information on this, and how to apply and follow the GNU GPL, see+<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>.
+ README view
@@ -0,0 +1,6 @@+Code using X-Dsp should be run with the monomorphism restriction+disabled (via the flag -XNoMonomorphismRestriction or similar).++If you want to use explicit type signatures, be prepared for very long class+contexts.  Various functions are provided ('a', 'k', 'i') to specify types+where they would otherwise be unable to be inferred.
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain
+ src/Language/XDsp/Implementations/Csound.hs view
@@ -0,0 +1,5582 @@+{-# LANGUAGE+     NoMonomorphismRestriction+    ,DoRec+    ,ExtendedDefaultRules+    ,TypeFamilies+    ,DeriveDataTypeable+    ,DeriveFunctor+    ,GeneralizedNewtypeDeriving+    ,ScopedTypeVariables+    ,MultiParamTypeClasses+    ,FlexibleInstances+    ,TupleSections+    ,OverlappingInstances+    ,TypeSynonymInstances #-}++module Language.XDsp.Implementations.Csound (+  S (..)+ ,BusType (..)+ ,HostOut (..)+ ,RType+ ,defaultRType+ ,unifyCsd+ ,writeHeader+ ,makeInstrument+ ,TList+ ,unTList'+ ,module Language.XDsp.Semantics.CsoundExt+)++where++import           Language.XDsp.Semantics+import           Language.XDsp.Semantics.CsoundExt hiding (CsOscil (..), CsOscili (..), CsSum (..))+import qualified Language.XDsp.Semantics.CsoundExt as CSE++import           Data.Char+import           Data.Data+import           Data.List (intersperse, intercalate)+import qualified Data.Map as M+import           Data.Maybe (fromMaybe, catMaybes)+import qualified Data.Set as S+import qualified Data.Text as T+import qualified Data.Text.Lazy as TL+import           Data.TypeLevel.Num ((:>=:), Nat, toInt)+import           Control.Monad.RWS+import           Control.Applicative+import           Control.Arrow++import           Text.Printf++-- ---------------------------------+-- ---------------------------------++-- |Initial csound pretty-printer++data CVar =+    Cnst Double+  | CStr String+  | CVar String+  deriving (Eq, Ord, Show, Read)++data VarType =+    A                  -- A-rate signal+  | K                  -- K-rate signal+  | I                  -- i-time value+  | F                  -- fsig+  | T                  -- function table+  | IC                 -- score i-statement+  | St                 -- String+  | U                  -- Unit+  | Tp VarType VarType -- tuple+  | T3 VarType VarType VarType         -- 3-tuple+  | T4 VarType VarType VarType VarType -- 4-element tuple+  | CList VarType      -- list+  deriving (Eq, Ord, Read, Show)++-- | get the initial character of a csound var from a VarType+mkChr :: VarType -> Char+mkChr T  = 'f'+mkChr IC = 'i'+mkChr St = 'i'  -- string type stored in ivals+mkChr x = toLower . head . show $ x++getLbl :: CVar -> String+getLbl (Cnst x)   = show x+getLbl (CStr s)   = show s+getLbl (CVar s)   = s++-- |Polyvariadic support for building argument lists+class ArgListBuilder r where+  appendToList :: [String] -> r++instance ArgListBuilder [String] where+  appendToList = reverse++instance (Varable a, ArgListBuilder r) => ArgListBuilder (a -> r) where+  appendToList arg = appendToList . (\acc a -> getVarLbl a : acc) arg++mkOp0 :: Varable out => String -> S n out+mkOp0 opname = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s\n" outName opname+  return out++-- |helper function to create a 1-argument opcode instance.+-- I should make these with TH, but that would require having "genName" in scope+-- which means S would need to be in scope, but then all the S instances+-- would be orphans, which I don't want either...+mkOp1 :: (Varable a, Varable out) => String -> a -> S n out+mkOp1 opname a1 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname (getVarLbl a1)+  return out++mkOp2 opname a1 a2 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2)+  return out++mkOp3 opname a1 a2 a3 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3)+  return out++mkOp4 opname a1 a2 a3 a4 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4)+  return out++mkOp5 opname a1 a2 a3 a4 a5 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5)+  return out++mkOp6 opname a1 a2 a3 a4 a5 a6 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6)+  return out++mkOp7 opname a1 a2 a3 a4 a5 a6 a7 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7)+  return out++mkOp8 opname a1 a2 a3 a4 a5 a6 a7 a8 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7 a8)+  return out++mkOp9 opname a1 a2 a3 a4 a5 a6 a7 a8 a9 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7 a8 a9)+  return out++mkOp10 opname a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7 a8 a9 a10)+  return out++mkOp11 opname a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11)+  return out++mkOp12 opname a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12)+  return out++mkOp13 opname a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13)+  return out++mkOp17 opname a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15 a16 a17 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15 a16 a17)+  return out++-- | remove null arguments; these appear when a list of arguments is empty.+argCleaner :: [String] -> String+argCleaner = intercalate ", " . filter (Prelude.not . null)++mkOp14 = error "mkOp14"+mkOp15 = error "mkOp15"+mkOp16 = error "mkOp16"+mkOp18 = error "mkOp18"+mkOp19 = error "mkOp19"+mkOp22 = error "mkOp22"+mkOp26 = error "mkOp26"+mkOp32 = error "mkOp32"+mkOp83 = error "mkOp83"+mkOp99 = error "mkOp99"+mkOp51 = error "mkOp51"+mkOp34 = error "mkOp34"+mkOp43 = error "mkOp43"++-- ------------------------------------------+-- ------------------------------------------+-- sco helpers++-- | A score item.  The "Card" name is old-school+data Card = Card VarType [String] deriving (Eq, Read, Show)++card2str :: Card -> String+card2str (Card typ args) = mkChr typ : unwords args ++ "\n"++writeCard :: Card -> S n ()+writeCard = tellSco . card2str++mkTbl :: Int -> Int -> Int -> [Int] -> Card+mkTbl nm time sz args = Card T . map show $ nm:time:sz:args++-- |Create a 0-filled f-statement in the score section.+mkScoreBuf :: Int -> Int -> S n ()+mkScoreBuf nm sz = writeCard $ mkTbl nm 0 sz [17,0,0]++-- | Holds data on a score item for memoization purposes.+data CardM = CardM VarType String String deriving (Eq, Ord, Show)++cacheBuf :: String -> Int -> CardM+cacheBuf lbl = CardM T lbl . show++-- ------------------------------------------+-- ------------------------------------------+-- external interface helpers++data BusType = KBus | TblBus Int deriving (Eq, Read, Show)++-- |Specifies details for a Host output described within the language.+-- First string is a host-specified label.  Second is an auto-generated+-- name (e.g. tablenum)+data HostOut = HostOut {+  busType :: BusType,+  busLbl  :: String,+  busName :: String } deriving (Eq, Read, Show)++-- ------------------------------------------+-- ------------------------------------------++data CacheKey =+ CKC CardM    -- score cache+ deriving (Eq, Ord, Show)++type WCache  = M.Map CacheKey CVar+type GenMap  = M.Map VarType Int+type ICache = S.Set Int+data SState  = SState {+  wcache :: WCache+ ,genMap :: GenMap+ ,iCache :: ICache}++type ScoType = TL.Text+type OrcType = TL.Text+type HostType = [HostOut]++type WType = (ScoType, OrcType, HostType)+type RType = (Integer, Integer) -- SR and ksmps++defaultRType = (44100,16)++newtype S n a = S { unS :: RWS RType WType SState a }+  deriving (Functor, Applicative, Monad, Typeable)++instance MonadFix (S n) where+  mfix f = S $ mfix (unS . f)++instance MonadState (S n) where+  type StateType (S n) = SState+  get = S get+  put = S . put++instance MonadWriter (S n) where+  type WriterType (S n) = WType+  tell   = S . tell+  listen = S . listen . unS+  pass   = S . pass . unS++instance MonadReader (S n) where+  type EnvType (S n) = RType+  ask   = S ask+  local f = S . local f . unS++csdHeader =+  "<CsoundSynthesizer>\n\+  \<CsOptions>\n\+  \%s\n\+  \</CsOptions>\n"++-- -------------------------+-- helpers for working with states++getGen :: S n GenMap+getGen = fmap genMap get++putGen :: GenMap -> S n ()+putGen newstate = modify (\ss -> ss {genMap = newstate})++cache  :: CacheKey -> CVar -> S n ()+cache key val = do+  SState cmap gen imap <- get+  put $ SState (M.insert key val cmap) gen imap++cacheInstr :: Int -> S n ()+cacheInstr n = modify (\ss -> let ic' = S.insert n (iCache ss) in ss { iCache = ic' })++instrInCache :: Int -> S n Bool+instrInCache n = do+  (SState _ _ imap) <- get+  return $ S.member n imap++tellOrc :: String -> S n ()+tellOrc s = tell (TL.pack s,mempty, mempty)++tellSco :: String -> S n ()+tellSco s = tell (mempty,TL.pack s,mempty)++tellHost :: HostOut -> S n ()+tellHost s = tell (mempty,mempty, [s])++runS :: S n a -> RType -> (a, SState, WType)+runS e rt = runRWS (unS e) rt (SState M.empty M.empty S.empty)++evalS :: S n a -> RType -> a+evalS e rt = let (a,_,_) = runS e rt in a++getWritten :: RType -> S n x -> WType+getWritten rt e = let (_,_,w) = runS e rt in w++-- |Creates a CSD formatted String from args and an x-dsp expression.+unifyCsd :: [String] -> RType -> S n x -> (TL.Text, [HostOut])+unifyCsd args r = unifyCsd' args . getWritten r++-- |Creates a CSD file from an argument list and Writer output+unifyCsd' :: [String] -> WType -> (TL.Text, [HostOut])+unifyCsd' args (orc, sco, host) = (csd, host)+ where+  oH = TL.pack "<CsInstruments>\n"+  oF = TL.pack "\n</CsInstruments>\n"+  sH = TL.pack "<CsScore>\n"+  sF = TL.pack "\ne\n</CsScore>\n</CsoundSynthesizer>\n"++  csd = TL.concat [TL.pack (printf csdHeader (unwords args))+                  ,oH ,orc ,oF ,sH ,sco ,sF]++class Varable s where+  genName   :: S n (s, String)+  getVarLbl :: s -> String++class Varable s => PVar s where++class Varable s => KVar s where++-- |Create a new number of the appropriate type.+-- This can be made into a name by prepending the type character.+mkName :: VarType -> S n Int+mkName typ = do+  gen <- getGen+  let num = fromMaybe 1 $ M.lookup typ gen+  putGen $ M.alter (const $ Just (succ num)) typ gen+  return num+++-- ---------------------------------+-- ---------------------------------+-- Instances++instance Dsp (S n) where+  data (ASig (S n)) = S_A CVar+  data (KSig (S n)) = S_K CVar+  data (INum (S n)) = S_IN CVar+  getSr    = fst <$> ask+  getKsmps = snd <$> ask++instance Constants (S n) where+  cnst = return . S_IN . Cnst+  ckig = return . S_K . Cnst+  csig = return . S_A . Cnst++instance Varable (ASig (S n)) where+  genName = do+    SState omap gen imap <- get+    let num = fromMaybe 1 $ M.lookup A gen+        nm  = 'a' : show num+    put $ SState omap (M.alter (const $ Just (succ num)) A gen) imap+    return (S_A $ CVar nm, nm)+  getVarLbl (S_A c) = getLbl c++instance PVar (ASig (S n)) where++instance Varable (KSig (S n)) where+  genName = do+    SState omap gen imap <- get+    let num = fromMaybe 1 $ M.lookup K gen+        nm  = 'k' : show num+    put $ SState omap (M.alter (const $ Just (succ num)) K gen) imap+    return (S_K $ CVar nm, nm)+  getVarLbl (S_K c) = getLbl c++instance PVar (KSig (S n)) where+instance KVar (KSig (S n)) where++instance Varable (INum (S n)) where+  genName = do+    SState omap gen imap <- get+    let num = fromMaybe 1 $ M.lookup I gen+        nm  = 'i' : show num+    put $ SState omap (M.alter (const $ Just (succ num)) I gen) imap+    return (S_IN $ CVar nm, nm)+  getVarLbl (S_IN c) = getLbl c++instance Varable () where+  genName            = return ((), "")+  getVarLbl _        = "()"++instance Varable String where+  genName = error "Can't call 'genName' on String directly"+  getVarLbl s = '"' : s ++ "\""++instance Varable (VString (S n)) where+  genName = do+    SState omap gen imap <- get+    let num = fromMaybe 1 $ M.lookup St gen+        nm  = 'S' : show num+    put $ SState omap (M.alter (const $ Just (succ num)) St gen) imap+    return (S_VS $ CVar nm, nm)+  getVarLbl (S_VS c) = getLbl c++instance KVar (VString (S n)) where++instance (Varable a, Varable b) => Varable (a,b) where+  genName = do+    (o1,nm1) <- genName+    (o2,nm2) <- genName+    return ((o1,o2), nm1 ++ ", " ++ nm2)+  getVarLbl (a,b)      = getVarLbl a ++ ", " ++ getVarLbl b++instance (Varable a, Varable b, Varable c) =>+ Varable (a,b,c) where+  genName = do+    (o1,nm1) <- genName+    (o2,nm2) <- genName+    (o3,nm3) <- genName+    return ((o1,o2,o3), intercalate ", " [nm1, nm2, nm3])+  getVarLbl (a,b,c) =+    intercalate ", " [getVarLbl a, getVarLbl b,getVarLbl c]++instance (Varable a, Varable b, Varable c, Varable d) => Varable (a,b,c,d) where+  genName = do+    (o1,nm1) <- genName+    (o2,nm2) <- genName+    (o3,nm3) <- genName+    (o4,nm4) <- genName+    return ((o1,o2,o3,o4), intercalate ", " [nm1, nm2, nm3, nm4])+  getVarLbl (a,b,c,d) =+    intercalate ", " [getVarLbl a, getVarLbl b,getVarLbl c, getVarLbl d]++instance Varable a => Varable [a] where+  genName             = error "Can't generate names for arbitrary lists"+  getVarLbl           = intercalate ", " . map getVarLbl++instance forall d a. (Varable a, Nat d) => Varable (TList d a) where+  genName = do+    outss <- replicateM (toInt (undefined :: d)) genName+    return (TList $ map fst outss, intercalate ", " $ map snd outss)+  getVarLbl           = intercalate ", " . map getVarLbl . unTList++instance KVar (INum (S n)) where++instance PVS (S n) where+  data FSig (S n) = S_FSig CVar++instance Varable (FSig (S n)) where+  genName = do+    SState omap gen imap <- get+    let num = fromMaybe 1 $ M.lookup F gen+        nm  = 'f' : show num+    put $ SState omap (M.alter (const $ Just (succ num)) F gen) imap+    return (S_FSig $ CVar nm, nm)+  getVarLbl (S_FSig c) = getLbl c++-- | need this to directly use numeric literals as arguments.+instance Varable Double where+  genName   = error "genName shouldn't be called with Doubles"+  getVarLbl = show++instance StringVar (S n) where+  data VString (S n) = S_VS CVar++-- ---------------------------------+-- ---------------------------------+-- The csound class+instance CsoundClass (S n) where+  nchnls n   = tellOrc (printf "nchnls = %i\n" n) >> return n+  set0dbfs n = tellOrc (printf "0dbfs = %f\n" n) >> return n++-- ---------------------------------+-- ---------------------------------+-- Numeric support for signals+instance Show (ASig (S n)) where+  show (S_A s) = show s++instance Eq (ASig (S n)) where+  (S_A a) == (S_A b) = a == b++instance Num (ASig (S n)) where+  (S_A a) + (S_A b) = S_A . CVar $ printf "(%s + %s)" (getLbl a) (getLbl b)+  (S_A a) - (S_A b) = S_A . CVar $ printf "(%s - %s)" (getLbl a) (getLbl b)+  (S_A a) * (S_A b) = S_A . CVar $ printf "(%s * %s)" (getLbl a) (getLbl b)+  abs _       = error "abs called on (ASig (S n))"+  signum      = error "signum called on (ASig (S n))"+  fromInteger = S_A . Cnst . fromInteger++instance Fractional (ASig (S n)) where+  (S_A a) / (S_A b) = S_A . CVar $ printf "(%s / %s)" (getLbl a) (getLbl b)+  fromRational = S_A . Cnst . fromRational++instance Show (KSig (S n)) where+  show (S_K s) = show s++instance Eq (KSig (S n)) where+  (S_K a) == (S_K b) = a == b++instance Num (KSig (S n)) where+  (S_K a) + (S_K b) = S_K . CVar $ printf "(%s + %s)" (getLbl a) (getLbl b)+  (S_K a) - (S_K b) = S_K . CVar $ printf "(%s - %s)" (getLbl a) (getLbl b)+  (S_K a) * (S_K b) = S_K . CVar $ printf "(%s * %s)" (getLbl a) (getLbl b)+  abs _       = error "abs called on (KSig (S n))"+  signum      = error "signum called on (KSig (S n))"+  fromInteger = S_K . Cnst . fromInteger++instance Fractional (KSig (S n)) where+  (S_K a) / (S_K b) = S_K . CVar $ printf "(%s / %s)" (getLbl a) (getLbl b)+  fromRational = S_K . Cnst . fromRational++instance Show (INum (S n)) where+  show (S_IN s) = show s++instance Eq (INum (S n)) where+  (S_IN a) == (S_IN b) = a == b++instance Num (INum (S n)) where+  (S_IN (Cnst a)) + (S_IN (Cnst b)) = S_IN $ Cnst (a+b)+  (S_IN a) + (S_IN b) = S_IN . CVar $ printf "(%s + %s)" (getLbl a) (getLbl b)+  (S_IN (Cnst a)) - (S_IN (Cnst b)) = S_IN $ Cnst (a-b)+  (S_IN a) - (S_IN b) = S_IN . CVar $ printf "(%s - %s)" (getLbl a) (getLbl b)+  (S_IN (Cnst a)) * (S_IN (Cnst b)) = S_IN $ Cnst (a*b)+  (S_IN a) * (S_IN b) = S_IN . CVar $ printf "(%s * %s)" (getLbl a) (getLbl b)+  abs _       = error "abs called on (INum (S n))"+  signum      = error "signum called on (INum (S n))"+  fromInteger = S_IN . Cnst . fromInteger++instance Fractional (INum (S n)) where+  (S_IN (Cnst a)) / (S_IN (Cnst b)) = S_IN . Cnst $ a/b+  (S_IN a) / (S_IN b) = S_IN . CVar $ printf "(%s / %s)" (getLbl a) (getLbl b)+  fromRational = S_IN . Cnst . fromRational++instance Show s => Show ((S n) s) where+  show s = show $ evalS s defaultRType++instance Eq e => Eq ((S n) e) where+  e1 == e2 = evalS ((==) <$> e1 <*> e2) defaultRType++instance Num e => Num ((S n) e) where+  e1 + e2     = (+) <$> e1 <*> e2+  e1 - e2     = (-) <$> e1 <*> e2+  e1 * e2     = (*) <$> e1 <*> e2+  abs         = fmap Prelude.abs+  signum      = fmap signum+  fromInteger = pure . fromInteger++instance Fractional e => Fractional ((S n) e) where+  e1 / e2 = (/) <$> e1 <*> e2+  recip   = fmap recip+  fromRational = pure . fromRational++-- ---------------------------------+-- ---------------------------------+-- core language extensions++-- | supports assignment+instance Varable a => Asn (S n) a where+  asn = mkOp1 "="++-- | supports output+instance Out (S n) where+  out = tellOrc . printf "       out %s\n" . getVarLbl+  outs a1 a2 = do+    (tellOrc $ printf "       outs %s, %s\n" (getVarLbl a1) (getVarLbl a2))+  outq a1 a2 a3 a4 = do+    (tellOrc $ printf "       outs %s, %s, %s, %s\n"+      (getVarLbl a1) (getVarLbl a2) (getVarLbl a3) (getVarLbl a4))+  outo a1 a2 a3 a4 a5 a6 a7 a8 = do+    (tellOrc $ printf "       outs %s, %s, %s, %s, %s, %s, %s, %s\n"+      (getVarLbl a1) (getVarLbl a2) (getVarLbl a3) (getVarLbl a4)+      (getVarLbl a5) (getVarLbl a6) (getVarLbl a7) (getVarLbl a8))++-- ---------------------------------+-- ---------------------------------+-- Buffers (function tables)++-- | creation of buffers+instance Buffer (S n) where+  type Buf (S n) = INum (S n)+  emptyBuffer sz = do+    bufNum <- mkName T+    mkScoreBuf bufNum sz+    return $ fromIntegral bufNum++instance (Varable a) => BufferR (S n) a a where+  lookupAt = flip (mkOp2 "tablei")++-- | creation of host-variable buffers+instance VBuf (S n) where+  vbuf lbl sz = do+    (SState cmap gen imap) <- get+    case M.lookup (CKC $ cacheBuf lbl sz) cmap of+      Just nm -> return $ S_IN nm+      Nothing -> do+        bufNum <- mkName T+        mkScoreBuf bufNum sz+        tellHost . HostOut (TblBus sz) lbl $ show bufNum+        let res = Cnst $ fromIntegral bufNum+        cache (CKC $ cacheBuf lbl sz) res+        return $ S_IN res++-- ---------------------------------+-- ---------------------------------+-- Instruments++instance (Nat m, Nat n, Show n, m :>=: n) => NumArgs S m n where+  getArg n = return . S_IN . CVar $ 'p': show n++-- | Labelled blocks (basic instrument creation)+instance LblBlock (S n) where+  type ArgTag (S n) = n+  type ArgTyp (S n) = Either String Double+  data Block (S n) = Instr Int+  lblBlock num e = do+    isCached <- instrInCache num+    when (Prelude.not isCached) $ do+      tellOrc (printf "instr %d\n" num) >> e >> tellOrc "endin\n\n"+      clearBlockData+      cacheInstr num+    return $ Instr num+  runBlock = runBlock'++getArgVal :: Either String Double -> String+getArgVal = either show show++makeInstrument :: S n () -> S n (Block (S n))+makeInstrument e = do+  SState _ _ imap <- get+  maybe (lblBlock 1 e) (\(n, _) -> lblBlock (n+1) e) $ S.maxView imap++-- | After labelling a block (csound instr), we need to clear the opcode+-- caches, otherwise code could be invalidly shared between instruments.+-- We can clear the name generator too (except for table nums).+clearBlockData :: S n ()+clearBlockData = do+  (SState cmap genmap imap) <- get+  let cmap' = M.mapMaybeWithKey cmf cmap+      genmap' = M.mapMaybeWithKey gmf genmap+  put $ SState cmap' genmap' imap+ where+  cmf k       v = Just v+  gmf T n       = Just n+  gmf _ _       = Nothing++-- | Runs a block (instr).+runBlock' ::+  Block (S n)+  -> Double+  -> Double+  -> TList m (Either String Double)+  -> S n ()+runBlock' (Instr blkLbl) startIn dur args =+  writeCard . Card IC $ [show blkLbl, show startIn, show dur]+                        ++ map getArgVal (unTList args)++-- runBlock' should have the constraint (n :>=: m), but that doesn't work+-- because the constraint isn't passed through the LblBlock class.+-- It's not a problem because the constraint is enforced by "getArg", so+-- only valid arguments will be used.++-- | Writes the header data+writeHeader :: Int -> Double -> S n ()+writeHeader nc dbfs = do+  (sr,ksmps) <- ask+  setSR sr+  setKSmps ksmps+  nchnls nc+  set0dbfs dbfs+  return ()++setSR n       = tellOrc (printf "sr = %i\n" n) >> return n+setKSmps n    = tellOrc (printf "ksmps = %i\n" n) >> return n++-- ---------------------------------+-- ---------------------------------+-- phasor+instance Phasor (S n) (KSig (S n)) (KSig (S n)) where+  phasor = mkOp1 "phasor"++instance (Varable a) => Phasor (S n) (ASig (S n)) a where+  phasor = mkOp1 "phasor"++-- oscillators++-- | Supports table-lookup oscillators+instance (Varable a, Varable b, PVar out) => Oscil (S n) out a b where+  oscil   = mkOp3 "oscil3"+  oscil'  = mkOp4 "oscil3"++-- ---------------------------------+-- ---------------------------------+-- delays+instance Delay (S n) where+  delaySamp = mkOp1 "delay1"+  vdelay3   = mkOp3 "vdelay3"++-- delay networks+instance DelayNet (S n) where+  type DelayN (S n) = SDelay n+  runDelay  = runDelay'+  tapA      = tap'+  tapK      = tap'+  tapI      = tap'++newtype SDelay n a = SDelay { unDelay :: S n a }+  deriving (Functor)++instance Applicative (SDelay n) where+  pure = SDelay . pure+  (SDelay a) <*> (SDelay b) = SDelay (a <*> b)++runDelay' :: INum (S n) -> ASig (S n) -> SDelay n a -> S n a+runDelay' maxdel insig dl = do+  tellOrc $ printf "aNull delayr %s\n" (getVarLbl maxdel)+  v <- unDelay dl+  tellOrc $ printf "    delayw %s\n" (getVarLbl insig)+  return v++tap' :: Varable b => b -> SDelay n (ASig (S n))+tap' dtime = SDelay $ mkOp1 "deltap3" dtime+++-- ---------------------------------+-- ---------------------------------+-- test instruments++-- | very basic block+t1 = do+  v <- csig 1000+  outs v v++-- | allocate a "variable buffer" (i.e. host-updated buffer)+t2 = do+  buf <- vbuf "a buffer" 8192+  so <- oscil 1000 440 buf+  outs so so++-- | delay networks++-- | simple delay with constant signal+t3 = do+  so <- runDelay 1 1000 (tapK 1)+  outs so so++t4 = do+  buf <- vbuf "a buffer" 8192+  so <- oscil 1000 440 buf+  let d = (\d1 d2 -> 0.5*d1+0.25*d2) <$> tapI 1 <*> tapI 2+  dl <- runDelay 2 so d+  sig <- asn $ so + dl+  outs sig sig++t5 = do+  buf <- vbuf "a buffer" 8192+  so  <- oscil 1000 440 buf+  let d = (\d1 d2 -> 0.5*d1+0.25*d2) <$> tapI 1 <*> tapI 2+  rec dl <- runDelay 2 (so+dl) d+  sig <- asn $ so + dl+  outs sig sig++t5' = do+  buf <- vbuf "a buffer" 8192+  so  <- oscil 1000 440 buf+  let d = (\d1 d2 -> 0.5*d1+0.25*d2) <$> tapI 1 <*> tapI 2+  rec dl <- runDelay 2 (so + 0.1*dl) d+  sig <- asn $ so + dl+  outs sig sig++-- | additive synthesis.  Shared buffer, uses the Num instance for signals.+t6 = do+  so  <- zipWithM (\fq buf -> oscil 1000 (fq*110) buf) [4..] (replicate 20 1)+  so' <- asn $ sum so+  outs so' so'++-- | using fold to make an oscil stack.  Note that emptyBuffer is *not*+-- memoized.+t8 = do+  buf <- emptyBuffer 8192+  stack <- foldM (\a f -> f a) (40)+                       (replicate 4 (\fq -> oscil 1000 fq buf))+  outs stack stack++-- | It's necessary to use monadic sequencing (here implicit in makeInstruments)+-- to chain instruments together+all1 = mapM makeInstrument [t1,t2, t3, t4, t5', t6, t8]+instance  CsATSadd (S n)  where+  aTSadd = mkOp5 "aTSadd"+  aTSadd' = mkOp8 "aTSadd"+++instance  CsATSaddnz (S n)  where+  aTSaddnz = mkOp3 "aTSaddnz"+  aTSaddnz' = mkOp5 "aTSaddnz"+++instance  CsATSbufread (S n)  where+  aTSbufread = mkOp4 "aTSbufread"+  aTSbufread' = mkOp6 "aTSbufread"+++instance  CsATScross (S n)  where+  aTScross = mkOp7 "aTScross"+  aTScross' = mkOp11 "aTScross"+++instance  CsATSinfo (S n)  where+  aTSinfo = mkOp2 "aTSinfo"+++instance  CsATSinterpread (S n)  where+  aTSinterpread = mkOp1 "aTSinterpread"+++instance  CsATSpartialtap (S n)  where+  aTSpartialtap = mkOp1 "aTSpartialtap"+++instance  CsATSread (S n)  where+  aTSread = mkOp3 "aTSread"+++instance  CsATSreadnz (S n)  where+  aTSreadnz = mkOp3 "aTSreadnz"+++instance  CsATSsinnoi (S n)  where+  aTSsinnoi = mkOp6 "aTSsinnoi"+  aTSsinnoi' = mkOp8 "aTSsinnoi"+++instance  CsMixerClear (S n)  where+  mixerClear = mkOp0 "mixerClear"+++instance  CsMixerGetLevel (S n)  where+  mixerGetLevel = mkOp2 "mixerGetLevel"+++instance  CsMixerReceive (S n)  where+  mixerReceive = mkOp2 "mixerReceive"+++instance  CsMixerSend (S n)  where+  mixerSend = mkOp4 "mixerSend"+++instance  CsMixerSetLevel (S n)  where+  mixerSetLevel = mkOp3 "mixerSetLevel"+++instance  CsMixerSetLevel_i (S n)  where+  mixerSetLevel_i = mkOp3 "mixerSetLevel_i"+++instance  CsACS (S n)  where+  aCS = mkOp1 "aCS"+++instance  CsAbs (S n) (ASig (S n)) (ASig (S n)) where+  abs = mkOp1 "abs"+++instance  CsAbs (S n) (KSig (S n)) (KSig (S n)) where+  abs = mkOp1 "abs"+++instance  CsAbs (S n) (INum (S n)) (INum (S n)) where+  abs = mkOp1 "abs"+++instance (Varable a, Varable b) => CsAdd (S n) (ASig (S n)) a b where+  add = mkOp2 "add"+++instance  CsAdd (S n) (KSig (S n)) (KSig (S n)) (KSig (S n)) where+  add = mkOp2 "add"+++instance  CsAdd (S n) (INum (S n)) (INum (S n)) (INum (S n)) where+  add = mkOp2 "add"+++instance (PVar out) => CsAdsr (S n) out where+  adsr = mkOp4 "adsr"+  adsr' = mkOp5 "adsr"+++instance  CsAdsyn (S n)  where+  adsyn = mkOp4 "adsyn"+  adsyn' = mkOp5 "adsyn"+++instance  CsAdsynt (S n)  where+  adsynt = mkOp6 "adsynt"+  adsynt' = mkOp7 "adsynt"+++instance  CsAdsynt2 (S n)  where+  adsynt2 = mkOp6 "adsynt2"+  adsynt2' = mkOp7 "adsynt2"+++instance  CsAftouch (S n)  where+  aftouch = mkOp0 "aftouch"+  aftouch' = mkOp2 "aftouch"+++instance  CsAlpass (S n)  where+  alpass = mkOp3 "alpass"+  alpass' = mkOp5 "alpass"+++instance  CsAlwayson (S n)  where+  alwayson = mkOp2 "alwayson"+++instance  CsAmpdb (S n) (ASig (S n)) (ASig (S n)) where+  ampdb = mkOp1 "ampdb"+++instance  CsAmpdb (S n) (KSig (S n)) (KSig (S n)) where+  ampdb = mkOp1 "ampdb"+++instance  CsAmpdb (S n) (INum (S n)) (INum (S n)) where+  ampdb = mkOp1 "ampdb"+++instance  CsAmpdbfs (S n) (ASig (S n)) (ASig (S n)) where+  ampdbfs = mkOp1 "ampdbfs"+++instance  CsAmpdbfs (S n) (KSig (S n)) (KSig (S n)) where+  ampdbfs = mkOp1 "ampdbfs"+++instance  CsAmpdbfs (S n) (INum (S n)) (INum (S n)) where+  ampdbfs = mkOp1 "ampdbfs"+++instance  CsAmpmidi (S n)  where+  ampmidi = mkOp1 "ampmidi"+  ampmidi' = mkOp2 "ampmidi"+++instance  CsAmpmidid (S n) (KSig (S n)) where+  ampmidid = mkOp2 "ampmidid"+++instance  CsAmpmidid (S n) (INum (S n)) where+  ampmidid = mkOp2 "ampmidid"+++instance (Varable a, Varable b) => CsAnd (S n) (ASig (S n)) a b where+  and = mkOp2 "and"+++instance  CsAnd (S n) (KSig (S n)) (KSig (S n)) (KSig (S n)) where+  and = mkOp2 "and"+++instance  CsAnd (S n) (INum (S n)) (INum (S n)) (INum (S n)) where+  and = mkOp2 "and"+++instance  CsAreson (S n)  where+  areson = mkOp3 "areson"+  areson' = mkOp5 "areson"+++instance  CsAresonk (S n)  where+  aresonk = mkOp3 "aresonk"+  aresonk' = mkOp5 "aresonk"+++instance  CsAtone (S n)  where+  atone = mkOp2 "atone"+  atone' = mkOp3 "atone"+++instance  CsAtonek (S n)  where+  atonek = mkOp2 "atonek"+  atonek' = mkOp3 "atonek"+++instance  CsAtonex (S n)  where+  atonex = mkOp2 "atonex"+  atonex' = mkOp4 "atonex"+++instance  CsBabo (S n)  where+  babo = mkOp7 "babo"+  babo' = mkOp9 "babo"+++instance  CsBalance (S n)  where+  balance = mkOp2 "balance"+  balance' = mkOp4 "balance"+++instance  CsBamboo (S n)  where+  bamboo = mkOp2 "bamboo"+  bamboo' = mkOp8 "bamboo"+++instance  CsBarmodel (S n)  where+  barmodel = mkOp9 "barmodel"+++instance  CsBbcutm (S n)  where+  bbcutm = mkOp6 "bbcutm"+  bbcutm' = mkOp9 "bbcutm"+++instance  CsBbcuts (S n)  where+  bbcuts = mkOp7 "bbcuts"+  bbcuts' = mkOp10 "bbcuts"+++instance  CsBetarand (S n) (ASig (S n)) where+  betarand = mkOp3 "betarand"+++instance  CsBetarand (S n) (KSig (S n)) where+  betarand = mkOp3 "betarand"+++instance  CsBetarand (S n) (INum (S n)) where+  betarand = mkOp3 "betarand"+++instance  CsBexprnd (S n) (ASig (S n)) where+  bexprnd = mkOp1 "bexprnd"+++instance  CsBexprnd (S n) (KSig (S n)) where+  bexprnd = mkOp1 "bexprnd"+++instance  CsBexprnd (S n) (INum (S n)) where+  bexprnd = mkOp1 "bexprnd"+++instance (Nat d) => CsBformdec (S n) d where+  bformdec = mkOp5 "bformdec"+++instance (Nat d) => CsBformdec1 (S n) d where+  bformdec1 = mkOp2 "bformdec1"+++instance (Nat d) => CsBformenc1 (S n) d where+  bformenc1 = mkOp3 "bformenc1"+++instance  CsBinit (S n)  where+  binit = mkOp2 "binit"+++instance  CsBiquad (S n)  where+  biquad = mkOp7 "biquad"+  biquad' = mkOp8 "biquad"+++instance  CsBiquada (S n)  where+  biquada = mkOp7 "biquada"+  biquada' = mkOp8 "biquada"+++instance  CsBirnd (S n) (KSig (S n)) where+  birnd = mkOp1 "birnd"+++instance  CsBirnd (S n) (INum (S n)) where+  birnd = mkOp1 "birnd"+++instance (Varable a, Varable b) => CsBqrez (S n) a b where+  bqrez = mkOp3 "bqrez"+  bqrez' = mkOp5 "bqrez"+++instance  CsButbp (S n)  where+  butbp = mkOp3 "butbp"+  butbp' = mkOp4 "butbp"+++instance  CsButbr (S n)  where+  butbr = mkOp3 "butbr"+  butbr' = mkOp4 "butbr"+++instance  CsButhp (S n)  where+  buthp = mkOp2 "buthp"+  buthp' = mkOp3 "buthp"+++instance  CsButlp (S n)  where+  butlp = mkOp2 "butlp"+  butlp' = mkOp3 "butlp"+++instance  CsButterbp (S n)  where+  butterbp = mkOp3 "butterbp"+  butterbp' = mkOp4 "butterbp"+++instance  CsButterbr (S n)  where+  butterbr = mkOp3 "butterbr"+  butterbr' = mkOp4 "butterbr"+++instance  CsButterhp (S n)  where+  butterhp = mkOp2 "butterhp"+  butterhp' = mkOp3 "butterhp"+++instance  CsButterlp (S n)  where+  butterlp = mkOp2 "butterlp"+  butterlp' = mkOp3 "butterlp"+++instance  CsButton (S n)  where+  button = mkOp1 "button"+++instance (Varable a, Varable b) => CsBuzz (S n) a b where+  buzz = mkOp4 "buzz"+  buzz' = mkOp5 "buzz"+++instance  CsCabasa (S n)  where+  cabasa = mkOp2 "cabasa"+  cabasa' = mkOp5 "cabasa"+++instance  CsCauchy (S n) (ASig (S n)) where+  cauchy = mkOp1 "cauchy"+++instance  CsCauchy (S n) (KSig (S n)) where+  cauchy = mkOp1 "cauchy"+++instance  CsCauchy (S n) (INum (S n)) where+  cauchy = mkOp1 "cauchy"+++instance  CsCeil (S n) (ASig (S n)) (ASig (S n)) where+  ceil = mkOp1 "ceil"+++instance  CsCeil (S n) (KSig (S n)) (KSig (S n)) where+  ceil = mkOp1 "ceil"+++instance  CsCeil (S n) (INum (S n)) (INum (S n)) where+  ceil = mkOp1 "ceil"+++instance  CsCent (S n) (ASig (S n)) (ASig (S n)) where+  cent = mkOp1 "cent"+++instance  CsCent (S n) (KSig (S n)) (KSig (S n)) where+  cent = mkOp1 "cent"+++instance  CsCent (S n) (INum (S n)) (INum (S n)) where+  cent = mkOp1 "cent"+++instance  CsChanctrl (S n) (KSig (S n)) where+  chanctrl = mkOp2 "chanctrl"+  chanctrl' = mkOp4 "chanctrl"+++instance  CsChanctrl (S n) (INum (S n)) where+  chanctrl = mkOp2 "chanctrl"+  chanctrl' = mkOp4 "chanctrl"+++instance  CsChanged (S n)  where+  changed = mkOp1 "changed"+++instance  CsChani (S n) (ASig (S n)) where+  chani = mkOp1 "chani"+++instance  CsChani (S n) (KSig (S n)) where+  chani = mkOp1 "chani"+++instance (Varable a) => CsChano (S n) a where+  chano = mkOp2 "chano"+++instance  CsChebyshevpoly (S n)  where+  chebyshevpoly = mkOp2 "chebyshevpoly"+++instance  CsCheckbox (S n)  where+  checkbox = mkOp1 "checkbox"+++instance  CsChn_S (S n)  where+  chn_S = mkOp2 "chn_S"+++instance  CsChn_a (S n)  where+  chn_a = mkOp2 "chn_a"+++instance  CsChn_k (S n)  where+  chn_k = mkOp2 "chn_k"+  chn_k' = mkOp6 "chn_k"+++instance  CsChnclear (S n)  where+  chnclear = mkOp1 "chnclear"+++instance  CsChnexport (S n) (ASig (S n)) where+  chnexport = mkOp2 "chnexport"+++instance  CsChnexport (S n) (KSig (S n)) where+  chnexport = mkOp2 "chnexport"+++instance  CsChnexport (S n) (INum (S n)) where+  chnexport = mkOp2 "chnexport"+++instance  CsChnexport (S n) (VString (S n)) where+  chnexport = mkOp2 "chnexport"+++instance  CsChnget (S n) (ASig (S n)) where+  chnget = mkOp1 "chnget"+++instance  CsChnget (S n) (KSig (S n)) where+  chnget = mkOp1 "chnget"+++instance  CsChnget (S n) (INum (S n)) where+  chnget = mkOp1 "chnget"+++instance  CsChnget (S n) (VString (S n)) where+  chnget = mkOp1 "chnget"+++instance  CsChnmix (S n)  where+  chnmix = mkOp2 "chnmix"+++instance  CsChnrecv (S n)  where+  chnrecv = mkOp1 "chnrecv"+  chnrecv' = mkOp2 "chnrecv"+++instance  CsChnsend (S n)  where+  chnsend = mkOp1 "chnsend"+  chnsend' = mkOp2 "chnsend"+++instance (Varable a) => CsChnset (S n) a where+  chnset = mkOp2 "chnset"+++instance  CsClear (S n)  where+  clear = mkOp1 "clear"+++instance  CsClfilt (S n)  where+  clfilt = mkOp4 "clfilt"+  clfilt' = mkOp8 "clfilt"+++instance  CsClip (S n)  where+  clip = mkOp3 "clip"+  clip' = mkOp4 "clip"+++instance  CsClockoff (S n)  where+  clockoff = mkOp1 "clockoff"+++instance  CsClockon (S n)  where+  clockon = mkOp1 "clockon"+++instance  CsComb (S n)  where+  comb = mkOp3 "comb"+  comb' = mkOp5 "comb"+++instance  CsCompress (S n)  where+  compress = mkOp9 "compress"+++instance  CsConnect (S n)  where+  connect = mkOp4 "connect"+++instance  CsControl (S n)  where+  control = mkOp1 "control"+++instance (Nat d) => CsConvle (S n) d where+  convle = mkOp2 "convle"+  convle' = mkOp3 "convle"+++instance (Nat d) => CsConvolve (S n) d where+  convolve = mkOp2 "convolve"+  convolve' = mkOp3 "convolve"+++instance  CsCos (S n) (ASig (S n)) (ASig (S n)) where+  cos = mkOp1 "cos"+++instance  CsCos (S n) (KSig (S n)) (KSig (S n)) where+  cos = mkOp1 "cos"+++instance  CsCos (S n) (INum (S n)) (INum (S n)) where+  cos = mkOp1 "cos"+++instance  CsCosh (S n) (ASig (S n)) (ASig (S n)) where+  cosh = mkOp1 "cosh"+++instance  CsCosh (S n) (KSig (S n)) (KSig (S n)) where+  cosh = mkOp1 "cosh"+++instance  CsCosh (S n) (INum (S n)) (INum (S n)) where+  cosh = mkOp1 "cosh"+++instance  CsCosinv (S n) (ASig (S n)) (ASig (S n)) where+  cosinv = mkOp1 "cosinv"+++instance  CsCosinv (S n) (KSig (S n)) (KSig (S n)) where+  cosinv = mkOp1 "cosinv"+++instance  CsCosinv (S n) (INum (S n)) (INum (S n)) where+  cosinv = mkOp1 "cosinv"+++instance  CsCps2pch (S n)  where+  cps2pch = mkOp2 "cps2pch"+++instance  CsCpsmidi (S n)  where+  cpsmidi = mkOp0 "cpsmidi"+++instance  CsCpsmidib (S n) (KSig (S n)) where+  cpsmidib = mkOp0 "cpsmidib"+  cpsmidib' = mkOp1 "cpsmidib"+++instance  CsCpsmidib (S n) (INum (S n)) where+  cpsmidib = mkOp0 "cpsmidib"+  cpsmidib' = mkOp1 "cpsmidib"+++instance  CsCpsmidinn (S n) (KSig (S n)) where+  cpsmidinn = mkOp1 "cpsmidinn"+++instance  CsCpsmidinn (S n) (INum (S n)) where+  cpsmidinn = mkOp1 "cpsmidinn"+++instance  CsCpsoct (S n) (ASig (S n)) (ASig (S n)) where+  cpsoct = mkOp1 "cpsoct"+++instance  CsCpsoct (S n) (KSig (S n)) (KSig (S n)) where+  cpsoct = mkOp1 "cpsoct"+++instance  CsCpsoct (S n) (INum (S n)) (INum (S n)) where+  cpsoct = mkOp1 "cpsoct"+++instance  CsCpspch (S n) (KSig (S n)) where+  cpspch = mkOp1 "cpspch"+++instance  CsCpspch (S n) (INum (S n)) where+  cpspch = mkOp1 "cpspch"+++instance  CsCpstmid (S n)  where+  cpstmid = mkOp1 "cpstmid"+++instance  CsCpstun (S n)  where+  cpstun = mkOp3 "cpstun"+++instance  CsCpstuni (S n)  where+  cpstuni = mkOp2 "cpstuni"+++instance  CsCpsxpch (S n)  where+  cpsxpch = mkOp4 "cpsxpch"+++instance  CsCpuprc (S n)  where+  cpuprc = mkOp2 "cpuprc"+++instance  CsCross2 (S n)  where+  cross2 = mkOp6 "cross2"+++instance (Varable a, Varable b, Varable c, Varable d) => CsCrossfm (S n) a b c d where+  crossfm = mkOp7 "crossfm"+  crossfm' = mkOp9 "crossfm"+++instance (Varable a, Varable b, Varable c, Varable d) => CsCrossfmi (S n) a b c d where+  crossfmi = mkOp7 "crossfmi"+  crossfmi' = mkOp9 "crossfmi"+++instance (Varable a, Varable b, Varable c, Varable d) => CsCrossfmpm (S n) a b c d where+  crossfmpm = mkOp7 "crossfmpm"+  crossfmpm' = mkOp9 "crossfmpm"+++instance (Varable a, Varable b, Varable c, Varable d) => CsCrossfmpmi (S n) a b c d where+  crossfmpmi = mkOp7 "crossfmpmi"+  crossfmpmi' = mkOp9 "crossfmpmi"+++instance (Varable a, Varable b, Varable c, Varable d) => CsCrosspm (S n) a b c d where+  crosspm = mkOp7 "crosspm"+  crosspm' = mkOp9 "crosspm"+++instance (Varable a, Varable b, Varable c, Varable d) => CsCrosspmi (S n) a b c d where+  crosspmi = mkOp7 "crosspmi"+  crosspmi' = mkOp9 "crosspmi"+++instance  CsCrunch (S n)  where+  crunch = mkOp2 "crunch"+  crunch' = mkOp5 "crunch"+++instance  CsCtlchn (S n)  where+  ctlchn = mkOp0 "ctlchn"+  ctlchn' = mkOp2 "ctlchn"+++instance  CsCtrl14 (S n) (KSig (S n)) where+  ctrl14 = mkOp5 "ctrl14"+  ctrl14' = mkOp6 "ctrl14"+++instance  CsCtrl14 (S n) (INum (S n)) where+  ctrl14 = mkOp5 "ctrl14"+  ctrl14' = mkOp6 "ctrl14"+++instance  CsCtrl21 (S n) (KSig (S n)) where+  ctrl21 = mkOp6 "ctrl21"+  ctrl21' = mkOp7 "ctrl21"+++instance  CsCtrl21 (S n) (INum (S n)) where+  ctrl21 = mkOp6 "ctrl21"+  ctrl21' = mkOp7 "ctrl21"+++instance  CsCtrl7 (S n) (ASig (S n)) where+  ctrl7 = mkOp4 "ctrl7"+  ctrl7' = mkOp5 "ctrl7"+++instance  CsCtrl7 (S n) (KSig (S n)) where+  ctrl7 = mkOp4 "ctrl7"+  ctrl7' = mkOp5 "ctrl7"+++instance  CsCtrl7 (S n) (INum (S n)) where+  ctrl7 = mkOp4 "ctrl7"+  ctrl7' = mkOp5 "ctrl7"+++instance  CsCtrlinit (S n)  where+  ctrlinit = mkOp2 "ctrlinit"+++instance  CsCuserrnd (S n) (ASig (S n)) where+  cuserrnd = mkOp3 "cuserrnd"+++instance  CsCuserrnd (S n) (KSig (S n)) where+  cuserrnd = mkOp3 "cuserrnd"+++instance  CsCuserrnd (S n) (INum (S n)) where+  cuserrnd = mkOp3 "cuserrnd"+++instance  CsDam (S n)  where+  dam = mkOp6 "dam"+++instance  CsDate (S n)  where+  date = mkOp0 "date"+++instance  CsDates (S n)  where+  dates = mkOp0 "dates"+  dates' = mkOp1 "dates"+++instance  CsDb (S n) (ASig (S n)) (ASig (S n)) where+  db = mkOp1 "db"+++instance  CsDb (S n) (KSig (S n)) (KSig (S n)) where+  db = mkOp1 "db"+++instance  CsDb (S n) (INum (S n)) (INum (S n)) where+  db = mkOp1 "db"+++instance  CsDbamp (S n) (KSig (S n)) where+  dbamp = mkOp1 "dbamp"+++instance  CsDbamp (S n) (INum (S n)) where+  dbamp = mkOp1 "dbamp"+++instance  CsDbfsamp (S n) (KSig (S n)) where+  dbfsamp = mkOp1 "dbfsamp"+++instance  CsDbfsamp (S n) (INum (S n)) where+  dbfsamp = mkOp1 "dbfsamp"+++instance  CsDcblock (S n)  where+  dcblock = mkOp1 "dcblock"+  dcblock' = mkOp2 "dcblock"+++instance  CsDcblock2 (S n)  where+  dcblock2 = mkOp1 "dcblock2"+  dcblock2' = mkOp3 "dcblock2"+++instance  CsDconv (S n)  where+  dconv = mkOp3 "dconv"+++instance  CsDelay (S n)  where+  delay = mkOp2 "delay"+  delay' = mkOp3 "delay"+++instance  CsDelay1 (S n)  where+  delay1 = mkOp1 "delay1"+  delay1' = mkOp2 "delay1"+++instance  CsDelayk (S n)  where+  delayk = mkOp2 "delayk"+  delayk' = mkOp3 "delayk"+++instance  CsDelayw (S n)  where+  delayw = mkOp1 "delayw"+++instance  CsDeltap (S n)  where+  deltap = mkOp1 "deltap"+  deltap' = mkOp2 "deltap"+++instance (Varable a) => CsDeltap3 (S n) a where+  deltap3 = mkOp1 "deltap3"+  deltap3' = mkOp2 "deltap3"+++instance (Varable a) => CsDeltapi (S n) a where+  deltapi = mkOp1 "deltapi"+  deltapi' = mkOp2 "deltapi"+++instance (Varable a) => CsDeltapn (S n) a where+  deltapn = mkOp1 "deltapn"+  deltapn' = mkOp2 "deltapn"+++instance  CsDeltapx (S n)  where+  deltapx = mkOp2 "deltapx"+  deltapx' = mkOp3 "deltapx"+++instance  CsDeltapxw (S n)  where+  deltapxw = mkOp3 "deltapxw"+  deltapxw' = mkOp4 "deltapxw"+++instance  CsDenorm (S n)  where+  denorm = mkOp1 "denorm"+++instance (PVar out, Varable a) => CsDiff (S n) out a where+  diff = mkOp1 "diff"+  diff' = mkOp2 "diff"+++instance (Nat d) => CsDiskgrain (S n) d where+  diskgrain = mkOp8 "diskgrain"+  diskgrain' = mkOp10 "diskgrain"+++instance (Nat d) => CsDiskin (S n) d where+  diskin = mkOp2 "diskin"+  diskin' = mkOp7 "diskin"+++instance (Nat d) => CsDiskin2 (S n) d where+  diskin2 = mkOp2 "diskin2"+  diskin2' = mkOp8 "diskin2"+++instance  CsDistort (S n)  where+  distort = mkOp3 "distort"+  distort' = mkOp5 "distort"+++instance  CsDistort1 (S n)  where+  distort1 = mkOp5 "distort1"+  distort1' = mkOp6 "distort1"+++instance (Varable a, Varable b) => CsDiv (S n) (ASig (S n)) a b where+  div = mkOp2 "div"+++instance  CsDiv (S n) (KSig (S n)) (KSig (S n)) (KSig (S n)) where+  div = mkOp2 "div"+++instance  CsDiv (S n) (INum (S n)) (INum (S n)) (INum (S n)) where+  div = mkOp2 "div"+++instance (Varable a, Varable b) => CsDivz (S n) (ASig (S n)) a b where+  divz = mkOp3 "divz"+++instance  CsDivz (S n) (KSig (S n)) (KSig (S n)) (KSig (S n)) where+  divz = mkOp3 "divz"+++instance  CsDivz (S n) (INum (S n)) (INum (S n)) (INum (S n)) where+  divz = mkOp3 "divz"+++instance  CsDoppler (S n)  where+  doppler = mkOp3 "doppler"+  doppler' = mkOp5 "doppler"+++instance  CsDownsamp (S n)  where+  downsamp = mkOp1 "downsamp"+  downsamp' = mkOp2 "downsamp"+++instance  CsDripwater (S n)  where+  dripwater = mkOp2 "dripwater"+  dripwater' = mkOp8 "dripwater"+++instance  CsDumpk (S n)  where+  dumpk = mkOp4 "dumpk"+++instance  CsDumpk2 (S n)  where+  dumpk2 = mkOp5 "dumpk2"+++instance  CsDumpk3 (S n)  where+  dumpk3 = mkOp6 "dumpk3"+++instance  CsDumpk4 (S n)  where+  dumpk4 = mkOp7 "dumpk4"+++instance  CsDuserrnd (S n) (ASig (S n)) where+  duserrnd = mkOp1 "duserrnd"+++instance  CsDuserrnd (S n) (KSig (S n)) where+  duserrnd = mkOp1 "duserrnd"+++instance  CsDuserrnd (S n) (INum (S n)) where+  duserrnd = mkOp1 "duserrnd"+++instance  CsEndin (S n)  where+  endin = mkOp0 "endin"+++instance  CsEndop (S n)  where+  endop = mkOp0 "endop"+++instance (PVar out, Varable a) => CsEnvlpx (S n) out a where+  envlpx = mkOp7 "envlpx"+  envlpx' = mkOp8 "envlpx"+++instance (PVar out, Varable a) => CsEnvlpxr (S n) out a where+  envlpxr = mkOp6 "envlpxr"+  envlpxr' = mkOp8 "envlpxr"+++instance (PVar out, Varable a) => CsEphasor (S n) out a where+  ephasor = mkOp2 "ephasor"+  ephasor' = mkOp3 "ephasor"+++instance  CsEqfil (S n)  where+  eqfil = mkOp4 "eqfil"+  eqfil' = mkOp5 "eqfil"+++instance  CsEvent_i (S n)  where+  event_i = mkOp3 "event_i"+++instance  CsExitnow (S n)  where+  exitnow = mkOp0 "exitnow"+++instance  CsExp (S n) (ASig (S n)) (ASig (S n)) where+  exp = mkOp1 "exp"+++instance  CsExp (S n) (KSig (S n)) (KSig (S n)) where+  exp = mkOp1 "exp"+++instance  CsExp (S n) (INum (S n)) (INum (S n)) where+  exp = mkOp1 "exp"+++instance  CsExpcurve (S n)  where+  expcurve = mkOp2 "expcurve"+++instance (PVar out) => CsExpon (S n) out where+  expon = mkOp3 "expon"+++instance  CsExprand (S n) (ASig (S n)) where+  exprand = mkOp1 "exprand"+++instance  CsExprand (S n) (KSig (S n)) where+  exprand = mkOp1 "exprand"+++instance  CsExprand (S n) (INum (S n)) where+  exprand = mkOp1 "exprand"+++instance (PVar out) => CsExpseg (S n) out where+  expseg = mkOp4 "expseg"+++instance  CsExpsega (S n)  where+  expsega = mkOp4 "expsega"+++instance (PVar out) => CsExpsegr (S n) out where+  expsegr = mkOp4 "expsegr"+++instance  CsFiclose (S n)  where+  ficlose = mkOp1 "ficlose"+++instance  CsFilebit (S n)  where+  filebit = mkOp1 "filebit"+  filebit' = mkOp2 "filebit"+++instance  CsFilelen (S n)  where+  filelen = mkOp1 "filelen"+  filelen' = mkOp2 "filelen"+++instance  CsFilenchnls (S n)  where+  filenchnls = mkOp1 "filenchnls"+  filenchnls' = mkOp2 "filenchnls"+++instance  CsFilepeak (S n)  where+  filepeak = mkOp1 "filepeak"+  filepeak' = mkOp2 "filepeak"+++instance  CsFilesr (S n)  where+  filesr = mkOp1 "filesr"+  filesr' = mkOp2 "filesr"+++instance  CsFilevalid (S n)  where+  filevalid = mkOp1 "filevalid"+++instance  CsFilter2 (S n) (ASig (S n)) (ASig (S n)) where+  filter2 = mkOp4 "filter2"+++instance  CsFilter2 (S n) (KSig (S n)) (KSig (S n)) where+  filter2 = mkOp4 "filter2"+++instance  CsFin (S n)  where+  fin = mkOp4 "fin"+++instance  CsFini (S n)  where+  fini = mkOp4 "fini"+++instance  CsFink (S n)  where+  fink = mkOp4 "fink"+++instance  CsFiopen (S n)  where+  fiopen = mkOp2 "fiopen"+++instance  CsFlanger (S n)  where+  flanger = mkOp3 "flanger"+  flanger' = mkOp4 "flanger"+++instance  CsFlashtxt (S n)  where+  flashtxt = mkOp2 "flashtxt"+++instance  CsFlooper (S n)  where+  flooper = mkOp6 "flooper"+++instance (KVar a) => CsFlooper2 (S n) a where+  flooper2 = mkOp6 "flooper2"+  flooper2' = mkOp11 "flooper2"+++instance  CsFlooper3 (S n)  where+  flooper3 = mkOp6 "flooper3"+  flooper3' = mkOp10 "flooper3"+++instance  CsFloor (S n) (ASig (S n)) (ASig (S n)) where+  floor = mkOp1 "floor"+++instance  CsFloor (S n) (KSig (S n)) (KSig (S n)) where+  floor = mkOp1 "floor"+++instance  CsFloor (S n) (INum (S n)) (INum (S n)) where+  floor = mkOp1 "floor"+++instance  CsFmb3 (S n)  where+  fmb3 = mkOp11 "fmb3"+++instance  CsFmbell (S n)  where+  fmbell = mkOp11 "fmbell"+++instance  CsFmmetal (S n)  where+  fmmetal = mkOp11 "fmmetal"+++instance  CsFmpercfl (S n)  where+  fmpercfl = mkOp11 "fmpercfl"+++instance  CsFmrhode (S n)  where+  fmrhode = mkOp11 "fmrhode"+++instance  CsFmvoice (S n)  where+  fmvoice = mkOp11 "fmvoice"+++instance  CsFmwurlie (S n)  where+  fmwurlie = mkOp11 "fmwurlie"+++instance (Varable a, Varable b, Varable c) => CsFof (S n) a b c where+  fof = mkOp12 "fof"+  fof' = mkOp15 "fof"+++instance (Varable a, Varable b, Varable c) => CsFof2 (S n) a b c where+  fof2 = mkOp14 "fof2"+  fof2' = mkOp15 "fof2"+++instance  CsFofilter (S n)  where+  fofilter = mkOp4 "fofilter"+  fofilter' = mkOp5 "fofilter"+++instance (Varable a, Varable b, Varable c) => CsFog (S n) a b c where+  fog = mkOp13 "fog"+  fog' = mkOp16 "fog"+++instance  CsFold (S n)  where+  fold = mkOp2 "fold"+++instance  CsFollow (S n)  where+  follow = mkOp2 "follow"+++instance  CsFollow2 (S n)  where+  follow2 = mkOp3 "follow2"+++instance (Varable a, Varable b, Varable c) => CsFoscil (S n) a b c where+  foscil = mkOp6 "foscil"+  foscil' = mkOp7 "foscil"+++instance (Varable a, Varable b, Varable c) => CsFoscili (S n) a b c where+  foscili = mkOp6 "foscili"+  foscili' = mkOp7 "foscili"+++instance  CsFout (S n)  where+  fout = mkOp3 "fout"+++instance  CsFouti (S n)  where+  fouti = mkOp4 "fouti"+++instance  CsFoutir (S n)  where+  foutir = mkOp4 "foutir"+++instance  CsFoutk (S n)  where+  foutk = mkOp3 "foutk"+++instance (Varable a) => CsFprintks (S n) a where+  fprintks = mkOp3 "fprintks"+++instance (Varable a) => CsFprints (S n) a where+  fprints = mkOp3 "fprints"+++instance  CsFrac (S n) (ASig (S n)) (ASig (S n)) where+  frac = mkOp1 "frac"+++instance  CsFrac (S n) (KSig (S n)) (KSig (S n)) where+  frac = mkOp1 "frac"+++instance  CsFrac (S n) (INum (S n)) (INum (S n)) where+  frac = mkOp1 "frac"+++instance  CsFreeverb (S n)  where+  freeverb = mkOp4 "freeverb"+  freeverb' = mkOp6 "freeverb"+++instance  CsFtchnls (S n)  where+  ftchnls = mkOp1 "ftchnls"+++instance (Nat d) => CsFtconv (S n) d where+  ftconv = mkOp3 "ftconv"+  ftconv' = mkOp6 "ftconv"+++instance  CsFtcps (S n)  where+  ftcps = mkOp1 "ftcps"+++instance  CsFtfree (S n)  where+  ftfree = mkOp2 "ftfree"+++instance  CsFtgen (S n)  where+  ftgen = mkOp6 "ftgen"+++instance  CsFtgenonce (S n)  where+  ftgenonce = mkOp6 "ftgenonce"+++instance  CsFtgentmp (S n)  where+  ftgentmp = mkOp6 "ftgentmp"+++instance  CsFtlen (S n)  where+  ftlen = mkOp1 "ftlen"+++instance  CsFtload (S n)  where+  ftload = mkOp3 "ftload"+++instance  CsFtloadk (S n)  where+  ftloadk = mkOp4 "ftloadk"+++instance  CsFtlptim (S n)  where+  ftlptim = mkOp1 "ftlptim"+++instance  CsFtmorf (S n)  where+  ftmorf = mkOp3 "ftmorf"+++instance  CsFtsave (S n)  where+  ftsave = mkOp3 "ftsave"+++instance  CsFtsavek (S n)  where+  ftsavek = mkOp4 "ftsavek"+++instance  CsFtsr (S n)  where+  ftsr = mkOp1 "ftsr"+++instance  CsGain (S n)  where+  gain = mkOp2 "gain"+  gain' = mkOp4 "gain"+++instance  CsGainslider (S n)  where+  gainslider = mkOp1 "gainslider"+++instance  CsGauss (S n) (ASig (S n)) where+  gauss = mkOp1 "gauss"+++instance  CsGauss (S n) (KSig (S n)) where+  gauss = mkOp1 "gauss"+++instance  CsGauss (S n) (INum (S n)) where+  gauss = mkOp1 "gauss"+++instance (Varable a, Varable b) => CsGbuzz (S n) a b where+  gbuzz = mkOp6 "gbuzz"+  gbuzz' = mkOp7 "gbuzz"+++instance  CsGetcfg (S n)  where+  getcfg = mkOp1 "getcfg"+++instance  CsGogobel (S n)  where+  gogobel = mkOp8 "gogobel"+++instance (Varable a, Varable b, Varable c) => CsGrain (S n) a b c where+  grain = mkOp9 "grain"+  grain' = mkOp10 "grain"+++instance  CsGrain2 (S n)  where+  grain2 = mkOp6 "grain2"+  grain2' = mkOp9 "grain2"+++instance  CsGrain3 (S n)  where+  grain3 = mkOp11 "grain3"+  grain3' = mkOp13 "grain3"+++instance (Varable a) => CsGranule (S n) a where+  granule = mkOp16 "granule"+  granule' = mkOp22 "granule"+++instance  CsGuiro (S n)  where+  guiro = mkOp2 "guiro"+  guiro' = mkOp7 "guiro"+++instance  CsHarmon (S n)  where+  harmon = mkOp8 "harmon"+++instance  CsHarmon2 (S n)  where+  harmon2 = mkOp6 "harmon2"+  harmon2' = mkOp7 "harmon2"+++instance  CsHarmon3 (S n)  where+  harmon3 = mkOp7 "harmon3"+  harmon3' = mkOp8 "harmon3"+++instance  CsHarmon4 (S n)  where+  harmon4 = mkOp8 "harmon4"+  harmon4' = mkOp9 "harmon4"+++instance  CsHilbert (S n)  where+  hilbert = mkOp1 "hilbert"+++instance  CsHrtfer (S n)  where+  hrtfer = mkOp4 "hrtfer"+++instance  CsHrtfmove (S n)  where+  hrtfmove = mkOp5 "hrtfmove"+  hrtfmove' = mkOp8 "hrtfmove"+++instance  CsHrtfmove2 (S n)  where+  hrtfmove2 = mkOp5 "hrtfmove2"+  hrtfmove2' = mkOp8 "hrtfmove2"+++instance  CsHrtfstat (S n)  where+  hrtfstat = mkOp5 "hrtfstat"+  hrtfstat' = mkOp7 "hrtfstat"+++instance  CsHsboscil (S n)  where+  hsboscil = mkOp6 "hsboscil"+  hsboscil' = mkOp8 "hsboscil"+++instance  CsHvs1 (S n)  where+  hvs1 = mkOp6 "hvs1"+  hvs1' = mkOp7 "hvs1"+++instance  CsHvs2 (S n)  where+  hvs2 = mkOp8 "hvs2"+  hvs2' = mkOp9 "hvs2"+++instance  CsHvs3 (S n)  where+  hvs3 = mkOp10 "hvs3"+  hvs3' = mkOp11 "hvs3"+++instance  CsICS (S n)  where+  iCS = mkOp1 "iCS"+++instance  CsIhold (S n)  where+  ihold = mkOp0 "ihold"+++instance  CsInCS (S n)  where+  inCS = mkOp0 "inCS"+++instance (Nat d) => CsInch (S n) d where+  inch = mkOp1 "inch"+++instance  CsInitc14 (S n)  where+  initc14 = mkOp4 "initc14"+++instance  CsInitc21 (S n)  where+  initc21 = mkOp5 "initc21"+++instance  CsInitc7 (S n)  where+  initc7 = mkOp3 "initc7"+++instance  CsInleta (S n)  where+  inleta = mkOp1 "inleta"+++instance  CsInletf (S n)  where+  inletf = mkOp1 "inletf"+++instance  CsInletk (S n)  where+  inletk = mkOp1 "inletk"+++instance  CsInq (S n)  where+  inq = mkOp0 "inq"+++instance  CsInrg (S n)  where+  inrg = mkOp2 "inrg"+++instance  CsIns (S n)  where+  ins = mkOp0 "ins"+++instance  CsInsglobal (S n)  where+  insglobal = mkOp2 "insglobal"+++instance  CsInsremot (S n)  where+  insremot = mkOp3 "insremot"+++instance  CsInstr (S n)  where+  instr = mkOp0 "instr"+++instance  CsInt (S n) (ASig (S n)) (ASig (S n)) where+  int = mkOp1 "int"+++instance  CsInt (S n) (KSig (S n)) (KSig (S n)) where+  int = mkOp1 "int"+++instance  CsInt (S n) (INum (S n)) (INum (S n)) where+  int = mkOp1 "int"+++instance (PVar out, Varable a) => CsInteg (S n) out a where+  integ = mkOp1 "integ"+  integ' = mkOp2 "integ"+++instance  CsInterp (S n)  where+  interp = mkOp1 "interp"+  interp' = mkOp3 "interp"+++instance  CsInvalue (S n) (KSig (S n)) where+  invalue = mkOp1 "invalue"+++instance  CsInvalue (S n) (VString (S n)) where+  invalue = mkOp1 "invalue"+++instance  CsInz (S n)  where+  inz = mkOp1 "inz"+++instance  CsJitter (S n)  where+  jitter = mkOp3 "jitter"+++instance  CsJitter2 (S n)  where+  jitter2 = mkOp7 "jitter2"+++instance (PVar out, Varable a) => CsJspline (S n) out a where+  jspline = mkOp3 "jspline"+++instance  CsKCS (S n)  where+  kCS = mkOp1 "kCS"+++instance  CsKtableseg (S n)  where+  ktableseg = mkOp4 "ktableseg"+++instance (PVar out) => CsLfo (S n) out where+  lfo = mkOp2 "lfo"+  lfo' = mkOp3 "lfo"+++instance (Varable a) => CsLimit (S n) (ASig (S n)) a where+  limit = mkOp3 "limit"+++instance (Varable a) => CsLimit (S n) (KSig (S n)) a where+  limit = mkOp3 "limit"+++instance  CsLimit (S n) (INum (S n)) (INum (S n)) where+  limit = mkOp3 "limit"+++instance (PVar out) => CsLine (S n) out where+  line = mkOp3 "line"+++instance (PVar out, Varable a) => CsLinen (S n) out a where+  linen = mkOp4 "linen"+++instance (PVar out, Varable a) => CsLinenr (S n) out a where+  linenr = mkOp4 "linenr"+++instance  CsLineto (S n)  where+  lineto = mkOp2 "lineto"+++instance  CsLinrand (S n) (ASig (S n)) where+  linrand = mkOp1 "linrand"+++instance  CsLinrand (S n) (KSig (S n)) where+  linrand = mkOp1 "linrand"+++instance  CsLinrand (S n) (INum (S n)) where+  linrand = mkOp1 "linrand"+++instance (PVar out) => CsLinseg (S n) out where+  linseg = mkOp4 "linseg"+++instance (PVar out) => CsLinsegr (S n) out where+  linsegr = mkOp4 "linsegr"+++instance (Nat d) => CsLocsend (S n) d where+  locsend = mkOp0 "locsend"+++instance (Nat d) => CsLocsig (S n) d where+  locsig = mkOp4 "locsig"+++instance  CsLog (S n) (ASig (S n)) (ASig (S n)) where+  log = mkOp1 "log"+++instance  CsLog (S n) (KSig (S n)) (KSig (S n)) where+  log = mkOp1 "log"+++instance  CsLog (S n) (INum (S n)) (INum (S n)) where+  log = mkOp1 "log"+++instance  CsLog10 (S n) (ASig (S n)) (ASig (S n)) where+  log10 = mkOp1 "log10"+++instance  CsLog10 (S n) (KSig (S n)) (KSig (S n)) where+  log10 = mkOp1 "log10"+++instance  CsLog10 (S n) (INum (S n)) (INum (S n)) where+  log10 = mkOp1 "log10"+++instance  CsLogbtwo (S n) (ASig (S n)) (ASig (S n)) where+  logbtwo = mkOp1 "logbtwo"+++instance  CsLogbtwo (S n) (KSig (S n)) (KSig (S n)) where+  logbtwo = mkOp1 "logbtwo"+++instance  CsLogbtwo (S n) (INum (S n)) (INum (S n)) where+  logbtwo = mkOp1 "logbtwo"+++instance  CsLogcurve (S n)  where+  logcurve = mkOp2 "logcurve"+++instance  CsLoopseg (S n)  where+  loopseg = mkOp4 "loopseg"+++instance  CsLoopsegp (S n)  where+  loopsegp = mkOp2 "loopsegp"+++instance  CsLooptseg (S n)  where+  looptseg = mkOp4 "looptseg"+++instance  CsLoopxseg (S n)  where+  loopxseg = mkOp4 "loopxseg"+++instance  CsLorenz (S n)  where+  lorenz = mkOp8 "lorenz"+  lorenz' = mkOp9 "lorenz"+++instance  CsLorismorph (S n)  where+  lorismorph = mkOp6 "lorismorph"+++instance  CsLorisplay (S n)  where+  lorisplay = mkOp4 "lorisplay"+++instance  CsLorisread (S n)  where+  lorisread = mkOp6 "lorisread"+  lorisread' = mkOp7 "lorisread"+++instance (Nat d, Varable a) => CsLoscil (S n) d a where+  loscil = mkOp3 "loscil"+  loscil' = mkOp10 "loscil"+++instance (Nat d, Varable a) => CsLoscil3 (S n) d a where+  loscil3 = mkOp3 "loscil3"+  loscil3' = mkOp10 "loscil3"+++instance (Nat d, Varable a) => CsLoscilx (S n) d a where+  loscilx = mkOp3 "loscilx"+  loscilx' = mkOp9 "loscilx"+++instance  CsLowpass2 (S n)  where+  lowpass2 = mkOp3 "lowpass2"+  lowpass2' = mkOp4 "lowpass2"+++instance  CsLowres (S n)  where+  lowres = mkOp3 "lowres"+  lowres' = mkOp4 "lowres"+++instance  CsLowresx (S n)  where+  lowresx = mkOp3 "lowresx"+  lowresx' = mkOp5 "lowresx"+++instance  CsLpf18 (S n)  where+  lpf18 = mkOp4 "lpf18"+++instance  CsLpform (S n)  where+  lpform = mkOp1 "lpform"+++instance  CsLpfreson (S n)  where+  lpfreson = mkOp2 "lpfreson"+++instance (Varable a) => CsLphasor (S n) a where+  lphasor = mkOp1 "lphasor"+  lphasor' = mkOp8 "lphasor"+++instance  CsLpinterp (S n)  where+  lpinterp = mkOp3 "lpinterp"+++instance  CsLposcil (S n)  where+  lposcil = mkOp5 "lposcil"+  lposcil' = mkOp6 "lposcil"+++instance  CsLposcil3 (S n)  where+  lposcil3 = mkOp5 "lposcil3"+  lposcil3' = mkOp6 "lposcil3"+++instance  CsLposcila (S n)  where+  lposcila = mkOp5 "lposcila"+  lposcila' = mkOp6 "lposcila"+++instance  CsLposcilsa (S n)  where+  lposcilsa = mkOp5 "lposcilsa"+  lposcilsa' = mkOp6 "lposcilsa"+++instance  CsLposcilsa2 (S n)  where+  lposcilsa2 = mkOp5 "lposcilsa2"+  lposcilsa2' = mkOp6 "lposcilsa2"+++instance  CsLpread (S n)  where+  lpread = mkOp2 "lpread"+  lpread' = mkOp4 "lpread"+++instance  CsLpreson (S n)  where+  lpreson = mkOp1 "lpreson"+++instance  CsLpshold (S n)  where+  lpshold = mkOp4 "lpshold"+++instance  CsLpsholdp (S n)  where+  lpsholdp = mkOp2 "lpsholdp"+++instance  CsLpslot (S n)  where+  lpslot = mkOp1 "lpslot"+++instance  CsMac (S n)  where+  mac = mkOp1 "mac"+++instance  CsMaca (S n)  where+  maca = mkOp1 "maca"+++instance (PVar out) => CsMadsr (S n) out where+  madsr = mkOp4 "madsr"+  madsr' = mkOp6 "madsr"+++instance  CsMandel (S n)  where+  mandel = mkOp4 "mandel"+++instance  CsMandol (S n)  where+  mandol = mkOp7 "mandol"+  mandol' = mkOp8 "mandol"+++instance  CsMarimba (S n)  where+  marimba = mkOp9 "marimba"+  marimba' = mkOp11 "marimba"+++instance  CsMassign (S n)  where+  massign = mkOp2 "massign"+  massign' = mkOp3 "massign"+++instance  CsMax_k (S n)  where+  max_k = mkOp3 "max_k"+++instance  CsMaxabsaccum (S n)  where+  maxabsaccum = mkOp2 "maxabsaccum"+++instance  CsMaxaccum (S n)  where+  maxaccum = mkOp2 "maxaccum"+++instance  CsMaxalloc (S n)  where+  maxalloc = mkOp2 "maxalloc"+++instance  CsMaxk (S n)  where+  maxk = mkOp3 "maxk"+++instance  CsMclock (S n)  where+  mclock = mkOp1 "mclock"+++instance  CsMdelay (S n)  where+  mdelay = mkOp5 "mdelay"+++instance  CsMedian (S n)  where+  median = mkOp3 "median"+  median' = mkOp4 "median"+++instance  CsMediank (S n)  where+  mediank = mkOp3 "mediank"+  mediank' = mkOp4 "mediank"+++instance  CsMetro (S n)  where+  metro = mkOp1 "metro"+  metro' = mkOp2 "metro"+++instance  CsMidglobal (S n)  where+  midglobal = mkOp2 "midglobal"+++instance  CsMidic14 (S n) (KSig (S n)) where+  midic14 = mkOp4 "midic14"+  midic14' = mkOp5 "midic14"+++instance  CsMidic14 (S n) (INum (S n)) where+  midic14 = mkOp4 "midic14"+  midic14' = mkOp5 "midic14"+++instance  CsMidic21 (S n) (KSig (S n)) where+  midic21 = mkOp5 "midic21"+  midic21' = mkOp6 "midic21"+++instance  CsMidic21 (S n) (INum (S n)) where+  midic21 = mkOp5 "midic21"+  midic21' = mkOp6 "midic21"+++instance  CsMidic7 (S n) (KSig (S n)) where+  midic7 = mkOp3 "midic7"+  midic7' = mkOp4 "midic7"+++instance  CsMidic7 (S n) (INum (S n)) where+  midic7 = mkOp3 "midic7"+  midic7' = mkOp4 "midic7"+++instance (Varable a) => CsMidichannelaftertouch (S n) a where+  midichannelaftertouch = mkOp1 "midichannelaftertouch"+  midichannelaftertouch' = mkOp3 "midichannelaftertouch"+++instance  CsMidichn (S n)  where+  midichn = mkOp0 "midichn"+++instance (Varable a, Varable b) => CsMidicontrolchange (S n) a b where+  midicontrolchange = mkOp2 "midicontrolchange"+  midicontrolchange' = mkOp4 "midicontrolchange"+++instance  CsMidictrl (S n) (KSig (S n)) where+  midictrl = mkOp1 "midictrl"+  midictrl' = mkOp3 "midictrl"+++instance  CsMidictrl (S n) (INum (S n)) where+  midictrl = mkOp1 "midictrl"+  midictrl' = mkOp3 "midictrl"+++instance (Varable a, Varable b) => CsMididefault (S n) a b where+  mididefault = mkOp2 "mididefault"+++instance  CsMidiin (S n)  where+  midiin = mkOp0 "midiin"+++instance (Varable a, Varable b) => CsMidinoteoff (S n) a b where+  midinoteoff = mkOp2 "midinoteoff"+++instance (Varable a, Varable b) => CsMidinoteoncps (S n) a b where+  midinoteoncps = mkOp2 "midinoteoncps"+++instance (Varable a, Varable b) => CsMidinoteonkey (S n) a b where+  midinoteonkey = mkOp2 "midinoteonkey"+++instance (Varable a, Varable b) => CsMidinoteonoct (S n) a b where+  midinoteonoct = mkOp2 "midinoteonoct"+++instance (Varable a, Varable b) => CsMidinoteonpch (S n) a b where+  midinoteonpch = mkOp2 "midinoteonpch"+++instance  CsMidion (S n)  where+  midion = mkOp3 "midion"+++instance  CsMidion2 (S n)  where+  midion2 = mkOp4 "midion2"+++instance  CsMidiout (S n)  where+  midiout = mkOp4 "midiout"+++instance  CsMidipgm (S n)  where+  midipgm = mkOp0 "midipgm"+  midipgm' = mkOp1 "midipgm"+++instance (Varable a) => CsMidipitchbend (S n) a where+  midipitchbend = mkOp1 "midipitchbend"+  midipitchbend' = mkOp3 "midipitchbend"+++instance (Varable a, Varable b) => CsMidipolyaftertouch (S n) a b where+  midipolyaftertouch = mkOp2 "midipolyaftertouch"+  midipolyaftertouch' = mkOp4 "midipolyaftertouch"+++instance (Varable a) => CsMidiprogramchange (S n) a where+  midiprogramchange = mkOp1 "midiprogramchange"+++instance  CsMiditempo (S n)  where+  miditempo = mkOp0 "miditempo"+++instance  CsMidremot (S n)  where+  midremot = mkOp3 "midremot"+++instance  CsMinabsaccum (S n)  where+  minabsaccum = mkOp2 "minabsaccum"+++instance  CsMinaccum (S n)  where+  minaccum = mkOp2 "minaccum"+++instance (Nat d) => CsMincer (S n) d where+  mincer = mkOp5 "mincer"+  mincer' = mkOp7 "mincer"+++instance  CsMirror (S n) (ASig (S n)) (ASig (S n)) where+  mirror = mkOp3 "mirror"+++instance  CsMirror (S n) (KSig (S n)) (KSig (S n)) where+  mirror = mkOp3 "mirror"+++instance  CsMirror (S n) (INum (S n)) (INum (S n)) where+  mirror = mkOp3 "mirror"+++instance (Varable a, Varable b) => CsMod (S n) (ASig (S n)) a b where+  mod = mkOp2 "mod"+++instance  CsMod (S n) (KSig (S n)) (KSig (S n)) (KSig (S n)) where+  mod = mkOp2 "mod"+++instance  CsMod (S n) (INum (S n)) (INum (S n)) (INum (S n)) where+  mod = mkOp2 "mod"+++instance  CsMode (S n)  where+  mode = mkOp3 "mode"+  mode' = mkOp4 "mode"+++instance  CsModmatrix (S n)  where+  modmatrix = mkOp7 "modmatrix"+++instance (Nat d) => CsMonitor (S n) d where+  monitor = mkOp0 "monitor"+++instance  CsMoog (S n)  where+  moog = mkOp9 "moog"+++instance  CsMoogladder (S n)  where+  moogladder = mkOp3 "moogladder"+  moogladder' = mkOp4 "moogladder"+++instance (Varable a, Varable b) => CsMoogvcf (S n) a b where+  moogvcf = mkOp3 "moogvcf"+  moogvcf' = mkOp5 "moogvcf"+++instance (Varable a, Varable b) => CsMoogvcf2 (S n) a b where+  moogvcf2 = mkOp3 "moogvcf2"+  moogvcf2' = mkOp5 "moogvcf2"+++instance  CsMoscil (S n)  where+  moscil = mkOp5 "moscil"+++instance  CsMpulse (S n)  where+  mpulse = mkOp2 "mpulse"+  mpulse' = mkOp3 "mpulse"+++instance  CsMrtmsg (S n)  where+  mrtmsg = mkOp1 "mrtmsg"+++instance (Varable a, Varable b) => CsMul (S n) (ASig (S n)) a b where+  mul = mkOp2 "mul"+++instance  CsMul (S n) (KSig (S n)) (KSig (S n)) (KSig (S n)) where+  mul = mkOp2 "mul"+++instance  CsMul (S n) (INum (S n)) (INum (S n)) (INum (S n)) where+  mul = mkOp2 "mul"+++instance  CsMultitap (S n)  where+  multitap = mkOp2 "multitap"+++instance  CsMute (S n)  where+  mute = mkOp1 "mute"+  mute' = mkOp2 "mute"+++instance  CsMutex_lock (S n)  where+  mutex_lock = mkOp1 "mutex_lock"+++instance  CsMutex_locki (S n)  where+  mutex_locki = mkOp1 "mutex_locki"+++instance  CsMutex_unlock (S n)  where+  mutex_unlock = mkOp1 "mutex_unlock"+++instance  CsMutex_unlocki (S n)  where+  mutex_unlocki = mkOp1 "mutex_unlocki"+++instance (PVar out) => CsMxadsr (S n) out where+  mxadsr = mkOp4 "mxadsr"+  mxadsr' = mkOp6 "mxadsr"+++instance  CsNestedap (S n)  where+  nestedap = mkOp5 "nestedap"+  nestedap' = mkOp10 "nestedap"+++instance  CsNlalp (S n)  where+  nlalp = mkOp3 "nlalp"+  nlalp' = mkOp5 "nlalp"+++instance  CsNlfilt (S n)  where+  nlfilt = mkOp6 "nlfilt"+++instance (Varable a) => CsNoise (S n) a where+  noise = mkOp2 "noise"+++instance  CsNot (S n) (ASig (S n)) (ASig (S n)) where+  not = mkOp1 "not"+++instance  CsNot (S n) (KSig (S n)) (KSig (S n)) where+  not = mkOp1 "not"+++instance  CsNot (S n) (INum (S n)) (INum (S n)) where+  not = mkOp1 "not"+++instance  CsNoteoff (S n)  where+  noteoff = mkOp3 "noteoff"+++instance  CsNoteon (S n)  where+  noteon = mkOp3 "noteon"+++instance  CsNoteondur (S n)  where+  noteondur = mkOp4 "noteondur"+++instance  CsNoteondur2 (S n)  where+  noteondur2 = mkOp4 "noteondur2"+++instance  CsNotnum (S n)  where+  notnum = mkOp0 "notnum"+++instance  CsNreverb (S n)  where+  nreverb = mkOp3 "nreverb"+  nreverb' = mkOp8 "nreverb"+++instance  CsNrpn (S n)  where+  nrpn = mkOp3 "nrpn"+++instance  CsNsamp (S n)  where+  nsamp = mkOp1 "nsamp"+++instance  CsNstrnum (S n)  where+  nstrnum = mkOp1 "nstrnum"+++instance  CsNtrpol (S n) (ASig (S n)) (ASig (S n)) (ASig (S n)) where+  ntrpol = mkOp3 "ntrpol"+  ntrpol' = mkOp5 "ntrpol"+++instance  CsNtrpol (S n) (KSig (S n)) (KSig (S n)) (KSig (S n)) where+  ntrpol = mkOp3 "ntrpol"+  ntrpol' = mkOp5 "ntrpol"+++instance  CsNtrpol (S n) (INum (S n)) (INum (S n)) (INum (S n)) where+  ntrpol = mkOp3 "ntrpol"+  ntrpol' = mkOp5 "ntrpol"+++instance  CsOctave (S n) (ASig (S n)) (ASig (S n)) where+  octave = mkOp1 "octave"+++instance  CsOctave (S n) (KSig (S n)) (KSig (S n)) where+  octave = mkOp1 "octave"+++instance  CsOctave (S n) (INum (S n)) (INum (S n)) where+  octave = mkOp1 "octave"+++instance  CsOctcps (S n) (KSig (S n)) where+  octcps = mkOp1 "octcps"+++instance  CsOctcps (S n) (INum (S n)) where+  octcps = mkOp1 "octcps"+++instance  CsOctmidi (S n)  where+  octmidi = mkOp0 "octmidi"+++instance  CsOctmidib (S n) (KSig (S n)) where+  octmidib = mkOp0 "octmidib"+  octmidib' = mkOp1 "octmidib"+++instance  CsOctmidib (S n) (INum (S n)) where+  octmidib = mkOp0 "octmidib"+  octmidib' = mkOp1 "octmidib"+++instance  CsOctmidinn (S n) (KSig (S n)) where+  octmidinn = mkOp1 "octmidinn"+++instance  CsOctmidinn (S n) (INum (S n)) where+  octmidinn = mkOp1 "octmidinn"+++instance  CsOctpch (S n) (KSig (S n)) where+  octpch = mkOp1 "octpch"+++instance  CsOctpch (S n) (INum (S n)) where+  octpch = mkOp1 "octpch"+++instance  CsOpcode (S n)  where+  opcode = mkOp0 "opcode"+++instance (Varable a, Varable b) => CsOr (S n) (ASig (S n)) a b where+  or = mkOp2 "or"+++instance  CsOr (S n) (KSig (S n)) (KSig (S n)) (KSig (S n)) where+  or = mkOp2 "or"+++instance  CsOr (S n) (INum (S n)) (INum (S n)) (INum (S n)) where+  or = mkOp2 "or"+++instance  CsOscbnk (S n)  where+  oscbnk = mkOp19 "oscbnk"+  oscbnk' = mkOp26 "oscbnk"+++instance (Varable a, Varable b) => CSE.CsOscil (S n) (ASig (S n)) a b where+  oscil = mkOp3 "oscil"+  oscil' = mkOp4 "oscil"+++instance (PVar out) => CSE.CsOscil (S n) out (KSig (S n)) (KSig (S n)) where+  oscil = mkOp3 "oscil"+  oscil' = mkOp4 "oscil"+++instance  CsOscil1 (S n)  where+  oscil1 = mkOp4 "oscil1"+++instance  CsOscil1i (S n)  where+  oscil1i = mkOp4 "oscil1i"+++instance (Varable a, Varable b) => CsOscil3 (S n) (ASig (S n)) a b where+  oscil3 = mkOp3 "oscil3"+  oscil3' = mkOp4 "oscil3"+++instance (PVar out) => CsOscil3 (S n) out (KSig (S n)) (KSig (S n)) where+  oscil3 = mkOp3 "oscil3"+  oscil3' = mkOp4 "oscil3"+++instance (Varable a, Varable b) => CSE.CsOscili (S n) (ASig (S n)) a b where+  oscili = mkOp3 "oscili"+  oscili' = mkOp4 "oscili"+++instance (PVar out) => CSE.CsOscili (S n) out (KSig (S n)) (KSig (S n)) where+  oscili = mkOp3 "oscili"+  oscili' = mkOp4 "oscili"+++instance (Varable a, Varable b) => CsOscilikt (S n) (ASig (S n)) a b where+  oscilikt = mkOp3 "oscilikt"+  oscilikt' = mkOp5 "oscilikt"+++instance (PVar out) => CsOscilikt (S n) out (KSig (S n)) (KSig (S n)) where+  oscilikt = mkOp3 "oscilikt"+  oscilikt' = mkOp5 "oscilikt"+++instance  CsOsciliktp (S n)  where+  osciliktp = mkOp3 "osciliktp"+  osciliktp' = mkOp4 "osciliktp"+++instance (Varable a, Varable b) => CsOscilikts (S n) a b where+  oscilikts = mkOp5 "oscilikts"+  oscilikts' = mkOp6 "oscilikts"+++instance  CsOsciln (S n)  where+  osciln = mkOp4 "osciln"+++instance  CsOscils (S n)  where+  oscils = mkOp3 "oscils"+  oscils' = mkOp4 "oscils"+++instance  CsOscilx (S n)  where+  oscilx = mkOp4 "oscilx"+++instance  CsOut32 (S n)  where+  out32 = mkOp32 "out32"+++instance  CsOutc (S n)  where+  outc = mkOp1 "outc"+++instance  CsOutch (S n)  where+  outch = mkOp1 "outch"+++instance  CsOuth (S n)  where+  outh = mkOp6 "outh"+++instance  CsOutiat (S n)  where+  outiat = mkOp4 "outiat"+++instance  CsOutic (S n)  where+  outic = mkOp5 "outic"+++instance  CsOutic14 (S n)  where+  outic14 = mkOp6 "outic14"+++instance  CsOutipat (S n)  where+  outipat = mkOp5 "outipat"+++instance  CsOutipb (S n)  where+  outipb = mkOp4 "outipb"+++instance  CsOutipc (S n)  where+  outipc = mkOp4 "outipc"+++instance  CsOutkat (S n)  where+  outkat = mkOp4 "outkat"+++instance  CsOutkc (S n)  where+  outkc = mkOp5 "outkc"+++instance  CsOutkc14 (S n)  where+  outkc14 = mkOp6 "outkc14"+++instance  CsOutkpat (S n)  where+  outkpat = mkOp5 "outkpat"+++instance  CsOutkpb (S n)  where+  outkpb = mkOp4 "outkpb"+++instance  CsOutkpc (S n)  where+  outkpc = mkOp4 "outkpc"+++instance  CsOutleta (S n)  where+  outleta = mkOp2 "outleta"+++instance  CsOutletf (S n)  where+  outletf = mkOp2 "outletf"+++instance  CsOutletk (S n)  where+  outletk = mkOp2 "outletk"+++instance  CsOutq1 (S n)  where+  outq1 = mkOp1 "outq1"+++instance  CsOutq2 (S n)  where+  outq2 = mkOp1 "outq2"+++instance  CsOutq3 (S n)  where+  outq3 = mkOp1 "outq3"+++instance  CsOutq4 (S n)  where+  outq4 = mkOp1 "outq4"+++instance  CsOutrg (S n)  where+  outrg = mkOp2 "outrg"+++instance  CsOuts1 (S n)  where+  outs1 = mkOp1 "outs1"+++instance  CsOuts2 (S n)  where+  outs2 = mkOp1 "outs2"+++instance  CsOutx (S n)  where+  outx = mkOp16 "outx"+++instance  CsOutz (S n)  where+  outz = mkOp1 "outz"+++instance  CsP (S n) (KSig (S n)) where+  p = mkOp1 "p"+++instance  CsP (S n) (INum (S n)) where+  p = mkOp1 "p"+++instance  CsPan (S n)  where+  pan = mkOp4 "pan"+  pan' = mkOp6 "pan"+++instance (Varable a) => CsPan2 (S n) a where+  pan2 = mkOp2 "pan2"+  pan2' = mkOp3 "pan2"+++instance  CsPareq (S n)  where+  pareq = mkOp4 "pareq"+  pareq' = mkOp6 "pareq"+++instance  CsPartials (S n)  where+  partials = mkOp6 "partials"+++instance  CsPcauchy (S n) (ASig (S n)) where+  pcauchy = mkOp1 "pcauchy"+++instance  CsPcauchy (S n) (KSig (S n)) where+  pcauchy = mkOp1 "pcauchy"+++instance  CsPcauchy (S n) (INum (S n)) where+  pcauchy = mkOp1 "pcauchy"+++instance  CsPchbend (S n) (KSig (S n)) where+  pchbend = mkOp0 "pchbend"+  pchbend' = mkOp2 "pchbend"+++instance  CsPchbend (S n) (INum (S n)) where+  pchbend = mkOp0 "pchbend"+  pchbend' = mkOp2 "pchbend"+++instance  CsPchmidi (S n)  where+  pchmidi = mkOp0 "pchmidi"+++instance  CsPchmidib (S n) (KSig (S n)) where+  pchmidib = mkOp0 "pchmidib"+  pchmidib' = mkOp1 "pchmidib"+++instance  CsPchmidib (S n) (INum (S n)) where+  pchmidib = mkOp0 "pchmidib"+  pchmidib' = mkOp1 "pchmidib"+++instance  CsPchmidinn (S n) (KSig (S n)) where+  pchmidinn = mkOp1 "pchmidinn"+++instance  CsPchmidinn (S n) (INum (S n)) where+  pchmidinn = mkOp1 "pchmidinn"+++instance  CsPchoct (S n) (KSig (S n)) where+  pchoct = mkOp1 "pchoct"+++instance  CsPchoct (S n) (INum (S n)) where+  pchoct = mkOp1 "pchoct"+++instance (Nat d) => CsPconvolve (S n) d where+  pconvolve = mkOp2 "pconvolve"+  pconvolve' = mkOp4 "pconvolve"+++instance  CsPcount (S n)  where+  pcount = mkOp0 "pcount"+++instance  CsPdclip (S n)  where+  pdclip = mkOp3 "pdclip"+  pdclip' = mkOp5 "pdclip"+++instance  CsPdhalf (S n)  where+  pdhalf = mkOp2 "pdhalf"+  pdhalf' = mkOp4 "pdhalf"+++instance  CsPdhalfy (S n)  where+  pdhalfy = mkOp2 "pdhalfy"+  pdhalfy' = mkOp4 "pdhalfy"+++instance (Varable a) => CsPeak (S n) a where+  peak = mkOp1 "peak"+++instance  CsPgmassign (S n)  where+  pgmassign = mkOp2 "pgmassign"+  pgmassign' = mkOp3 "pgmassign"+++instance  CsPgmchn (S n)  where+  pgmchn = mkOp0 "pgmchn"+  pgmchn' = mkOp1 "pgmchn"+++instance  CsPhaser1 (S n)  where+  phaser1 = mkOp4 "phaser1"+  phaser1' = mkOp5 "phaser1"+++instance  CsPhaser2 (S n)  where+  phaser2 = mkOp7 "phaser2"+++instance (PVar out, Varable a) => CsPhasorbnk (S n) out a where+  phasorbnk = mkOp3 "phasorbnk"+  phasorbnk' = mkOp4 "phasorbnk"+++instance  CsPindex (S n)  where+  pindex = mkOp1 "pindex"+++instance (Varable a) => CsPinkish (S n) a where+  pinkish = mkOp1 "pinkish"+  pinkish' = mkOp5 "pinkish"+++instance  CsPitch (S n)  where+  pitch = mkOp5 "pitch"+  pitch' = mkOp13 "pitch"+++instance  CsPitchac (S n)  where+  pitchac = mkOp4 "pitchac"+++instance  CsPitchamdf (S n)  where+  pitchamdf = mkOp3 "pitchamdf"+  pitchamdf' = mkOp8 "pitchamdf"+++instance  CsPlanet (S n)  where+  planet = mkOp10 "planet"+  planet' = mkOp12 "planet"+++instance  CsPluck (S n)  where+  pluck = mkOp5 "pluck"+  pluck' = mkOp7 "pluck"+++instance  CsPoisson (S n) (ASig (S n)) where+  poisson = mkOp1 "poisson"+++instance  CsPoisson (S n) (KSig (S n)) where+  poisson = mkOp1 "poisson"+++instance  CsPoisson (S n) (INum (S n)) where+  poisson = mkOp1 "poisson"+++instance  CsPolyaft (S n) (KSig (S n)) where+  polyaft = mkOp1 "polyaft"+  polyaft' = mkOp3 "polyaft"+++instance  CsPolyaft (S n) (INum (S n)) where+  polyaft = mkOp1 "polyaft"+  polyaft' = mkOp3 "polyaft"+++instance  CsPolynomial (S n)  where+  polynomial = mkOp2 "polynomial"+++instance  CsPop_f (S n)  where+  pop_f = mkOp0 "pop_f"+++instance  CsPort (S n)  where+  port = mkOp2 "port"+  port' = mkOp3 "port"+++instance  CsPortk (S n)  where+  portk = mkOp2 "portk"+  portk' = mkOp3 "portk"+++instance (Varable a, Varable b) => CsPoscil (S n) (ASig (S n)) a b where+  poscil = mkOp3 "poscil"+  poscil' = mkOp4 "poscil"+++instance (PVar out) => CsPoscil (S n) out (KSig (S n)) (KSig (S n)) where+  poscil = mkOp3 "poscil"+  poscil' = mkOp4 "poscil"+++instance (PVar out) => CsPoscil3 (S n) out where+  poscil3 = mkOp3 "poscil3"+  poscil3' = mkOp4 "poscil3"+++instance  CsPow (S n) (ASig (S n)) (ASig (S n)) where+  pow = mkOp2 "pow"+  pow' = mkOp3 "pow"+++instance  CsPow (S n) (KSig (S n)) (KSig (S n)) where+  pow = mkOp2 "pow"+  pow' = mkOp3 "pow"+++instance  CsPow (S n) (INum (S n)) (INum (S n)) where+  pow = mkOp2 "pow"+  pow' = mkOp3 "pow"+++instance  CsPowershape (S n)  where+  powershape = mkOp2 "powershape"+  powershape' = mkOp3 "powershape"+++instance  CsPowoftwo (S n) (ASig (S n)) (ASig (S n)) where+  powoftwo = mkOp1 "powoftwo"+++instance  CsPowoftwo (S n) (KSig (S n)) (KSig (S n)) where+  powoftwo = mkOp1 "powoftwo"+++instance  CsPowoftwo (S n) (INum (S n)) (INum (S n)) where+  powoftwo = mkOp1 "powoftwo"+++instance  CsPrealloc (S n)  where+  prealloc = mkOp2 "prealloc"+  prealloc' = mkOp3 "prealloc"+++instance (Nat d) => CsPrepiano (S n) d where+  prepiano = mkOp15 "prepiano"+  prepiano' = mkOp17 "prepiano"+++instance  CsPrint (S n)  where+  print = mkOp1 "print"+++instance  CsPrintf_i (S n)  where+  printf_i = mkOp4 "printf_i"+++instance  CsPrintk (S n)  where+  printk = mkOp2 "printk"+  printk' = mkOp3 "printk"+++instance  CsPrintk2 (S n)  where+  printk2 = mkOp1 "printk2"+  printk2' = mkOp2 "printk2"+++instance (Varable a) => CsPrintks (S n) a where+  printks = mkOp3 "printks"+++instance (Varable a) => CsPrints (S n) a where+  prints = mkOp2 "prints"+++instance  CsProduct (S n)  where+  product = mkOp1 "product"+++instance  CsPset (S n)  where+  pset = mkOp1 "pset"+++instance  CsPtrack (S n)  where+  ptrack = mkOp2 "ptrack"+  ptrack' = mkOp3 "ptrack"+++instance  CsPush (S n)  where+  push = mkOp1 "push"+++instance  CsPush_f (S n)  where+  push_f = mkOp1 "push_f"+++instance  CsPuts (S n)  where+  puts = mkOp2 "puts"+  puts' = mkOp3 "puts"+++instance  CsPvadd (S n)  where+  pvadd = mkOp5 "pvadd"+  pvadd' = mkOp10 "pvadd"+++instance  CsPvbufread (S n)  where+  pvbufread = mkOp2 "pvbufread"+++instance  CsPvcross (S n)  where+  pvcross = mkOp5 "pvcross"+  pvcross' = mkOp6 "pvcross"+++instance  CsPvinterp (S n)  where+  pvinterp = mkOp9 "pvinterp"+++instance  CsPvoc (S n)  where+  pvoc = mkOp3 "pvoc"+  pvoc' = mkOp7 "pvoc"+++instance  CsPvread (S n)  where+  pvread = mkOp3 "pvread"+++instance  CsPvsadsyn (S n)  where+  pvsadsyn = mkOp3 "pvsadsyn"+  pvsadsyn' = mkOp6 "pvsadsyn"+++instance  CsPvsanal (S n)  where+  pvsanal = mkOp5 "pvsanal"+  pvsanal' = mkOp7 "pvsanal"+++instance  CsPvsarp (S n)  where+  pvsarp = mkOp4 "pvsarp"+++instance (Varable a, Varable b, Varable c, Varable d, KVar e) => CsPvsbandp (S n) a b c d e where+  pvsbandp = mkOp5 "pvsbandp"+  pvsbandp' = mkOp6 "pvsbandp"+++instance (Varable a, Varable b, Varable c, Varable d, KVar e) => CsPvsbandr (S n) a b c d e where+  pvsbandr = mkOp5 "pvsbandr"+  pvsbandr' = mkOp6 "pvsbandr"+++instance (PVar out) => CsPvsbin (S n) out where+  pvsbin = mkOp2 "pvsbin"+++instance  CsPvsblur (S n)  where+  pvsblur = mkOp3 "pvsblur"+++instance  CsPvsbuffer (S n)  where+  pvsbuffer = mkOp2 "pvsbuffer"+++instance (KVar a, KVar b) => CsPvsbufread (S n) a b where+  pvsbufread = mkOp2 "pvsbufread"+  pvsbufread' = mkOp5 "pvsbufread"+++instance (PVar out) => CsPvscent (S n) out where+  pvscent = mkOp1 "pvscent"+++instance  CsPvscross (S n)  where+  pvscross = mkOp4 "pvscross"+++instance  CsPvsdemix (S n)  where+  pvsdemix = mkOp5 "pvsdemix"+++instance  CsPvsdisp (S n)  where+  pvsdisp = mkOp1 "pvsdisp"+  pvsdisp' = mkOp3 "pvsdisp"+++instance (Varable a) => CsPvsfilter (S n) a where+  pvsfilter = mkOp3 "pvsfilter"+  pvsfilter' = mkOp4 "pvsfilter"+++instance  CsPvsfread (S n)  where+  pvsfread = mkOp2 "pvsfread"+  pvsfread' = mkOp3 "pvsfread"+++instance  CsPvsfreeze (S n)  where+  pvsfreeze = mkOp3 "pvsfreeze"+++instance  CsPvsftr (S n)  where+  pvsftr = mkOp2 "pvsftr"+  pvsftr' = mkOp3 "pvsftr"+++instance  CsPvsftw (S n)  where+  pvsftw = mkOp2 "pvsftw"+  pvsftw' = mkOp3 "pvsftw"+++instance  CsPvsfwrite (S n)  where+  pvsfwrite = mkOp2 "pvsfwrite"+++instance (Varable a, KVar b, KVar c, KVar d) => CsPvshift (S n) a b c d where+  pvshift = mkOp3 "pvshift"+  pvshift' = mkOp6 "pvshift"+++instance  CsPvsifd (S n)  where+  pvsifd = mkOp4 "pvsifd"+  pvsifd' = mkOp5 "pvsifd"+++instance  CsPvsin (S n)  where+  pvsin = mkOp1 "pvsin"+  pvsin' = mkOp6 "pvsin"+++instance  CsPvsinfo (S n)  where+  pvsinfo = mkOp1 "pvsinfo"+++instance  CsPvsinit (S n)  where+  pvsinit = mkOp1 "pvsinit"+  pvsinit' = mkOp5 "pvsinit"+++instance  CsPvslock (S n)  where+  pvslock = mkOp2 "pvslock"+++instance  CsPvsmaska (S n)  where+  pvsmaska = mkOp3 "pvsmaska"+++instance  CsPvsmix (S n)  where+  pvsmix = mkOp2 "pvsmix"+++instance (Varable a, Varable b) => CsPvsmooth (S n) a b where+  pvsmooth = mkOp3 "pvsmooth"+++instance  CsPvsmorph (S n)  where+  pvsmorph = mkOp4 "pvsmorph"+++instance  CsPvsosc (S n)  where+  pvsosc = mkOp4 "pvsosc"+  pvsosc' = mkOp8 "pvsosc"+++instance  CsPvsout (S n)  where+  pvsout = mkOp2 "pvsout"+++instance  CsPvspitch (S n)  where+  pvspitch = mkOp2 "pvspitch"+++instance  CsPvstencil (S n)  where+  pvstencil = mkOp4 "pvstencil"+++instance (KVar a) => CsPvsvoc (S n) a where+  pvsvoc = mkOp4 "pvsvoc"+  pvsvoc' = mkOp5 "pvsvoc"+++instance  CsPvsynth (S n)  where+  pvsynth = mkOp1 "pvsynth"+  pvsynth' = mkOp2 "pvsynth"+++instance (PVar out, Varable a) => CsRand (S n) out a where+  rand = mkOp1 "rand"+  rand' = mkOp4 "rand"+++instance (PVar out, Varable a, Varable b) => CsRandh (S n) out a b where+  randh = mkOp2 "randh"+  randh' = mkOp5 "randh"+++instance (PVar out, Varable a, Varable b) => CsRandi (S n) out a b where+  randi = mkOp2 "randi"+  randi' = mkOp5 "randi"+++instance  CsRandom (S n) (ASig (S n)) where+  random = mkOp2 "random"+++instance  CsRandom (S n) (KSig (S n)) where+  random = mkOp2 "random"+++instance  CsRandom (S n) (INum (S n)) where+  random = mkOp2 "random"+++instance (PVar out, Varable a) => CsRandomh (S n) out a where+  randomh = mkOp3 "randomh"+++instance (PVar out, Varable a) => CsRandomi (S n) out a where+  randomi = mkOp3 "randomi"+++instance  CsRbjeq (S n)  where+  rbjeq = mkOp5 "rbjeq"+  rbjeq' = mkOp6 "rbjeq"+++instance  CsReadclock (S n)  where+  readclock = mkOp1 "readclock"+++instance  CsReadk (S n)  where+  readk = mkOp3 "readk"+++instance  CsReadk2 (S n)  where+  readk2 = mkOp3 "readk2"+++instance  CsReadk3 (S n)  where+  readk3 = mkOp3 "readk3"+++instance  CsReadk4 (S n)  where+  readk4 = mkOp3 "readk4"+++instance  CsReadks (S n)  where+  readks = mkOp2 "readks"+++instance  CsRelease (S n)  where+  release = mkOp0 "release"+++instance  CsRemoteport (S n)  where+  remoteport = mkOp1 "remoteport"+++instance  CsRemove (S n)  where+  remove = mkOp1 "remove"+++instance  CsRepluck (S n)  where+  repluck = mkOp6 "repluck"+++instance  CsReson (S n)  where+  reson = mkOp3 "reson"+  reson' = mkOp5 "reson"+++instance  CsResonk (S n)  where+  resonk = mkOp3 "resonk"+  resonk' = mkOp5 "resonk"+++instance  CsResonr (S n)  where+  resonr = mkOp3 "resonr"+  resonr' = mkOp5 "resonr"+++instance  CsResonx (S n)  where+  resonx = mkOp3 "resonx"+  resonx' = mkOp6 "resonx"+++instance  CsResonxk (S n)  where+  resonxk = mkOp3 "resonxk"+  resonxk' = mkOp6 "resonxk"+++instance  CsResony (S n)  where+  resony = mkOp5 "resony"+  resony' = mkOp8 "resony"+++instance  CsResonz (S n)  where+  resonz = mkOp3 "resonz"+  resonz' = mkOp5 "resonz"+++instance  CsResyn (S n)  where+  resyn = mkOp5 "resyn"+++instance  CsReverb (S n)  where+  reverb = mkOp2 "reverb"+  reverb' = mkOp3 "reverb"+++instance  CsReverb2 (S n)  where+  reverb2 = mkOp3 "reverb2"+  reverb2' = mkOp8 "reverb2"+++instance  CsReverbsc (S n)  where+  reverbsc = mkOp4 "reverbsc"+  reverbsc' = mkOp7 "reverbsc"+++instance  CsRewindscore (S n)  where+  rewindscore = mkOp0 "rewindscore"+++instance (Varable a, Varable b) => CsRezzy (S n) a b where+  rezzy = mkOp3 "rezzy"+  rezzy' = mkOp5 "rezzy"+++instance  CsRireturn (S n)  where+  rireturn = mkOp0 "rireturn"+++instance  CsRms (S n)  where+  rms = mkOp1 "rms"+  rms' = mkOp3 "rms"+++instance  CsRnd (S n) (KSig (S n)) where+  rnd = mkOp1 "rnd"+++instance  CsRnd (S n) (INum (S n)) where+  rnd = mkOp1 "rnd"+++instance  CsRnd31 (S n) (ASig (S n)) where+  rnd31 = mkOp2 "rnd31"+  rnd31' = mkOp3 "rnd31"+++instance  CsRnd31 (S n) (KSig (S n)) where+  rnd31 = mkOp2 "rnd31"+  rnd31' = mkOp3 "rnd31"+++instance  CsRnd31 (S n) (INum (S n)) where+  rnd31 = mkOp2 "rnd31"+  rnd31' = mkOp3 "rnd31"+++instance  CsRound (S n) (ASig (S n)) (ASig (S n)) where+  round = mkOp1 "round"+++instance  CsRound (S n) (KSig (S n)) (KSig (S n)) where+  round = mkOp1 "round"+++instance  CsRound (S n) (INum (S n)) (INum (S n)) where+  round = mkOp1 "round"+++instance (PVar out, Varable a, Varable b) => CsRspline (S n) out a b where+  rspline = mkOp4 "rspline"+++instance  CsRtclock (S n) (KSig (S n)) where+  rtclock = mkOp0 "rtclock"+++instance  CsRtclock (S n) (INum (S n)) where+  rtclock = mkOp0 "rtclock"+++instance (PVar out, Varable a, Varable b) => CsSamphold (S n) out a b where+  samphold = mkOp2 "samphold"+  samphold' = mkOp4 "samphold"+++instance  CsSandpaper (S n)  where+  sandpaper = mkOp2 "sandpaper"+  sandpaper' = mkOp5 "sandpaper"+++instance  CsScale (S n)  where+  scale = mkOp3 "scale"+++instance  CsScanhammer (S n)  where+  scanhammer = mkOp4 "scanhammer"+++instance  CsScans (S n)  where+  scans = mkOp4 "scans"+  scans' = mkOp5 "scans"+++instance  CsScantable (S n)  where+  scantable = mkOp7 "scantable"+++instance  CsScanu (S n)  where+  scanu = mkOp18 "scanu"+++instance  CsSchedule (S n)  where+  schedule = mkOp4 "schedule"+++instance  CsSchedwhen (S n)  where+  schedwhen = mkOp5 "schedwhen"+++instance  CsScoreline (S n)  where+  scoreline = mkOp2 "scoreline"+++instance  CsScoreline_i (S n)  where+  scoreline_i = mkOp1 "scoreline_i"+++instance  CsSeed (S n)  where+  seed = mkOp1 "seed"+++instance  CsSekere (S n)  where+  sekere = mkOp2 "sekere"+  sekere' = mkOp5 "sekere"+++instance  CsSemitone (S n) (ASig (S n)) (ASig (S n)) where+  semitone = mkOp1 "semitone"+++instance  CsSemitone (S n) (KSig (S n)) (KSig (S n)) where+  semitone = mkOp1 "semitone"+++instance  CsSemitone (S n) (INum (S n)) (INum (S n)) where+  semitone = mkOp1 "semitone"+++instance  CsSeqtime (S n)  where+  seqtime = mkOp5 "seqtime"+++instance  CsSeqtime2 (S n)  where+  seqtime2 = mkOp6 "seqtime2"+++instance  CsSetctrl (S n)  where+  setctrl = mkOp3 "setctrl"+++instance  CsSetksmps (S n)  where+  setksmps = mkOp1 "setksmps"+++instance  CsSetscorepos (S n)  where+  setscorepos = mkOp1 "setscorepos"+++instance  CsSfilist (S n)  where+  sfilist = mkOp1 "sfilist"+++instance (Varable a, Varable b) => CsSfinstr (S n) a b where+  sfinstr = mkOp6 "sfinstr"+  sfinstr' = mkOp9 "sfinstr"+++instance (Varable a, Varable b) => CsSfinstr3 (S n) a b where+  sfinstr3 = mkOp6 "sfinstr3"+  sfinstr3' = mkOp9 "sfinstr3"+++instance (Varable a, Varable b) => CsSfinstr3m (S n) a b where+  sfinstr3m = mkOp6 "sfinstr3m"+  sfinstr3m' = mkOp9 "sfinstr3m"+++instance (Varable a, Varable b) => CsSfinstrm (S n) a b where+  sfinstrm = mkOp6 "sfinstrm"+  sfinstrm' = mkOp9 "sfinstrm"+++instance  CsSfload (S n)  where+  sfload = mkOp1 "sfload"+++instance  CsSflooper (S n)  where+  sflooper = mkOp8 "sflooper"+  sflooper' = mkOp12 "sflooper"+++instance  CsSfpassign (S n)  where+  sfpassign = mkOp2 "sfpassign"+  sfpassign' = mkOp3 "sfpassign"+++instance (Varable a, Varable b) => CsSfplay (S n) a b where+  sfplay = mkOp5 "sfplay"+  sfplay' = mkOp8 "sfplay"+++instance (Varable a, Varable b) => CsSfplay3 (S n) a b where+  sfplay3 = mkOp5 "sfplay3"+  sfplay3' = mkOp8 "sfplay3"+++instance (Varable a, Varable b) => CsSfplay3m (S n) a b where+  sfplay3m = mkOp5 "sfplay3m"+  sfplay3m' = mkOp8 "sfplay3m"+++instance (Varable a, Varable b) => CsSfplaym (S n) a b where+  sfplaym = mkOp5 "sfplaym"+  sfplaym' = mkOp8 "sfplaym"+++instance  CsSfplist (S n)  where+  sfplist = mkOp1 "sfplist"+++instance  CsSfpreset (S n)  where+  sfpreset = mkOp4 "sfpreset"+++instance  CsShaker (S n)  where+  shaker = mkOp5 "shaker"+  shaker' = mkOp6 "shaker"+++instance (Varable a, Varable b) => CsShl (S n) (ASig (S n)) a b where+  shl = mkOp2 "shl"+++instance  CsShl (S n) (KSig (S n)) (KSig (S n)) (KSig (S n)) where+  shl = mkOp2 "shl"+++instance  CsShl (S n) (INum (S n)) (INum (S n)) (INum (S n)) where+  shl = mkOp2 "shl"+++instance (Varable a, Varable b) => CsShr (S n) (ASig (S n)) a b where+  shr = mkOp2 "shr"+++instance  CsShr (S n) (KSig (S n)) (KSig (S n)) (KSig (S n)) where+  shr = mkOp2 "shr"+++instance  CsShr (S n) (INum (S n)) (INum (S n)) (INum (S n)) where+  shr = mkOp2 "shr"+++instance  CsSin (S n) (ASig (S n)) (ASig (S n)) where+  sin = mkOp1 "sin"+++instance  CsSin (S n) (KSig (S n)) (KSig (S n)) where+  sin = mkOp1 "sin"+++instance  CsSin (S n) (INum (S n)) (INum (S n)) where+  sin = mkOp1 "sin"+++instance  CsSinh (S n) (ASig (S n)) (ASig (S n)) where+  sinh = mkOp1 "sinh"+++instance  CsSinh (S n) (KSig (S n)) (KSig (S n)) where+  sinh = mkOp1 "sinh"+++instance  CsSinh (S n) (INum (S n)) (INum (S n)) where+  sinh = mkOp1 "sinh"+++instance  CsSininv (S n) (ASig (S n)) (ASig (S n)) where+  sininv = mkOp1 "sininv"+++instance  CsSininv (S n) (KSig (S n)) (KSig (S n)) where+  sininv = mkOp1 "sininv"+++instance  CsSininv (S n) (INum (S n)) (INum (S n)) where+  sininv = mkOp1 "sininv"+++instance  CsSinsyn (S n)  where+  sinsyn = mkOp4 "sinsyn"+++instance  CsSleighbells (S n)  where+  sleighbells = mkOp2 "sleighbells"+  sleighbells' = mkOp8 "sleighbells"+++instance  CsSlider16table (S n)  where+  slider16table = mkOp83 "slider16table"+++instance  CsSlider16tablef (S n)  where+  slider16tablef = mkOp99 "slider16tablef"+++instance  CsSlider8table (S n)  where+  slider8table = mkOp43 "slider8table"+++instance  CsSlider8tablef (S n)  where+  slider8tablef = mkOp51 "slider8tablef"+++instance  CsSndload (S n)  where+  sndload = mkOp1 "sndload"+  sndload' = mkOp10 "sndload"+++instance  CsSndloop (S n)  where+  sndloop = mkOp5 "sndloop"+++instance (Nat d, Varable a, Varable b, Varable c) => CsSndwarp (S n) d a b c where+  sndwarp = mkOp10 "sndwarp"+++instance (Nat d, Varable a, Varable b, Varable c) => CsSndwarpst (S n) d a b c where+  sndwarpst = mkOp10 "sndwarpst"+++instance  CsSockrecv (S n)  where+  sockrecv = mkOp2 "sockrecv"+++instance  CsSockrecvs (S n)  where+  sockrecvs = mkOp2 "sockrecvs"+++instance  CsSocksend (S n)  where+  socksend = mkOp4 "socksend"+++instance  CsSocksends (S n)  where+  socksends = mkOp5 "socksends"+++instance (Nat d) => CsSoundin (S n) d where+  soundin = mkOp1 "soundin"+  soundin' = mkOp5 "soundin"+++instance  CsSoundout (S n)  where+  soundout = mkOp2 "soundout"+  soundout' = mkOp3 "soundout"+++instance  CsSoundouts (S n)  where+  soundouts = mkOp3 "soundouts"+  soundouts' = mkOp4 "soundouts"+++instance  CsSpace (S n)  where+  space = mkOp6 "space"+++instance  CsSpat3d (S n)  where+  spat3d = mkOp9 "spat3d"+  spat3d' = mkOp10 "spat3d"+++instance  CsSpat3di (S n)  where+  spat3di = mkOp7 "spat3di"+  spat3di' = mkOp8 "spat3di"+++instance  CsSpat3dt (S n)  where+  spat3dt = mkOp8 "spat3dt"+  spat3dt' = mkOp9 "spat3dt"+++instance  CsSpdist (S n)  where+  spdist = mkOp4 "spdist"+++instance  CsSplitrig (S n)  where+  splitrig = mkOp5 "splitrig"+++instance  CsSprintf (S n)  where+  sprintf = mkOp3 "sprintf"+++instance  CsSpsend (S n)  where+  spsend = mkOp0 "spsend"+++instance  CsSqrt (S n) (ASig (S n)) (ASig (S n)) where+  sqrt = mkOp1 "sqrt"+++instance  CsSqrt (S n) (KSig (S n)) (KSig (S n)) where+  sqrt = mkOp1 "sqrt"+++instance  CsSqrt (S n) (INum (S n)) (INum (S n)) where+  sqrt = mkOp1 "sqrt"+++instance  CsStack (S n)  where+  stack = mkOp1 "stack"+++instance  CsStatevar (S n)  where+  statevar = mkOp3 "statevar"+  statevar' = mkOp5 "statevar"+++instance  CsStix (S n)  where+  stix = mkOp2 "stix"+  stix' = mkOp5 "stix"+++instance  CsStrcat (S n)  where+  strcat = mkOp2 "strcat"+++instance  CsStrcatk (S n)  where+  strcatk = mkOp2 "strcatk"+++instance  CsStrchar (S n)  where+  strchar = mkOp1 "strchar"+  strchar' = mkOp2 "strchar"+++instance (KVar a) => CsStrchark (S n) a where+  strchark = mkOp1 "strchark"+  strchark' = mkOp2 "strchark"+++instance  CsStrcmp (S n)  where+  strcmp = mkOp2 "strcmp"+++instance  CsStrcmpk (S n)  where+  strcmpk = mkOp2 "strcmpk"+++instance  CsStrcpy (S n)  where+  strcpy = mkOp1 "strcpy"+++instance  CsStrcpyk (S n)  where+  strcpyk = mkOp1 "strcpyk"+++instance  CsStrecv (S n)  where+  strecv = mkOp2 "strecv"+++instance  CsStreson (S n)  where+  streson = mkOp3 "streson"+++instance  CsStrget (S n)  where+  strget = mkOp1 "strget"+++instance  CsStrindex (S n)  where+  strindex = mkOp2 "strindex"+++instance  CsStrindexk (S n)  where+  strindexk = mkOp2 "strindexk"+++instance  CsStrlen (S n)  where+  strlen = mkOp1 "strlen"+++instance  CsStrlenk (S n)  where+  strlenk = mkOp1 "strlenk"+++instance  CsStrlower (S n)  where+  strlower = mkOp1 "strlower"+++instance  CsStrlowerk (S n)  where+  strlowerk = mkOp1 "strlowerk"+++instance  CsStrrindex (S n)  where+  strrindex = mkOp2 "strrindex"+++instance  CsStrrindexk (S n)  where+  strrindexk = mkOp2 "strrindexk"+++instance  CsStrset (S n)  where+  strset = mkOp2 "strset"+++instance  CsStrsub (S n)  where+  strsub = mkOp1 "strsub"+  strsub' = mkOp3 "strsub"+++instance  CsStrsubk (S n)  where+  strsubk = mkOp3 "strsubk"+++instance  CsStrtod (S n)  where+  strtod = mkOp1 "strtod"+++instance  CsStrtol (S n)  where+  strtol = mkOp1 "strtol"+++instance  CsStrupper (S n)  where+  strupper = mkOp1 "strupper"+++instance  CsStrupperk (S n)  where+  strupperk = mkOp1 "strupperk"+++instance  CsStsend (S n)  where+  stsend = mkOp3 "stsend"+++instance (Varable a, Varable b) => CsSub (S n) (ASig (S n)) a b where+  sub = mkOp2 "sub"+++instance  CsSub (S n) (KSig (S n)) (KSig (S n)) (KSig (S n)) where+  sub = mkOp2 "sub"+++instance  CsSub (S n) (INum (S n)) (INum (S n)) (INum (S n)) where+  sub = mkOp2 "sub"+++instance (Nat d) => CsSubinstr (S n) d where+  subinstr = mkOp2 "subinstr"+++instance  CsSubinstrinit (S n)  where+  subinstrinit = mkOp2 "subinstrinit"+++instance  CSE.CsSum (S n)  where+  sum = mkOp1 "sum"+++instance  CsSvfilter (S n)  where+  svfilter = mkOp3 "svfilter"+  svfilter' = mkOp4 "svfilter"+++instance  CsSyncgrain (S n)  where+  syncgrain = mkOp8 "syncgrain"+++instance  CsSyncloop (S n)  where+  syncloop = mkOp10 "syncloop"+  syncloop' = mkOp12 "syncloop"+++instance (Varable a) => CsSyncphasor (S n) a where+  syncphasor = mkOp2 "syncphasor"+  syncphasor' = mkOp3 "syncphasor"+++instance (KVar a) => CsSystem (S n) a where+  system = mkOp2 "system"+  system' = mkOp3 "system"+++instance  CsSystem_i (S n)  where+  system_i = mkOp2 "system_i"+  system_i' = mkOp3 "system_i"+++instance (PVar out, Varable a) => CsTab (S n) out a where+  tab = mkOp2 "tab"+  tab' = mkOp3 "tab"+++instance  CsTab_i (S n)  where+  tab_i = mkOp2 "tab_i"+  tab_i' = mkOp3 "tab_i"+++instance (Varable a) => CsTable (S n) (ASig (S n)) a where+  table = mkOp2 "table"+  table' = mkOp5 "table"+++instance (Varable a) => CsTable (S n) (KSig (S n)) a where+  table = mkOp2 "table"+  table' = mkOp5 "table"+++instance  CsTable (S n) (INum (S n)) (INum (S n)) where+  table = mkOp2 "table"+  table' = mkOp5 "table"+++instance (Varable a) => CsTable3 (S n) (ASig (S n)) a where+  table3 = mkOp2 "table3"+  table3' = mkOp5 "table3"+++instance (Varable a) => CsTable3 (S n) (KSig (S n)) a where+  table3 = mkOp2 "table3"+  table3' = mkOp5 "table3"+++instance  CsTable3 (S n) (INum (S n)) (INum (S n)) where+  table3 = mkOp2 "table3"+  table3' = mkOp5 "table3"+++instance  CsTablecopy (S n)  where+  tablecopy = mkOp2 "tablecopy"+++instance  CsTablegpw (S n)  where+  tablegpw = mkOp1 "tablegpw"+++instance (Varable a) => CsTablei (S n) (ASig (S n)) a where+  tablei = mkOp2 "tablei"+  tablei' = mkOp5 "tablei"+++instance (Varable a) => CsTablei (S n) (KSig (S n)) a where+  tablei = mkOp2 "tablei"+  tablei' = mkOp5 "tablei"+++instance  CsTablei (S n) (INum (S n)) (INum (S n)) where+  tablei = mkOp2 "tablei"+  tablei' = mkOp5 "tablei"+++instance  CsTableicopy (S n)  where+  tableicopy = mkOp2 "tableicopy"+++instance  CsTableigpw (S n)  where+  tableigpw = mkOp1 "tableigpw"+++instance (PVar out, Varable a) => CsTableikt (S n) out a where+  tableikt = mkOp2 "tableikt"+  tableikt' = mkOp5 "tableikt"+++instance  CsTableimix (S n)  where+  tableimix = mkOp9 "tableimix"+++instance  CsTableiw (S n)  where+  tableiw = mkOp3 "tableiw"+  tableiw' = mkOp6 "tableiw"+++instance (PVar out, Varable a) => CsTablekt (S n) out a where+  tablekt = mkOp2 "tablekt"+  tablekt' = mkOp5 "tablekt"+++instance  CsTablemix (S n)  where+  tablemix = mkOp9 "tablemix"+++instance  CsTableng (S n) (KSig (S n)) where+  tableng = mkOp1 "tableng"+++instance  CsTableng (S n) (INum (S n)) where+  tableng = mkOp1 "tableng"+++instance  CsTablera (S n)  where+  tablera = mkOp3 "tablera"+++instance  CsTableseg (S n)  where+  tableseg = mkOp4 "tableseg"+++instance (Varable a, Varable b) => CsTablew (S n) a b where+  tablew = mkOp3 "tablew"+  tablew' = mkOp6 "tablew"+++instance  CsTablewa (S n)  where+  tablewa = mkOp3 "tablewa"+++instance (Varable a, Varable b) => CsTablewkt (S n) a b where+  tablewkt = mkOp3 "tablewkt"+  tablewkt' = mkOp6 "tablewkt"+++instance (Varable a) => CsTablexkt (S n) a where+  tablexkt = mkOp4 "tablexkt"+  tablexkt' = mkOp7 "tablexkt"+++instance  CsTablexseg (S n)  where+  tablexseg = mkOp4 "tablexseg"+++instance  CsTabmorph (S n)  where+  tabmorph = mkOp5 "tabmorph"+++instance  CsTabmorpha (S n)  where+  tabmorpha = mkOp5 "tabmorpha"+++instance  CsTabmorphak (S n)  where+  tabmorphak = mkOp5 "tabmorphak"+++instance  CsTabmorphi (S n)  where+  tabmorphi = mkOp5 "tabmorphi"+++instance  CsTabplay (S n)  where+  tabplay = mkOp4 "tabplay"+++instance  CsTabrec (S n)  where+  tabrec = mkOp5 "tabrec"+++instance (KVar a, KVar b) => CsTabsum (S n) a b where+  tabsum = mkOp1 "tabsum"+  tabsum' = mkOp3 "tabsum"+++instance (Varable a, Varable b) => CsTabw (S n) a b where+  tabw = mkOp3 "tabw"+  tabw' = mkOp4 "tabw"+++instance  CsTabw_i (S n)  where+  tabw_i = mkOp3 "tabw_i"+  tabw_i' = mkOp4 "tabw_i"+++instance  CsTambourine (S n)  where+  tambourine = mkOp2 "tambourine"+  tambourine' = mkOp8 "tambourine"+++instance  CsTan (S n) (ASig (S n)) (ASig (S n)) where+  tan = mkOp1 "tan"+++instance  CsTan (S n) (KSig (S n)) (KSig (S n)) where+  tan = mkOp1 "tan"+++instance  CsTan (S n) (INum (S n)) (INum (S n)) where+  tan = mkOp1 "tan"+++instance  CsTanh (S n) (ASig (S n)) (ASig (S n)) where+  tanh = mkOp1 "tanh"+++instance  CsTanh (S n) (KSig (S n)) (KSig (S n)) where+  tanh = mkOp1 "tanh"+++instance  CsTanh (S n) (INum (S n)) (INum (S n)) where+  tanh = mkOp1 "tanh"+++instance  CsTaninv (S n) (ASig (S n)) (ASig (S n)) where+  taninv = mkOp1 "taninv"+++instance  CsTaninv (S n) (KSig (S n)) (KSig (S n)) where+  taninv = mkOp1 "taninv"+++instance  CsTaninv (S n) (INum (S n)) (INum (S n)) where+  taninv = mkOp1 "taninv"+++instance  CsTaninv2 (S n) (ASig (S n)) (ASig (S n)) (ASig (S n)) where+  taninv2 = mkOp2 "taninv2"+++instance  CsTaninv2 (S n) (KSig (S n)) (KSig (S n)) (KSig (S n)) where+  taninv2 = mkOp2 "taninv2"+++instance  CsTaninv2 (S n) (INum (S n)) (INum (S n)) (INum (S n)) where+  taninv2 = mkOp2 "taninv2"+++instance  CsTb0 (S n) (KSig (S n)) where+  tb0 = mkOp1 "tb0"+++instance  CsTb0 (S n) (INum (S n)) where+  tb0 = mkOp1 "tb0"+++instance  CsTb0_init (S n)  where+  tb0_init = mkOp1 "tb0_init"+++instance  CsTb1 (S n) (KSig (S n)) where+  tb1 = mkOp1 "tb1"+++instance  CsTb1 (S n) (INum (S n)) where+  tb1 = mkOp1 "tb1"+++instance  CsTb10 (S n) (KSig (S n)) where+  tb10 = mkOp1 "tb10"+++instance  CsTb10 (S n) (INum (S n)) where+  tb10 = mkOp1 "tb10"+++instance  CsTb10_init (S n)  where+  tb10_init = mkOp1 "tb10_init"+++instance  CsTb11 (S n) (KSig (S n)) where+  tb11 = mkOp1 "tb11"+++instance  CsTb11 (S n) (INum (S n)) where+  tb11 = mkOp1 "tb11"+++instance  CsTb11_init (S n)  where+  tb11_init = mkOp1 "tb11_init"+++instance  CsTb12 (S n) (KSig (S n)) where+  tb12 = mkOp1 "tb12"+++instance  CsTb12 (S n) (INum (S n)) where+  tb12 = mkOp1 "tb12"+++instance  CsTb12_init (S n)  where+  tb12_init = mkOp1 "tb12_init"+++instance  CsTb13 (S n) (KSig (S n)) where+  tb13 = mkOp1 "tb13"+++instance  CsTb13 (S n) (INum (S n)) where+  tb13 = mkOp1 "tb13"+++instance  CsTb13_init (S n)  where+  tb13_init = mkOp1 "tb13_init"+++instance  CsTb14 (S n) (KSig (S n)) where+  tb14 = mkOp1 "tb14"+++instance  CsTb14 (S n) (INum (S n)) where+  tb14 = mkOp1 "tb14"+++instance  CsTb14_init (S n)  where+  tb14_init = mkOp1 "tb14_init"+++instance  CsTb15 (S n) (KSig (S n)) where+  tb15 = mkOp1 "tb15"+++instance  CsTb15 (S n) (INum (S n)) where+  tb15 = mkOp1 "tb15"+++instance  CsTb15_init (S n)  where+  tb15_init = mkOp1 "tb15_init"+++instance  CsTb1_init (S n)  where+  tb1_init = mkOp1 "tb1_init"+++instance  CsTb2 (S n) (KSig (S n)) where+  tb2 = mkOp1 "tb2"+++instance  CsTb2 (S n) (INum (S n)) where+  tb2 = mkOp1 "tb2"+++instance  CsTb2_init (S n)  where+  tb2_init = mkOp1 "tb2_init"+++instance  CsTb3 (S n) (KSig (S n)) where+  tb3 = mkOp1 "tb3"+++instance  CsTb3 (S n) (INum (S n)) where+  tb3 = mkOp1 "tb3"+++instance  CsTb3_init (S n)  where+  tb3_init = mkOp1 "tb3_init"+++instance  CsTb4 (S n) (KSig (S n)) where+  tb4 = mkOp1 "tb4"+++instance  CsTb4 (S n) (INum (S n)) where+  tb4 = mkOp1 "tb4"+++instance  CsTb4_init (S n)  where+  tb4_init = mkOp1 "tb4_init"+++instance  CsTb5 (S n) (KSig (S n)) where+  tb5 = mkOp1 "tb5"+++instance  CsTb5 (S n) (INum (S n)) where+  tb5 = mkOp1 "tb5"+++instance  CsTb5_init (S n)  where+  tb5_init = mkOp1 "tb5_init"+++instance  CsTb6 (S n) (KSig (S n)) where+  tb6 = mkOp1 "tb6"+++instance  CsTb6 (S n) (INum (S n)) where+  tb6 = mkOp1 "tb6"+++instance  CsTb6_init (S n)  where+  tb6_init = mkOp1 "tb6_init"+++instance  CsTb7 (S n) (KSig (S n)) where+  tb7 = mkOp1 "tb7"+++instance  CsTb7 (S n) (INum (S n)) where+  tb7 = mkOp1 "tb7"+++instance  CsTb7_init (S n)  where+  tb7_init = mkOp1 "tb7_init"+++instance  CsTb8 (S n) (KSig (S n)) where+  tb8 = mkOp1 "tb8"+++instance  CsTb8 (S n) (INum (S n)) where+  tb8 = mkOp1 "tb8"+++instance  CsTb8_init (S n)  where+  tb8_init = mkOp1 "tb8_init"+++instance  CsTb9 (S n) (KSig (S n)) where+  tb9 = mkOp1 "tb9"+++instance  CsTb9 (S n) (INum (S n)) where+  tb9 = mkOp1 "tb9"+++instance  CsTb9_init (S n)  where+  tb9_init = mkOp1 "tb9_init"+++instance (Varable a, Varable b) => CsTbvcf (S n) a b where+  tbvcf = mkOp5 "tbvcf"+  tbvcf' = mkOp6 "tbvcf"+++instance  CsTempest (S n)  where+  tempest = mkOp10 "tempest"+  tempest' = mkOp12 "tempest"+++instance  CsTempo (S n)  where+  tempo = mkOp2 "tempo"+++instance  CsTempoval (S n)  where+  tempoval = mkOp0 "tempoval"+++instance  CsTimedseq (S n)  where+  timedseq = mkOp3 "timedseq"+++instance  CsTimeinstk (S n)  where+  timeinstk = mkOp0 "timeinstk"+++instance  CsTimeinsts (S n)  where+  timeinsts = mkOp0 "timeinsts"+++instance  CsTimek (S n) (KSig (S n)) where+  timek = mkOp0 "timek"+++instance  CsTimek (S n) (INum (S n)) where+  timek = mkOp0 "timek"+++instance  CsTimes (S n) (KSig (S n)) where+  times = mkOp0 "times"+++instance  CsTimes (S n) (INum (S n)) where+  times = mkOp0 "times"+++instance  CsTival (S n)  where+  tival = mkOp0 "tival"+++instance  CsTlineto (S n)  where+  tlineto = mkOp3 "tlineto"+++instance  CsTone (S n)  where+  tone = mkOp2 "tone"+  tone' = mkOp3 "tone"+++instance  CsTonek (S n)  where+  tonek = mkOp2 "tonek"+  tonek' = mkOp3 "tonek"+++instance  CsTonex (S n)  where+  tonex = mkOp2 "tonex"+  tonex' = mkOp4 "tonex"+++instance  CsTradsyn (S n)  where+  tradsyn = mkOp5 "tradsyn"+++instance  CsTrandom (S n)  where+  trandom = mkOp3 "trandom"+++instance (PVar out) => CsTranseg (S n) out where+  transeg = mkOp4 "transeg"+++instance (PVar out) => CsTransegr (S n) out where+  transegr = mkOp4 "transegr"+++instance  CsTrcross (S n)  where+  trcross = mkOp4 "trcross"+++instance  CsTrfilter (S n)  where+  trfilter = mkOp3 "trfilter"+++instance  CsTrigger (S n)  where+  trigger = mkOp3 "trigger"+++instance  CsTrigseq (S n)  where+  trigseq = mkOp6 "trigseq"+++instance  CsTrirand (S n) (ASig (S n)) where+  trirand = mkOp1 "trirand"+++instance  CsTrirand (S n) (KSig (S n)) where+  trirand = mkOp1 "trirand"+++instance  CsTrirand (S n) (INum (S n)) where+  trirand = mkOp1 "trirand"+++instance  CsTrmix (S n)  where+  trmix = mkOp2 "trmix"+++instance  CsTrscale (S n)  where+  trscale = mkOp2 "trscale"+++instance  CsTrshift (S n)  where+  trshift = mkOp2 "trshift"+++instance  CsTrsplit (S n)  where+  trsplit = mkOp2 "trsplit"+++instance  CsTurnoff (S n)  where+  turnoff = mkOp0 "turnoff"+++instance  CsTurnoff2 (S n)  where+  turnoff2 = mkOp3 "turnoff2"+++instance  CsTurnon (S n)  where+  turnon = mkOp1 "turnon"+  turnon' = mkOp2 "turnon"+++instance  CsUnirand (S n) (ASig (S n)) where+  unirand = mkOp1 "unirand"+++instance  CsUnirand (S n) (KSig (S n)) where+  unirand = mkOp1 "unirand"+++instance  CsUnirand (S n) (INum (S n)) where+  unirand = mkOp1 "unirand"+++instance  CsUpsamp (S n)  where+  upsamp = mkOp1 "upsamp"+++instance  CsUrd (S n) (ASig (S n)) where+  urd = mkOp1 "urd"+++instance  CsUrd (S n) (KSig (S n)) where+  urd = mkOp1 "urd"+++instance  CsUrd (S n) (INum (S n)) where+  urd = mkOp1 "urd"+++instance (KVar a, KVar b) => CsVadd (S n) a b where+  vadd = mkOp3 "vadd"+  vadd' = mkOp5 "vadd"+++instance  CsVadd_i (S n)  where+  vadd_i = mkOp3 "vadd_i"+  vadd_i' = mkOp4 "vadd_i"+++instance (KVar a, KVar b, KVar c) => CsVaddv (S n) a b c where+  vaddv = mkOp3 "vaddv"+  vaddv' = mkOp6 "vaddv"+++instance  CsVaddv_i (S n)  where+  vaddv_i = mkOp3 "vaddv_i"+  vaddv_i' = mkOp5 "vaddv_i"+++instance  CsVaget (S n)  where+  vaget = mkOp2 "vaget"+++instance (Varable a) => CsValpass (S n) a where+  valpass = mkOp4 "valpass"+  valpass' = mkOp6 "valpass"+++instance  CsVaset (S n)  where+  vaset = mkOp3 "vaset"+++instance (KVar a, KVar b) => CsVbap4 (S n) a b where+  vbap4 = mkOp2 "vbap4"+  vbap4' = mkOp4 "vbap4"+++instance  CsVbap4move (S n)  where+  vbap4move = mkOp5 "vbap4move"+++instance  CsVbaplsinit (S n)  where+  vbaplsinit = mkOp2 "vbaplsinit"+  vbaplsinit' = mkOp34 "vbaplsinit"+++instance (KVar a, KVar b) => CsVbapz (S n) a b where+  vbapz = mkOp4 "vbapz"+  vbapz' = mkOp6 "vbapz"+++instance  CsVbapzmove (S n)  where+  vbapzmove = mkOp7 "vbapzmove"+++instance  CsVcella (S n)  where+  vcella = mkOp7 "vcella"+  vcella' = mkOp8 "vcella"+++instance (Varable a) => CsVco2 (S n) a where+  vco2 = mkOp2 "vco2"+  vco2' = mkOp4 "vco2"+++instance  CsVco2ft (S n)  where+  vco2ft = mkOp1 "vco2ft"+  vco2ft' = mkOp3 "vco2ft"+++instance  CsVco2ift (S n)  where+  vco2ift = mkOp1 "vco2ift"+  vco2ift' = mkOp3 "vco2ift"+++instance  CsVco2init (S n)  where+  vco2init = mkOp1 "vco2init"+  vco2init' = mkOp6 "vco2init"+++instance (Varable a) => CsVcomb (S n) a where+  vcomb = mkOp4 "vcomb"+  vcomb' = mkOp6 "vcomb"+++instance (KVar a, KVar b, KVar c) => CsVcopy (S n) a b c where+  vcopy = mkOp3 "vcopy"+  vcopy' = mkOp6 "vcopy"+++instance  CsVcopy_i (S n)  where+  vcopy_i = mkOp3 "vcopy_i"+  vcopy_i' = mkOp5 "vcopy_i"+++instance  CsVdel_k (S n)  where+  vdel_k = mkOp3 "vdel_k"+  vdel_k' = mkOp4 "vdel_k"+++instance  CsVdelayk (S n)  where+  vdelayk = mkOp3 "vdelayk"+  vdelayk' = mkOp5 "vdelayk"+++instance  CsVdelayx (S n)  where+  vdelayx = mkOp4 "vdelayx"+  vdelayx' = mkOp5 "vdelayx"+++instance  CsVdelayxq (S n)  where+  vdelayxq = mkOp7 "vdelayxq"+  vdelayxq' = mkOp8 "vdelayxq"+++instance  CsVdelayxs (S n)  where+  vdelayxs = mkOp5 "vdelayxs"+  vdelayxs' = mkOp6 "vdelayxs"+++instance  CsVdelayxw (S n)  where+  vdelayxw = mkOp4 "vdelayxw"+  vdelayxw' = mkOp5 "vdelayxw"+++instance  CsVdelayxwq (S n)  where+  vdelayxwq = mkOp7 "vdelayxwq"+  vdelayxwq' = mkOp8 "vdelayxwq"+++instance  CsVdelayxws (S n)  where+  vdelayxws = mkOp5 "vdelayxws"+  vdelayxws' = mkOp6 "vdelayxws"+++instance (KVar a, KVar b, KVar c) => CsVdivv (S n) a b c where+  vdivv = mkOp3 "vdivv"+  vdivv' = mkOp6 "vdivv"+++instance  CsVdivv_i (S n)  where+  vdivv_i = mkOp3 "vdivv_i"+  vdivv_i' = mkOp5 "vdivv_i"+++instance  CsVecdelay (S n)  where+  vecdelay = mkOp5 "vecdelay"+  vecdelay' = mkOp6 "vecdelay"+++instance  CsVeloc (S n)  where+  veloc = mkOp0 "veloc"+  veloc' = mkOp2 "veloc"+++instance (KVar a, KVar b) => CsVexp (S n) a b where+  vexp = mkOp3 "vexp"+  vexp' = mkOp5 "vexp"+++instance  CsVexp_i (S n)  where+  vexp_i = mkOp3 "vexp_i"+  vexp_i' = mkOp4 "vexp_i"+++instance  CsVexpseg (S n)  where+  vexpseg = mkOp4 "vexpseg"+++instance (KVar a, KVar b, KVar c) => CsVexpv (S n) a b c where+  vexpv = mkOp3 "vexpv"+  vexpv' = mkOp6 "vexpv"+++instance  CsVexpv_i (S n)  where+  vexpv_i = mkOp3 "vexpv_i"+  vexpv_i' = mkOp5 "vexpv_i"+++instance  CsVibes (S n)  where+  vibes = mkOp9 "vibes"+++instance  CsVibr (S n)  where+  vibr = mkOp3 "vibr"+++instance  CsVibrato (S n)  where+  vibrato = mkOp9 "vibrato"+  vibrato' = mkOp10 "vibrato"+++instance  CsVincr (S n)  where+  vincr = mkOp2 "vincr"+++instance  CsVlimit (S n)  where+  vlimit = mkOp4 "vlimit"+++instance  CsVlinseg (S n)  where+  vlinseg = mkOp4 "vlinseg"+++instance  CsVlowres (S n)  where+  vlowres = mkOp5 "vlowres"+++instance  CsVmap (S n)  where+  vmap = mkOp3 "vmap"+  vmap' = mkOp5 "vmap"+++instance  CsVmirror (S n)  where+  vmirror = mkOp4 "vmirror"+++instance (KVar a, KVar b) => CsVmult (S n) a b where+  vmult = mkOp3 "vmult"+  vmult' = mkOp5 "vmult"+++instance  CsVmult_i (S n)  where+  vmult_i = mkOp3 "vmult_i"+  vmult_i' = mkOp4 "vmult_i"+++instance (KVar a, KVar b, KVar c) => CsVmultv (S n) a b c where+  vmultv = mkOp3 "vmultv"+  vmultv' = mkOp6 "vmultv"+++instance  CsVmultv_i (S n)  where+  vmultv_i = mkOp3 "vmultv_i"+  vmultv_i' = mkOp5 "vmultv_i"+++instance  CsVoice (S n)  where+  voice = mkOp8 "voice"+++instance  CsVosim (S n)  where+  vosim = mkOp7 "vosim"+  vosim' = mkOp8 "vosim"+++instance  CsVphaseseg (S n)  where+  vphaseseg = mkOp4 "vphaseseg"+++instance  CsVport (S n)  where+  vport = mkOp3 "vport"+  vport' = mkOp4 "vport"+++instance (KVar a, KVar b) => CsVpow (S n) a b where+  vpow = mkOp3 "vpow"+  vpow' = mkOp5 "vpow"+++instance  CsVpow_i (S n)  where+  vpow_i = mkOp3 "vpow_i"+  vpow_i' = mkOp4 "vpow_i"+++instance (KVar a, KVar b, KVar c) => CsVpowv (S n) a b c where+  vpowv = mkOp3 "vpowv"+  vpowv' = mkOp6 "vpowv"+++instance  CsVpowv_i (S n)  where+  vpowv_i = mkOp3 "vpowv_i"+  vpowv_i' = mkOp5 "vpowv_i"+++instance  CsVpvoc (S n)  where+  vpvoc = mkOp3 "vpvoc"+  vpvoc' = mkOp5 "vpvoc"+++instance  CsVrandh (S n)  where+  vrandh = mkOp4 "vrandh"+  vrandh' = mkOp8 "vrandh"+++instance  CsVrandi (S n)  where+  vrandi = mkOp4 "vrandi"+  vrandi' = mkOp8 "vrandi"+++instance (KVar a, KVar b, KVar c) => CsVsubv (S n) a b c where+  vsubv = mkOp3 "vsubv"+  vsubv' = mkOp6 "vsubv"+++instance  CsVsubv_i (S n)  where+  vsubv_i = mkOp3 "vsubv_i"+  vsubv_i' = mkOp5 "vsubv_i"+++instance  CsVtaba (S n)  where+  vtaba = mkOp3 "vtaba"+++instance  CsVtabi (S n)  where+  vtabi = mkOp3 "vtabi"+++instance  CsVtabk (S n)  where+  vtabk = mkOp3 "vtabk"+++instance  CsVtable1k (S n)  where+  vtable1k = mkOp2 "vtable1k"+++instance  CsVtablea (S n)  where+  vtablea = mkOp5 "vtablea"+++instance  CsVtablei (S n)  where+  vtablei = mkOp5 "vtablei"+++instance  CsVtablek (S n)  where+  vtablek = mkOp5 "vtablek"+++instance  CsVtablewa (S n)  where+  vtablewa = mkOp4 "vtablewa"+++instance  CsVtablewi (S n)  where+  vtablewi = mkOp4 "vtablewi"+++instance  CsVtablewk (S n)  where+  vtablewk = mkOp4 "vtablewk"+++instance  CsVtabwa (S n)  where+  vtabwa = mkOp3 "vtabwa"+++instance  CsVtabwi (S n)  where+  vtabwi = mkOp3 "vtabwi"+++instance  CsVtabwk (S n)  where+  vtabwk = mkOp3 "vtabwk"+++instance  CsVwrap (S n)  where+  vwrap = mkOp4 "vwrap"+++instance  CsWaveset (S n)  where+  waveset = mkOp2 "waveset"+  waveset' = mkOp3 "waveset"+++instance  CsWeibull (S n) (ASig (S n)) where+  weibull = mkOp2 "weibull"+++instance  CsWeibull (S n) (KSig (S n)) where+  weibull = mkOp2 "weibull"+++instance  CsWeibull (S n) (INum (S n)) where+  weibull = mkOp2 "weibull"+++instance  CsWgbow (S n)  where+  wgbow = mkOp7 "wgbow"+  wgbow' = mkOp8 "wgbow"+++instance  CsWgbowedbar (S n)  where+  wgbowedbar = mkOp5 "wgbowedbar"+  wgbowedbar' = mkOp9 "wgbowedbar"+++instance  CsWgbrass (S n)  where+  wgbrass = mkOp7 "wgbrass"+  wgbrass' = mkOp8 "wgbrass"+++instance  CsWgclar (S n)  where+  wgclar = mkOp9 "wgclar"+  wgclar' = mkOp10 "wgclar"+++instance  CsWgflute (S n)  where+  wgflute = mkOp9 "wgflute"+  wgflute' = mkOp12 "wgflute"+++instance  CsWgpluck (S n)  where+  wgpluck = mkOp7 "wgpluck"+++instance  CsWgpluck2 (S n)  where+  wgpluck2 = mkOp5 "wgpluck2"+++instance (Varable a) => CsWguide1 (S n) a where+  wguide1 = mkOp4 "wguide1"+++instance (Varable a, Varable b) => CsWguide2 (S n) a b where+  wguide2 = mkOp7 "wguide2"+++instance  CsWrap (S n) (ASig (S n)) (ASig (S n)) where+  wrap = mkOp3 "wrap"+++instance  CsWrap (S n) (KSig (S n)) (KSig (S n)) where+  wrap = mkOp3 "wrap"+++instance  CsWrap (S n) (INum (S n)) (INum (S n)) where+  wrap = mkOp3 "wrap"+++instance  CsWterrain (S n)  where+  wterrain = mkOp8 "wterrain"+++instance (PVar out) => CsXadsr (S n) out where+  xadsr = mkOp4 "xadsr"+  xadsr' = mkOp5 "xadsr"+++instance (Varable a, Varable b) => CsXor (S n) (ASig (S n)) a b where+  xor = mkOp2 "xor"+++instance  CsXor (S n) (KSig (S n)) (KSig (S n)) (KSig (S n)) where+  xor = mkOp2 "xor"+++instance  CsXor (S n) (INum (S n)) (INum (S n)) (INum (S n)) where+  xor = mkOp2 "xor"+++instance  CsXout (S n)  where+  xout = mkOp1 "xout"+++instance  CsXscanmap (S n)  where+  xscanmap = mkOp3 "xscanmap"+  xscanmap' = mkOp4 "xscanmap"+++instance  CsXscans (S n)  where+  xscans = mkOp4 "xscans"+  xscans' = mkOp5 "xscans"+++instance  CsXscansmap (S n)  where+  xscansmap = mkOp5 "xscansmap"+  xscansmap' = mkOp6 "xscansmap"+++instance  CsXscanu (S n)  where+  xscanu = mkOp18 "xscanu"+++instance  CsXtratim (S n)  where+  xtratim = mkOp1 "xtratim"+++instance  CsXyin (S n)  where+  xyin = mkOp5 "xyin"+  xyin' = mkOp7 "xyin"+++instance  CsZacl (S n)  where+  zacl = mkOp2 "zacl"+++instance  CsZakinit (S n)  where+  zakinit = mkOp2 "zakinit"+++instance  CsZamod (S n)  where+  zamod = mkOp2 "zamod"+++instance  CsZar (S n)  where+  zar = mkOp1 "zar"+++instance  CsZarg (S n)  where+  zarg = mkOp2 "zarg"+++instance  CsZaw (S n)  where+  zaw = mkOp2 "zaw"+++instance  CsZawm (S n)  where+  zawm = mkOp2 "zawm"+  zawm' = mkOp3 "zawm"+++instance  CsZfilter2 (S n)  where+  zfilter2 = mkOp6 "zfilter2"+++instance  CsZir (S n)  where+  zir = mkOp1 "zir"+++instance  CsZiw (S n)  where+  ziw = mkOp2 "ziw"+++instance  CsZiwm (S n)  where+  ziwm = mkOp2 "ziwm"+  ziwm' = mkOp3 "ziwm"+++instance  CsZkcl (S n)  where+  zkcl = mkOp2 "zkcl"+++instance  CsZkmod (S n)  where+  zkmod = mkOp2 "zkmod"+++instance  CsZkr (S n)  where+  zkr = mkOp1 "zkr"+++instance  CsZkw (S n)  where+  zkw = mkOp2 "zkw"+++instance  CsZkwm (S n)  where+  zkwm = mkOp2 "zkwm"+  zkwm' = mkOp3 "zkwm"
+ src/Language/XDsp/Implementations/HaskellNative.hs view
@@ -0,0 +1,197 @@+{-# LANGUAGE+     NoMonomorphismRestriction+    ,TypeFamilies+    ,DeriveFunctor+    ,DeriveDataTypeable+    ,GeneralizedNewtypeDeriving+    ,MultiParamTypeClasses+    ,FlexibleInstances+    ,OverlappingInstances #-}++module Language.XDsp.Implementations.HaskellNative++where++import           Language.XDsp.Semantics++import           Control.Applicative+import           Control.Monad.Reader+import           Data.Data+import           Data.Array.Unboxed++-- Basic audio evaluator++type RType = (Integer, Integer) -- SR, ksmps++defaultRType :: RType+defaultRType = (44100,16)++newtype HN a = HN { unHn :: Reader RType a }+  deriving (Functor, Applicative, Monad, Typeable)++evalHn :: HN a -> RType -> a+evalHn = runReader . unHn++instance MonadReader HN where+  type EnvType HN = RType+  ask = HN ask+  local f = HN . local f . unHn++instance Dsp HN where+  data (ASig HN) = HN_A (ZipList Double)+  data (KSig HN) = HN_K (ZipList Double)+  data (INum HN) = HN_I Double+  getSr    = fst <$> ask+  getKsmps = snd <$> ask++instance Constants HN where+  csig = return . HN_A . pure+  ckig = return . HN_K . pure+  cnst = return . HN_I++instance Show (ASig HN) where+  show _ = "audio signal"++instance Eq (ASig HN) where+  (HN_A z1) /= (HN_A z2) = getZipList z1 /= getZipList z2++instance Num (ASig HN) where+  (HN_A z1) + (HN_A z2) = HN_A $ (+) <$> z1 <*> z2+  (HN_A z1) * (HN_A z2) = HN_A $ (*) <$> z1 <*> z2+  abs    (HN_A z)       = HN_A $ abs <$> z+  signum (HN_A z)       = HN_A $ signum <$> z+  fromInteger           = HN_A . pure . fromInteger++instance Fractional (ASig HN) where+  (HN_A z1) / (HN_A z2) = HN_A $ (/) <$> z1 <*> z2+  fromRational = HN_A . pure . fromRational++instance Show (KSig HN) where+  show _ = "control signal"++instance Eq (KSig HN) where+  (HN_K z1) /= (HN_K z2) = getZipList z1 /= getZipList z2++instance Num (KSig HN) where+  (HN_K z1) + (HN_K z2) = HN_K $ (+) <$> z1 <*> z2+  (HN_K z1) * (HN_K z2) = HN_K $ (*) <$> z1 <*> z2+  abs    (HN_K z)       = HN_K $ abs <$> z+  signum (HN_K z)       = HN_K $ signum <$> z+  fromInteger           = HN_K . pure . fromInteger++instance Fractional (KSig HN) where+  (HN_K z1) / (HN_K z2) = HN_K $ (/) <$> z1 <*> z2+  fromRational = HN_K . pure . fromRational++instance Show (INum HN) where+  show _ = "control signal"++instance Eq (INum HN) where+  (HN_I z1) /= (HN_I z2) = z1 /= z2+  (HN_I z1) == (HN_I z2) = z1 == z2++instance Num (INum HN) where+  (HN_I z1) + (HN_I z2) = HN_I $ z1 + z2+  (HN_I z1) * (HN_I z2) = HN_I $ z1 * z2+  abs    (HN_I z)       = HN_I $ abs z+  signum (HN_I z)       = HN_I $ signum z+  fromInteger           = HN_I . fromInteger++instance Fractional (INum HN) where+  (HN_I z1) / (HN_I z2) = HN_I $ z1 / z2+  fromRational = HN_I . fromRational++instance Show s => Show (HN s) where+  show s = show $ evalHn s defaultRType++instance Eq s => Eq (HN s) where+  e1 == e2 = evalHn (liftM2 (==) e1 e2) defaultRType++instance Num e => Num (HN e) where+  (+)         = liftM2 (+)+  (*)         = liftM2 (*)+  abs         = fmap abs+  signum      = fmap signum+  fromInteger = pure . fromInteger++instance Fractional e => Fractional (HN e) where+  (/)          = liftM2 (/)+  recip        = fmap recip+  fromRational = pure . fromRational++-- ---------------------------------+-- ---------------------------------+-- basic language extensions++-- ---------------------------------+-- ---------------------------------+-- Buffers (function tables)++instance Buffer HN where+  type Buf HN = UArray Int Double+  emptyBuffer sz = return . listArray (0,sz-1) $ replicate sz 0++instance (Integral a) => BufferR HN Double a where+  lookupAt buf i = return $ buf ! (fromIntegral i)++lookupInterp :: UArray Int Double -> Double -> Double+lookupInterp arr d1 = v1 + frc * (v2-v1)+ where+  i  = floor d1+  v1 = arr ! i+  v2 = arr ! i+1+  frc = d1 - (fromIntegral i)++-- | table lookup with linear interpolation+instance BufferR HN Double Double where+  lookupAt buf ix = return $ lookupInterp buf ix++instance BufferR HN Double (INum HN) where+  lookupAt buf (HN_I ix) = lookupAt buf ix++instance BufferR HN (ASig HN) (ASig HN) where+  lookupAt buf (HN_A ix) = return . HN_A $ fmap (lookupInterp buf) ix++instance BufferR HN (KSig HN) (KSig HN) where+  lookupAt buf (HN_K ix) = return . HN_K $ fmap (lookupInterp buf) ix++-- ---------------------------------+-- ---------------------------------+-- phasor and oscillators++phasor' :: Integer -> Double -> Double -> Double+phasor' sr frq last = if next <= 1+  then next+  else next-(fromIntegral $ floor next)+ where next = last + (frq/(fromIntegral sr))++instance Phasor HN (KSig HN) (INum HN) where+  phasor (HN_I frq') = f frq' <$> getSr+   where f frq sr = let phsfn = phasor' sr frq+                        phs n = n : phs (phsfn n)+                    in HN_K . ZipList $ phs 0++instance Phasor HN (KSig HN) (KSig HN) where+  phasor (HN_K frq') = f frq' <$> getSr+   where f zk sr =+          let phs = ZipList $ 0 : getZipList ((phasor' sr) <$> zk <*> phs)+          in  HN_K phs++instance Phasor HN (ASig HN) (INum HN) where+  phasor (HN_I frq') = f frq' <$> getSr+   where f frq sr = let phsfn = phasor' sr frq+                        phs n = n : phs (phsfn n)+                    in HN_A . ZipList $ phs 0++instance Phasor HN (ASig HN) (ASig HN) where+  phasor (HN_A frq') = f frq' <$> getSr+   where f zk sr =+          let phs = ZipList $ 0 : getZipList ((phasor' sr) <$> zk <*> phs)+          in  HN_A phs++instance Phasor HN (ASig HN) (KSig HN) where+  phasor (HN_K (ZipList frq')) = f frq' <$> getSr <*> getKsmps+   where f k sr ksmps =+          let phs = replicate (fromIntegral ksmps) 0+                    : zipWith (\frq -> map (phasor' sr frq)) k phs+          in HN_A . ZipList $ concat phs
+ src/Language/XDsp/Semantics.hs view
@@ -0,0 +1,11 @@+module Language.XDsp.Semantics (+  module Language.XDsp.Semantics.Core+  ,module Language.XDsp.Semantics.BasicExtensions+  ,module Language.XDsp.Semantics.Extras+)++where++import Language.XDsp.Semantics.Core+import Language.XDsp.Semantics.BasicExtensions+import Language.XDsp.Semantics.Extras
+ src/Language/XDsp/Semantics/BasicExtensions.hs view
@@ -0,0 +1,114 @@+{-# LANGUAGE TypeFamilies+            ,MultiParamTypeClasses+            ,FlexibleContexts+            ,DeriveFunctor #-}++module Language.XDsp.Semantics.BasicExtensions (+  StringVar (..)+ ,Buffer (..)+ ,BufferR (..)+ ,VKtl (..)+ ,VBuf (..)+ ,LblBlock (..)+ ,NumArgs (..)+ ,TList (..)+ ,unTList+ ,unTList'+ ,unsafeTList+ ,defaultRunBlock+ ,Phasor (..)+ ,Oscil (..)+)++where++import           Language.XDsp.Semantics.Core+import           Data.TypeLevel.Num+++-- a few very common extensions.+++-- ---------------------------------+-- ---------------------------------+-- some basic extensions++-- | Support for string variables.+class Dsp repr => StringVar repr where+  data VString repr :: *++-- | Audio buffer or other data table.+class Dsp repr => Buffer repr where+  type Buf repr :: *+  emptyBuffer :: Int -> repr (Buf repr)++-- | Table lookup+class Buffer repr => BufferR repr out a where+  lookupAt :: Buf repr -> a -> repr out++-- | Creates a runnable labelled block.+-- This block can only be run at compile time.  Creating runnable blocks at+-- runtime is a to-be-implemented class.+class Dsp repr => LblBlock repr where+  type ArgTag repr :: * -- type-level number to tag the length of the arglist+  type ArgTyp repr :: * -- argument type+  data Block repr  :: *+  lblBlock :: Int -> repr a -> repr (Block repr)+  runBlock :: Block repr+              -> Double+              -> Double+              -> TList (ArgTag repr) (ArgTyp repr)+              -> repr ()++-- | Gets an argument from a runnable context+class (Nat n, Nat m, m :>=: n) => NumArgs repr m n where+  getArg :: n -> repr m (INum (repr m))++data TList n a = TList [a] deriving (Eq, Show, Functor)++defaultRunBlock ::+ (ArgTag repr ~ D3, LblBlock repr) =>+  Block repr+  -> Double+  -> Double+  -> repr ()+defaultRunBlock blk st dr = runBlock blk st dr tlist0++tlist0 :: TList D3 a+tlist0 = TList []++unTList :: TList n a -> [a]+unTList (TList l) = l++unTList' :: n -> TList n a -> [a]+unTList' _ = unTList++unsafeTList :: Nat n => n -> [a] -> TList n a+unsafeTList _ l = TList l++-- ---------------------------------+-- ---------------------------------+-- external input functions++-- | Get data from an external source+class Dsp repr => VKtl repr where+  vktl :: String -> repr (KSig repr)++-- | Create a sized buffer which is updated by an external source+class Buffer repr => VBuf repr where+  vbuf :: String -> Int -> repr (Buf repr)++-- ---------------------------------+-- ---------------------------------+-- basic audio++-- | Phasor (output sawtooth range 0-1 at specified frequency)+class Phasor repr out a where+  phasor :: a -> repr out++-- | A basic table-lookup oscillator, interpolating and non-interpolating+class Buffer repr => Oscil repr out a b where+  oscil  :: a -> b -> Buf repr -> repr out+  oscil' :: a -> b -> Buf repr -> INum repr -> repr out++
+ src/Language/XDsp/Semantics/Core.hs view
@@ -0,0 +1,30 @@+{-# LANGUAGE TypeFamilies, MultiParamTypeClasses #-}++module Language.XDsp.Semantics.Core++where++-- |Third version of tagless final csound interpreter+-- no de Bruijn indices, a monadic repr++class Dsp repr where+  data ASig repr :: *+  data KSig repr :: *+  data INum repr :: *+  getSr    :: repr Integer+  getKsmps :: repr Integer++-- |Create signals from constants.+class Dsp repr => Constants repr where+  cnst :: Double -> repr (INum repr)+  ckig :: Double -> repr (KSig repr)+  csig :: Double -> repr (ASig repr)++-- ---------------------------------+-- ---------------------------------+-- Very common extensions.++-- | Assign a signal to a named variable+class Dsp repr => Asn repr a where+  asn   :: a -> repr a+
+ src/Language/XDsp/Semantics/CsoundExt.hs view
@@ -0,0 +1,31 @@+module Language.XDsp.Semantics.CsoundExt (+  CsoundClass (..)+ ,Out (..)+ ,module Language.XDsp.Semantics.CsoundExt.All+)++where++import Language.XDsp.Semantics.Core+import Language.XDsp.Semantics.BasicExtensions++import Language.XDsp.Semantics.CsoundExt.Core+import Language.XDsp.Semantics.CsoundExt.All+++-- ---------------------------------+-- ---------------------------------+-- csound-specific language extensions.  Although these could be implemented+-- in other backends, doing so may be un-idiomatic++-- | Output classes+class Out repr where+  out  :: ASig repr -> repr ()+  outs :: ASig repr -> ASig repr -> repr ()+  outq :: ASig repr -> ASig repr+          -> ASig repr -> ASig repr -> repr ()+  outo :: ASig repr -> ASig repr+          -> ASig repr -> ASig repr+          -> ASig repr -> ASig repr+          -> ASig repr -> ASig repr -> repr ()+
+ src/Language/XDsp/Semantics/CsoundExt/All.hs view
@@ -0,0 +1,9938 @@+{-# LANGUAGE TypeFamilies, MultiParamTypeClasses, FlexibleContexts #-}++module Language.XDsp.Semantics.CsoundExt.All where++import Language.XDsp.Semantics.Core+import Language.XDsp.Semantics.CsoundExt.Core+import Language.XDsp.Semantics.Extras+import Language.XDsp.Semantics.BasicExtensions++class (CsoundClass repr) => CsATSadd repr  where+  aTSadd ::+    KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  aTSadd' :: KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsATSaddnz repr  where+  aTSaddnz ::+    KSig repr+    -> VString repr+    -> INum repr+    -> repr (ASig repr)+  aTSaddnz' :: KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsATSbufread repr  where+  aTSbufread ::+    KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> repr ()+  aTSbufread' :: KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsATScross repr  where+  aTScross ::+    KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  aTScross' :: KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsATSinfo repr  where+  aTSinfo ::+    VString repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsATSinterpread repr  where+  aTSinterpread ::+    KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsATSpartialtap repr  where+  aTSpartialtap ::+    INum repr+    -> repr (KSig repr, KSig repr)+++class (CsoundClass repr) => CsATSread repr  where+  aTSread ::+    KSig repr+    -> VString repr+    -> INum repr+    -> repr (KSig repr, KSig repr)+++class (CsoundClass repr) => CsATSreadnz repr  where+  aTSreadnz ::+    KSig repr+    -> VString repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsATSsinnoi repr  where+  aTSsinnoi ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> repr (ASig repr)+  aTSsinnoi' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsMixerClear repr  where+  mixerClear ::+    repr ()+++class (CsoundClass repr) => CsMixerGetLevel repr  where+  mixerGetLevel ::+    INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsMixerReceive repr  where+  mixerReceive ::+    INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsMixerSend repr  where+  mixerSend ::+    ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsMixerSetLevel repr  where+  mixerSetLevel ::+    INum repr+    -> INum repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsMixerSetLevel_i repr  where+  mixerSetLevel_i ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsACS repr  where+  aCS ::+    KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsAbs repr out a where+  abs ::+    a+    -> repr out+++class (CsoundClass repr) => CsAdd repr out a b where+  add ::+    a+    -> b+    -> repr out+++class (CsoundClass repr) => CsAdsr repr out  where+  adsr ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+  adsr' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsAdsyn repr  where+  adsyn ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> VString repr+    -> repr (ASig repr)+  adsyn' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsAdsynt repr  where+  adsynt ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  adsynt' :: KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsAdsynt2 repr  where+  adsynt2 ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  adsynt2' :: KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsAftouch repr  where+  aftouch ::+    repr (KSig repr)+  aftouch' :: INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsAlpass repr  where+  alpass ::+    ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  alpass' :: ASig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsAlwayson repr  where+  alwayson ::+    VString repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsAmpdb repr out a where+  ampdb ::+    a+    -> repr out+++class (CsoundClass repr) => CsAmpdbfs repr out a where+  ampdbfs ::+    a+    -> repr out+++class (CsoundClass repr) => CsAmpmidi repr  where+  ampmidi ::+    INum repr+    -> repr (INum repr)+  ampmidi' :: INum repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsAmpmidid repr out  where+  ampmidid ::+    KSig repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsAnd repr out a b where+  and ::+    a+    -> b+    -> repr out+++class (CsoundClass repr) => CsAreson repr  where+  areson ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  areson' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsAresonk repr  where+  aresonk ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr)+  aresonk' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsAtone repr  where+  atone ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+  atone' :: ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsAtonek repr  where+  atonek ::+    KSig repr+    -> KSig repr+    -> repr (KSig repr)+  atonek' :: KSig repr+    -> KSig repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsAtonex repr  where+  atonex ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+  atonex' :: ASig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsBabo repr  where+  babo ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+  babo' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsBalance repr  where+  balance ::+    ASig repr+    -> ASig repr+    -> repr (ASig repr)+  balance' :: ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsBamboo repr  where+  bamboo ::+    KSig repr+    -> INum repr+    -> repr (ASig repr)+  bamboo' :: KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsBarmodel repr  where+  barmodel ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsBbcutm repr  where+  bbcutm ::+    ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  bbcutm' :: ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsBbcuts repr  where+  bbcuts ::+    ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+  bbcuts' :: ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsBetarand repr out  where+  betarand ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr out+++class (CsoundClass repr) => CsBexprnd repr out  where+  bexprnd ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsBformdec repr d  where+  bformdec ::+    INum repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> [ASig repr]+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsBformdec1 repr d  where+  bformdec1 ::+    INum repr+    -> [ASig repr]+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsBformenc1 repr d  where+  bformenc1 ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsBinit repr  where+  binit ::+    FSig repr+    -> INum repr+    -> repr (FSig repr)+++class (CsoundClass repr) => CsBiquad repr  where+  biquad ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  biquad' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsBiquada repr  where+  biquada ::+    ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> repr (ASig repr)+  biquada' :: ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsBirnd repr out  where+  birnd ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsBqrez repr a b where+  bqrez ::+    ASig repr+    -> a+    -> b+    -> repr (ASig repr)+  bqrez' :: ASig repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsButbp repr  where+  butbp ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  butbp' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsButbr repr  where+  butbr ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  butbr' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsButhp repr  where+  buthp ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+  buthp' :: ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsButlp repr  where+  butlp ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+  butlp' :: ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsButterbp repr  where+  butterbp ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  butterbp' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsButterbr repr  where+  butterbr ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  butterbr' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsButterhp repr  where+  butterhp ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+  butterhp' :: ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsButterlp repr  where+  butterlp ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+  butterlp' :: ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsButton repr  where+  button ::+    KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsBuzz repr a b where+  buzz ::+    a+    -> b+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  buzz' :: a+    -> b+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsCabasa repr  where+  cabasa ::+    INum repr+    -> INum repr+    -> repr (ASig repr)+  cabasa' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsCauchy repr out  where+  cauchy ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsCeil repr out a where+  ceil ::+    a+    -> repr out+++class (CsoundClass repr) => CsCent repr out a where+  cent ::+    a+    -> repr out+++class (CsoundClass repr) => CsChanctrl repr out  where+  chanctrl ::+    INum repr+    -> INum repr+    -> repr out+  chanctrl' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsChanged repr  where+  changed ::+    [KSig repr]+    -> repr (KSig repr)+++class (CsoundClass repr) => CsChani repr out  where+  chani ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsChano repr a where+  chano ::+    a+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsChebyshevpoly repr  where+  chebyshevpoly ::+    ASig repr+    -> [KSig repr]+    -> repr (ASig repr)+++class (CsoundClass repr) => CsCheckbox repr  where+  checkbox ::+    KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsChn_S repr  where+  chn_S ::+    VString repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsChn_a repr  where+  chn_a ::+    VString repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsChn_k repr  where+  chn_k ::+    VString repr+    -> INum repr+    -> repr ()+  chn_k' :: VString repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsChnclear repr  where+  chnclear ::+    VString repr+    -> repr ()+++class (CsoundClass repr) => CsChnexport repr out  where+  chnexport ::+    VString repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsChnget repr out  where+  chnget ::+    VString repr+    -> repr out+++class (CsoundClass repr) => CsChnmix repr  where+  chnmix ::+    ASig repr+    -> VString repr+    -> repr ()+++class (CsoundClass repr) => CsChnrecv repr  where+  chnrecv ::+    VString repr+    -> repr ()+  chnrecv' :: VString repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsChnsend repr  where+  chnsend ::+    VString repr+    -> repr ()+  chnsend' :: VString repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsChnset repr a where+  chnset ::+    a+    -> VString repr+    -> repr ()+++class (CsoundClass repr) => CsClear repr  where+  clear ::+    [ASig repr]+    -> repr ()+++class (CsoundClass repr) => CsClfilt repr  where+  clfilt ::+    ASig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  clfilt' :: ASig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsClip repr  where+  clip ::+    ASig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  clip' :: ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsClockoff repr  where+  clockoff ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsClockon repr  where+  clockon ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsComb repr  where+  comb ::+    ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  comb' :: ASig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsCompress repr  where+  compress ::+    ASig repr+    -> ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsConnect repr  where+  connect ::+    VString repr+    -> VString repr+    -> VString repr+    -> VString repr+    -> repr ()+++class (CsoundClass repr) => CsControl repr  where+  control ::+    KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsConvle repr d  where+  convle ::+    ASig repr+    -> VString repr+    -> repr (TList d (ASig repr))+  convle' :: ASig repr+    -> VString repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsConvolve repr d  where+  convolve ::+    ASig repr+    -> VString repr+    -> repr (TList d (ASig repr))+  convolve' :: ASig repr+    -> VString repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsCos repr out a where+  cos ::+    a+    -> repr out+++class (CsoundClass repr) => CsCosh repr out a where+  cosh ::+    a+    -> repr out+++class (CsoundClass repr) => CsCosinv repr out a where+  cosinv ::+    a+    -> repr out+++class (CsoundClass repr) => CsCps2pch repr  where+  cps2pch ::+    INum repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsCpsmidi repr  where+  cpsmidi ::+    repr (INum repr)+++class (CsoundClass repr) => CsCpsmidib repr out  where+  cpsmidib ::+    repr out+  cpsmidib' :: INum repr+    -> repr out+++class (CsoundClass repr) => CsCpsmidinn repr out  where+  cpsmidinn ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsCpsoct repr out a where+  cpsoct ::+    a+    -> repr out+++class (CsoundClass repr) => CsCpspch repr out  where+  cpspch ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsCpstmid repr  where+  cpstmid ::+    INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsCpstun repr  where+  cpstun ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsCpstuni repr  where+  cpstuni ::+    INum repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsCpsxpch repr  where+  cpsxpch ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsCpuprc repr  where+  cpuprc ::+    VString repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsCross2 repr  where+  cross2 ::+    ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsCrossfm repr a b c d where+  crossfm ::+    a+    -> b+    -> c+    -> d+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+  crossfm' :: a+    -> b+    -> c+    -> d+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsCrossfmi repr a b c d where+  crossfmi ::+    a+    -> b+    -> c+    -> d+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+  crossfmi' :: a+    -> b+    -> c+    -> d+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsCrossfmpm repr a b c d where+  crossfmpm ::+    a+    -> b+    -> c+    -> d+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+  crossfmpm' :: a+    -> b+    -> c+    -> d+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsCrossfmpmi repr a b c d where+  crossfmpmi ::+    a+    -> b+    -> c+    -> d+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+  crossfmpmi' :: a+    -> b+    -> c+    -> d+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsCrosspm repr a b c d where+  crosspm ::+    a+    -> b+    -> c+    -> d+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+  crosspm' :: a+    -> b+    -> c+    -> d+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsCrosspmi repr a b c d where+  crosspmi ::+    a+    -> b+    -> c+    -> d+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+  crosspmi' :: a+    -> b+    -> c+    -> d+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsCrunch repr  where+  crunch ::+    INum repr+    -> INum repr+    -> repr (ASig repr)+  crunch' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsCtlchn repr  where+  ctlchn ::+    repr (KSig repr, KSig repr, KSig repr)+  ctlchn' :: INum repr+    -> INum repr+    -> repr (KSig repr, KSig repr, KSig repr)+++class (CsoundClass repr) => CsCtrl14 repr out  where+  ctrl14 ::+    INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> repr out+  ctrl14' :: INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsCtrl21 repr out  where+  ctrl21 ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> repr out+  ctrl21' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsCtrl7 repr out  where+  ctrl7 ::+    INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> repr out+  ctrl7' :: INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsCtrlinit repr  where+  ctrlinit ::+    INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsCuserrnd repr out  where+  cuserrnd ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr out+++class (CsoundClass repr) => CsDam repr  where+  dam ::+    ASig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDate repr  where+  date ::+    repr (INum repr)+++class (CsoundClass repr) => CsDates repr  where+  dates ::+    repr (VString repr)+  dates' :: INum repr+    -> repr (VString repr)+++class (CsoundClass repr) => CsDb repr out a where+  db ::+    a+    -> repr out+++class (CsoundClass repr) => CsDbamp repr out  where+  dbamp ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsDbfsamp repr out  where+  dbfsamp ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsDcblock repr  where+  dcblock ::+    ASig repr+    -> repr (ASig repr)+  dcblock' :: ASig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDcblock2 repr  where+  dcblock2 ::+    ASig repr+    -> repr (ASig repr)+  dcblock2' :: ASig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDconv repr  where+  dconv ::+    ASig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDelay repr  where+  delay ::+    ASig repr+    -> INum repr+    -> repr (ASig repr)+  delay' :: ASig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDelay1 repr  where+  delay1 ::+    ASig repr+    -> repr (ASig repr)+  delay1' :: ASig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDelayk repr  where+  delayk ::+    KSig repr+    -> INum repr+    -> repr (KSig repr)+  delayk' :: KSig repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsDelayw repr  where+  delayw ::+    ASig repr+    -> repr ()+++class (CsoundClass repr) => CsDeltap repr  where+  deltap ::+    KSig repr+    -> repr (ASig repr)+  deltap' :: KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDeltap3 repr a where+  deltap3 ::+    a+    -> repr (ASig repr)+  deltap3' :: a+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDeltapi repr a where+  deltapi ::+    a+    -> repr (ASig repr)+  deltapi' :: a+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDeltapn repr a where+  deltapn ::+    a+    -> repr (ASig repr)+  deltapn' :: a+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDeltapx repr  where+  deltapx ::+    ASig repr+    -> INum repr+    -> repr (ASig repr)+  deltapx' :: ASig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDeltapxw repr  where+  deltapxw ::+    ASig repr+    -> ASig repr+    -> INum repr+    -> repr ()+  deltapxw' :: ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsDenorm repr  where+  denorm ::+    [ASig repr]+    -> repr ()+++class (CsoundClass repr) => CsDiff repr out a where+  diff ::+    a+    -> repr out+  diff' :: a+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsDiskgrain repr d  where+  diskgrain ::+    VString repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+  diskgrain' :: VString repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsDiskin repr d  where+  diskin ::+    VString repr+    -> KSig repr+    -> repr (TList d (ASig repr))+  diskin' :: VString repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsDiskin2 repr d  where+  diskin2 ::+    VString repr+    -> KSig repr+    -> repr (TList d (ASig repr))+  diskin2' :: VString repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsDistort repr  where+  distort ::+    ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  distort' :: ASig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDistort1 repr  where+  distort1 ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  distort1' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDiv repr out a b where+  div ::+    a+    -> b+    -> repr out+++class (CsoundClass repr) => CsDivz repr out a b where+  divz ::+    a+    -> b+    -> KSig repr+    -> repr out+++class (CsoundClass repr) => CsDoppler repr  where+  doppler ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  doppler' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDownsamp repr  where+  downsamp ::+    ASig repr+    -> repr (KSig repr)+  downsamp' :: ASig repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsDripwater repr  where+  dripwater ::+    KSig repr+    -> INum repr+    -> repr (ASig repr)+  dripwater' :: KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsDumpk repr  where+  dumpk ::+    KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsDumpk2 repr  where+  dumpk2 ::+    KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsDumpk3 repr  where+  dumpk3 ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsDumpk4 repr  where+  dumpk4 ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsDuserrnd repr out  where+  duserrnd ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsEndin repr  where+  endin ::+    repr ()+++class (CsoundClass repr) => CsEndop repr  where+  endop ::+    repr ()+++class (CsoundClass repr) => CsEnvlpx repr out a where+  envlpx ::+    a+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+  envlpx' :: a+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsEnvlpxr repr out a where+  envlpxr ::+    a+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+  envlpxr' :: a+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsEphasor repr out a where+  ephasor ::+    a+    -> KSig repr+    -> repr (out,out)+  ephasor' :: a+    -> KSig repr+    -> INum repr+    -> repr (out,out)+++class (CsoundClass repr) => CsEqfil repr  where+  eqfil ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  eqfil' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsEvent_i repr  where+  event_i ::+    VString repr+    -> VString repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsExitnow repr  where+  exitnow ::+    repr ()+++class (CsoundClass repr) => CsExp repr out a where+  exp ::+    a+    -> repr out+++class (CsoundClass repr) => CsExpcurve repr  where+  expcurve ::+    KSig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsExpon repr out  where+  expon ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsExprand repr out  where+  exprand ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsExpseg repr out  where+  expseg ::+    INum repr+    -> INum repr+    -> INum repr+    -> [(INum repr, INum repr)]+    -> repr out+++class (CsoundClass repr) => CsExpsega repr  where+  expsega ::+    INum repr+    -> INum repr+    -> INum repr+    -> [(INum repr, INum repr)]+    -> repr (ASig repr)+++class (CsoundClass repr) => CsExpsegr repr out  where+  expsegr ::+    INum repr+    -> INum repr+    -> INum repr+    -> [(INum repr, INum repr)]+    -> repr out+++class (CsoundClass repr) => CsFiclose repr  where+  ficlose ::+    VString repr+    -> repr ()+++class (CsoundClass repr) => CsFilebit repr  where+  filebit ::+    VString repr+    -> repr (INum repr)+  filebit' :: VString repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsFilelen repr  where+  filelen ::+    VString repr+    -> repr (INum repr)+  filelen' :: VString repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsFilenchnls repr  where+  filenchnls ::+    VString repr+    -> repr (INum repr)+  filenchnls' :: VString repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsFilepeak repr  where+  filepeak ::+    VString repr+    -> repr (INum repr)+  filepeak' :: VString repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsFilesr repr  where+  filesr ::+    VString repr+    -> repr (INum repr)+  filesr' :: VString repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsFilevalid repr  where+  filevalid ::+    VString repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsFilter2 repr out a where+  filter2 ::+    a+    -> INum repr+    -> INum repr+    -> [INum repr]+    -> repr out+++class (CsoundClass repr) => CsFin repr  where+  fin ::+    VString repr+    -> INum repr+    -> INum repr+    -> [ASig repr]+    -> repr ()+++class (CsoundClass repr) => CsFini repr  where+  fini ::+    VString repr+    -> INum repr+    -> INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsFink repr  where+  fink ::+    VString repr+    -> INum repr+    -> INum repr+    -> [KSig repr]+    -> repr ()+++class (CsoundClass repr) => CsFiopen repr  where+  fiopen ::+    VString repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsFlanger repr  where+  flanger ::+    ASig repr+    -> ASig repr+    -> KSig repr+    -> repr (ASig repr)+  flanger' :: ASig repr+    -> ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFlashtxt repr  where+  flashtxt ::+    INum repr+    -> VString repr+    -> repr ()+++class (CsoundClass repr) => CsFlooper repr  where+  flooper ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFlooper2 repr a where+  flooper2 ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  flooper2' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> a+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFlooper3 repr  where+  flooper3 ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  flooper3' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFloor repr out a where+  floor ::+    a+    -> repr out+++class (CsoundClass repr) => CsFmb3 repr  where+  fmb3 ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFmbell repr  where+  fmbell ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFmmetal repr  where+  fmmetal ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFmpercfl repr  where+  fmpercfl ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFmrhode repr  where+  fmrhode ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFmvoice repr  where+  fmvoice ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFmwurlie repr  where+  fmwurlie ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFof repr a b c where+  fof ::+    a+    -> b+    -> c+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  fof' :: a+    -> b+    -> c+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFof2 repr a b c where+  fof2 ::+    a+    -> b+    -> c+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  fof2' :: a+    -> b+    -> c+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFofilter repr  where+  fofilter ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  fofilter' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFog repr a b c where+  fog ::+    a+    -> b+    -> c+    -> ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  fog' :: a+    -> b+    -> c+    -> ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFold repr  where+  fold ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFollow repr  where+  follow ::+    ASig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFollow2 repr  where+  follow2 ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFoscil repr a b c where+  foscil ::+    a+    -> KSig repr+    -> b+    -> c+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  foscil' :: a+    -> KSig repr+    -> b+    -> c+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFoscili repr a b c where+  foscili ::+    a+    -> KSig repr+    -> b+    -> c+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  foscili' :: a+    -> KSig repr+    -> b+    -> c+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsFout repr  where+  fout ::+    VString repr+    -> INum repr+    -> [ASig repr]+    -> repr ()+++class (CsoundClass repr) => CsFouti repr  where+  fouti ::+    INum repr+    -> INum repr+    -> INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsFoutir repr  where+  foutir ::+    INum repr+    -> INum repr+    -> INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsFoutk repr  where+  foutk ::+    VString repr+    -> INum repr+    -> [KSig repr]+    -> repr ()+++class (CsoundClass repr) => CsFprintks repr a where+  fprintks ::+    VString repr+    -> VString repr+    -> [a]+    -> repr ()+++class (CsoundClass repr) => CsFprints repr a where+  fprints ::+    VString repr+    -> VString repr+    -> [a]+    -> repr ()+++class (CsoundClass repr) => CsFrac repr out a where+  frac ::+    a+    -> repr out+++class (CsoundClass repr) => CsFreeverb repr  where+  freeverb ::+    ASig repr+    -> ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr, ASig repr)+  freeverb' :: ASig repr+    -> ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsFtchnls repr  where+  ftchnls ::+    INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsFtconv repr d  where+  ftconv ::+    ASig repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+  ftconv' :: ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsFtcps repr  where+  ftcps ::+    INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsFtfree repr  where+  ftfree ::+    INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsFtgen repr  where+  ftgen ::+    INum repr+    -> INum repr+    -> INum repr+    -> VString repr+    -> VString repr+    -> [INum repr]+    -> repr (INum repr)+++class (CsoundClass repr) => CsFtgenonce repr  where+  ftgenonce ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> VString repr+    -> [INum repr]+    -> repr (INum repr)+++class (CsoundClass repr) => CsFtgentmp repr  where+  ftgentmp ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> VString repr+    -> [INum repr]+    -> repr (INum repr)+++class (CsoundClass repr) => CsFtlen repr  where+  ftlen ::+    INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsFtload repr  where+  ftload ::+    VString repr+    -> INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsFtloadk repr  where+  ftloadk ::+    VString repr+    -> KSig repr+    -> INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsFtlptim repr  where+  ftlptim ::+    INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsFtmorf repr  where+  ftmorf ::+    KSig repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsFtsave repr  where+  ftsave ::+    VString repr+    -> INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsFtsavek repr  where+  ftsavek ::+    VString repr+    -> KSig repr+    -> INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsFtsr repr  where+  ftsr ::+    INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsGain repr  where+  gain ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+  gain' :: ASig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsGainslider repr  where+  gainslider ::+    KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsGauss repr out  where+  gauss ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsGbuzz repr a b where+  gbuzz ::+    a+    -> b+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  gbuzz' :: a+    -> b+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsGetcfg repr  where+  getcfg ::+    INum repr+    -> repr (VString repr)+++class (CsoundClass repr) => CsGogobel repr  where+  gogobel ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsGrain repr a b c where+  grain ::+    a+    -> b+    -> c+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  grain' :: a+    -> b+    -> c+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsGrain2 repr  where+  grain2 ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  grain2' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsGrain3 repr  where+  grain3 ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  grain3' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsGranule repr a where+  granule ::+    a+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  granule' :: a+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsGuiro repr  where+  guiro ::+    KSig repr+    -> INum repr+    -> repr (ASig repr)+  guiro' :: KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsHarmon repr  where+  harmon ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsHarmon2 repr  where+  harmon2 ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  harmon2' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsHarmon3 repr  where+  harmon3 ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  harmon3' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsHarmon4 repr  where+  harmon4 ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  harmon4' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsHilbert repr  where+  hilbert ::+    ASig repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsHrtfer repr  where+  hrtfer ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> VString repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsHrtfmove repr  where+  hrtfmove ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> VString repr+    -> VString repr+    -> repr (ASig repr, ASig repr)+  hrtfmove' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> VString repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsHrtfmove2 repr  where+  hrtfmove2 ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> VString repr+    -> VString repr+    -> repr (ASig repr, ASig repr)+  hrtfmove2' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> VString repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsHrtfstat repr  where+  hrtfstat ::+    ASig repr+    -> INum repr+    -> INum repr+    -> VString repr+    -> VString repr+    -> repr (ASig repr, ASig repr)+  hrtfstat' :: ASig repr+    -> INum repr+    -> INum repr+    -> VString repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsHsboscil repr  where+  hsboscil ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  hsboscil' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsHvs1 repr  where+  hvs1 ::+    KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  hvs1' :: KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsHvs2 repr  where+  hvs2 ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  hvs2' :: KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsHvs3 repr  where+  hvs3 ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  hvs3' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsICS repr  where+  iCS ::+    KSig repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsIhold repr  where+  ihold ::+    repr ()+++class (CsoundClass repr) => CsInCS repr  where+  inCS ::+    repr (ASig repr)+++class (CsoundClass repr) => CsInch repr d  where+  inch ::+    [KSig repr]+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsInitc14 repr  where+  initc14 ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsInitc21 repr  where+  initc21 ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsInitc7 repr  where+  initc7 ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsInleta repr  where+  inleta ::+    VString repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsInletf repr  where+  inletf ::+    VString repr+    -> repr (FSig repr)+++class (CsoundClass repr) => CsInletk repr  where+  inletk ::+    VString repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsInq repr  where+  inq ::+    repr (ASig repr, ASig repr, ASig repr, ASig repr)+++class (CsoundClass repr) => CsInrg repr  where+  inrg ::+    KSig repr+    -> [ASig repr]+    -> repr ()+++class (CsoundClass repr) => CsIns repr  where+  ins ::+    repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsInsglobal repr  where+  insglobal ::+    VString repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsInsremot repr  where+  insremot ::+    VString repr+    -> VString repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsInstr repr  where+  instr ::+    repr ()+++class (CsoundClass repr) => CsInt repr out a where+  int ::+    a+    -> repr out+++class (CsoundClass repr) => CsInteg repr out a where+  integ ::+    a+    -> repr out+  integ' :: a+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsInterp repr  where+  interp ::+    KSig repr+    -> repr (ASig repr)+  interp' :: KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsInvalue repr out  where+  invalue ::+    VString repr+    -> repr out+++class (CsoundClass repr) => CsInz repr  where+  inz ::+    KSig repr+    -> repr ()+++class (CsoundClass repr) => CsJitter repr  where+  jitter ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsJitter2 repr  where+  jitter2 ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsJspline repr out a where+  jspline ::+    a+    -> KSig repr+    -> KSig repr+    -> repr out+++class (CsoundClass repr) => CsKCS repr  where+  kCS ::+    INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsKtableseg repr  where+  ktableseg ::+    INum repr+    -> INum repr+    -> INum repr+    -> [(INum repr, INum repr)]+    -> repr ()+++class (CsoundClass repr) => CsLfo repr out  where+  lfo ::+    KSig repr+    -> KSig repr+    -> repr out+  lfo' :: KSig repr+    -> KSig repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsLimit repr out a where+  limit ::+    a+    -> KSig repr+    -> KSig repr+    -> repr out+++class (CsoundClass repr) => CsLine repr out  where+  line ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsLinen repr out a where+  linen ::+    a+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsLinenr repr out a where+  linenr ::+    a+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsLineto repr  where+  lineto ::+    KSig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsLinrand repr out  where+  linrand ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsLinseg repr out  where+  linseg ::+    INum repr+    -> INum repr+    -> INum repr+    -> [(INum repr, INum repr)]+    -> repr out+++class (CsoundClass repr) => CsLinsegr repr out  where+  linsegr ::+    INum repr+    -> INum repr+    -> INum repr+    -> [(INum repr, INum repr)]+    -> repr out+++class (CsoundClass repr) => CsLocsend repr d  where+  locsend ::+    repr (TList d (ASig repr))+++class (CsoundClass repr) => CsLocsig repr d  where+  locsig ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsLog repr out a where+  log ::+    a+    -> repr out+++class (CsoundClass repr) => CsLog10 repr out a where+  log10 ::+    a+    -> repr out+++class (CsoundClass repr) => CsLogbtwo repr out a where+  logbtwo ::+    a+    -> repr out+++class (CsoundClass repr) => CsLogcurve repr  where+  logcurve ::+    KSig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsLoopseg repr  where+  loopseg ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> [KSig repr]+    -> repr (KSig repr)+++class (CsoundClass repr) => CsLoopsegp repr  where+  loopsegp ::+    KSig repr+    -> [KSig repr]+    -> repr (KSig repr)+++class (CsoundClass repr) => CsLooptseg repr  where+  looptseg ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> [KSig repr]+    -> repr (KSig repr)+++class (CsoundClass repr) => CsLoopxseg repr  where+  loopxseg ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> [KSig repr]+    -> repr (KSig repr)+++class (CsoundClass repr) => CsLorenz repr  where+  lorenz ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr)+  lorenz' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr)+++class (CsoundClass repr) => CsLorismorph repr  where+  lorismorph ::+    INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsLorisplay repr  where+  lorisplay ::+    INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsLorisread repr  where+  lorisread ::+    KSig repr+    -> VString repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+  lorisread' :: KSig repr+    -> VString repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsLoscil repr d a where+  loscil ::+    a+    -> KSig repr+    -> INum repr+    -> repr (TList d (ASig repr))+  loscil' :: a+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsLoscil3 repr d a where+  loscil3 ::+    a+    -> KSig repr+    -> INum repr+    -> repr (TList d (ASig repr))+  loscil3' :: a+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsLoscilx repr d a where+  loscilx ::+    a+    -> KSig repr+    -> VString repr+    -> repr (TList d (ASig repr))+  loscilx' :: a+    -> KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsLowpass2 repr  where+  lowpass2 ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  lowpass2' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsLowres repr  where+  lowres ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  lowres' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsLowresx repr  where+  lowresx ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  lowresx' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsLpf18 repr  where+  lpf18 ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsLpform repr  where+  lpform ::+    KSig repr+    -> repr (KSig repr, KSig repr)+++class (CsoundClass repr) => CsLpfreson repr  where+  lpfreson ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsLphasor repr a where+  lphasor ::+    a+    -> repr (ASig repr)+  lphasor' :: a+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsLpinterp repr  where+  lpinterp ::+    INum repr+    -> INum repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsLposcil repr  where+  lposcil ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  lposcil' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsLposcil3 repr  where+  lposcil3 ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  lposcil3' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsLposcila repr  where+  lposcila ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  lposcila' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsLposcilsa repr  where+  lposcilsa ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+  lposcilsa' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsLposcilsa2 repr  where+  lposcilsa2 ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+  lposcilsa2' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsLpread repr  where+  lpread ::+    KSig repr+    -> VString repr+    -> repr (KSig repr, KSig repr, KSig repr, KSig repr)+  lpread' :: KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr, KSig repr, KSig repr, KSig repr)+++class (CsoundClass repr) => CsLpreson repr  where+  lpreson ::+    ASig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsLpshold repr  where+  lpshold ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> [KSig repr]+    -> repr (KSig repr)+++class (CsoundClass repr) => CsLpsholdp repr  where+  lpsholdp ::+    KSig repr+    -> [KSig repr]+    -> repr (KSig repr)+++class (CsoundClass repr) => CsLpslot repr  where+  lpslot ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsMac repr  where+  mac ::+    [(KSig repr, ASig repr)]+    -> repr (ASig repr)+++class (CsoundClass repr) => CsMaca repr  where+  maca ::+    [ASig repr]+    -> repr (ASig repr)+++class (CsoundClass repr) => CsMadsr repr out  where+  madsr ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+  madsr' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsMandel repr  where+  mandel ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr, KSig repr)+++class (CsoundClass repr) => CsMandol repr  where+  mandol ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  mandol' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsMarimba repr  where+  marimba ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  marimba' :: KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsMassign repr  where+  massign ::+    INum repr+    -> VString repr+    -> repr ()+  massign' :: INum repr+    -> VString repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsMax_k repr  where+  max_k ::+    ASig repr+    -> KSig repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsMaxabsaccum repr  where+  maxabsaccum ::+    ASig repr+    -> ASig repr+    -> repr ()+++class (CsoundClass repr) => CsMaxaccum repr  where+  maxaccum ::+    ASig repr+    -> ASig repr+    -> repr ()+++class (CsoundClass repr) => CsMaxalloc repr  where+  maxalloc ::+    VString repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsMaxk repr  where+  maxk ::+    ASig repr+    -> KSig repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsMclock repr  where+  mclock ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsMdelay repr  where+  mdelay ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsMedian repr  where+  median ::+    ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  median' :: ASig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsMediank repr  where+  mediank ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> repr (KSig repr)+  mediank' :: KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsMetro repr  where+  metro ::+    KSig repr+    -> repr (KSig repr)+  metro' :: KSig repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsMidglobal repr  where+  midglobal ::+    VString repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsMidic14 repr out  where+  midic14 ::+    INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> repr out+  midic14' :: INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsMidic21 repr out  where+  midic21 ::+    INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> repr out+  midic21' :: INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsMidic7 repr out  where+  midic7 ::+    INum repr+    -> KSig repr+    -> KSig repr+    -> repr out+  midic7' :: INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsMidichannelaftertouch repr a where+  midichannelaftertouch ::+    a+    -> repr ()+  midichannelaftertouch' :: a+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsMidichn repr  where+  midichn ::+    repr (INum repr)+++class (CsoundClass repr) => CsMidicontrolchange repr a b where+  midicontrolchange ::+    a+    -> b+    -> repr ()+  midicontrolchange' :: a+    -> b+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsMidictrl repr out  where+  midictrl ::+    INum repr+    -> repr out+  midictrl' :: INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsMididefault repr a b where+  mididefault ::+    a+    -> b+    -> repr ()+++class (CsoundClass repr) => CsMidiin repr  where+  midiin ::+    repr (KSig repr, KSig repr, KSig repr, KSig repr)+++class (CsoundClass repr) => CsMidinoteoff repr a b where+  midinoteoff ::+    a+    -> b+    -> repr ()+++class (CsoundClass repr) => CsMidinoteoncps repr a b where+  midinoteoncps ::+    a+    -> b+    -> repr ()+++class (CsoundClass repr) => CsMidinoteonkey repr a b where+  midinoteonkey ::+    a+    -> b+    -> repr ()+++class (CsoundClass repr) => CsMidinoteonoct repr a b where+  midinoteonoct ::+    a+    -> b+    -> repr ()+++class (CsoundClass repr) => CsMidinoteonpch repr a b where+  midinoteonpch ::+    a+    -> b+    -> repr ()+++class (CsoundClass repr) => CsMidion repr  where+  midion ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsMidion2 repr  where+  midion2 ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsMidiout repr  where+  midiout ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsMidipgm repr  where+  midipgm ::+    repr (INum repr)+  midipgm' :: INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsMidipitchbend repr a where+  midipitchbend ::+    a+    -> repr ()+  midipitchbend' :: a+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsMidipolyaftertouch repr a b where+  midipolyaftertouch ::+    a+    -> b+    -> repr ()+  midipolyaftertouch' :: a+    -> b+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsMidiprogramchange repr a where+  midiprogramchange ::+    a+    -> repr ()+++class (CsoundClass repr) => CsMiditempo repr  where+  miditempo ::+    repr (KSig repr)+++class (CsoundClass repr) => CsMidremot repr  where+  midremot ::+    VString repr+    -> VString repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsMinabsaccum repr  where+  minabsaccum ::+    ASig repr+    -> ASig repr+    -> repr ()+++class (CsoundClass repr) => CsMinaccum repr  where+  minaccum ::+    ASig repr+    -> ASig repr+    -> repr ()+++class (CsoundClass repr) => CsMincer repr d  where+  mincer ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (TList d (ASig repr))+  mincer' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsMirror repr out a where+  mirror ::+    a+    -> KSig repr+    -> KSig repr+    -> repr out+++class (CsoundClass repr) => CsMod repr out a b where+  mod ::+    a+    -> b+    -> repr out+++class (CsoundClass repr) => CsMode repr  where+  mode ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  mode' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsModmatrix repr  where+  modmatrix ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsMonitor repr d  where+  monitor ::+    repr (TList d (ASig repr))+++class (CsoundClass repr) => CsMoog repr  where+  moog ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsMoogladder repr  where+  moogladder ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  moogladder' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsMoogvcf repr a b where+  moogvcf ::+    ASig repr+    -> a+    -> b+    -> repr (ASig repr)+  moogvcf' :: ASig repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsMoogvcf2 repr a b where+  moogvcf2 ::+    ASig repr+    -> a+    -> b+    -> repr (ASig repr)+  moogvcf2' :: ASig repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsMoscil repr  where+  moscil ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsMpulse repr  where+  mpulse ::+    KSig repr+    -> KSig repr+    -> repr (ASig repr)+  mpulse' :: KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsMrtmsg repr  where+  mrtmsg ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsMul repr out a b where+  mul ::+    a+    -> b+    -> repr out+++class (CsoundClass repr) => CsMultitap repr  where+  multitap ::+    ASig repr+    -> [INum repr]+    -> repr (ASig repr)+++class (CsoundClass repr) => CsMute repr  where+  mute ::+    VString repr+    -> repr ()+  mute' :: VString repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsMutex_lock repr  where+  mutex_lock ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsMutex_locki repr  where+  mutex_locki ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsMutex_unlock repr  where+  mutex_unlock ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsMutex_unlocki repr  where+  mutex_unlocki ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsMxadsr repr out  where+  mxadsr ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+  mxadsr' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsNestedap repr  where+  nestedap ::+    ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  nestedap' :: ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsNlalp repr  where+  nlalp ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  nlalp' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsNlfilt repr  where+  nlfilt ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsNoise repr a where+  noise ::+    a+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsNot repr out a where+  not ::+    a+    -> repr out+++class (CsoundClass repr) => CsNoteoff repr  where+  noteoff ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsNoteon repr  where+  noteon ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsNoteondur repr  where+  noteondur ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsNoteondur2 repr  where+  noteondur2 ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsNotnum repr  where+  notnum ::+    repr (INum repr)+++class (CsoundClass repr) => CsNreverb repr  where+  nreverb ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  nreverb' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsNrpn repr  where+  nrpn ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsNsamp repr  where+  nsamp ::+    INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsNstrnum repr  where+  nstrnum ::+    VString repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsNtrpol repr out a b where+  ntrpol ::+    a+    -> b+    -> KSig repr+    -> repr out+  ntrpol' :: a+    -> b+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsOctave repr out a where+  octave ::+    a+    -> repr out+++class (CsoundClass repr) => CsOctcps repr out  where+  octcps ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsOctmidi repr  where+  octmidi ::+    repr (INum repr)+++class (CsoundClass repr) => CsOctmidib repr out  where+  octmidib ::+    repr out+  octmidib' :: INum repr+    -> repr out+++class (CsoundClass repr) => CsOctmidinn repr out  where+  octmidinn ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsOctpch repr out  where+  octpch ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsOpcode repr  where+  opcode ::+    repr ()+++class (CsoundClass repr) => CsOr repr out a b where+  or ::+    a+    -> b+    -> repr out+++class (CsoundClass repr) => CsOscbnk repr  where+  oscbnk ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> repr (ASig repr)+  oscbnk' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsOscil repr out a b where+  oscil ::+    a+    -> b+    -> INum repr+    -> repr out+  oscil' :: a+    -> b+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsOscil1 repr  where+  oscil1 ::+    INum repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsOscil1i repr  where+  oscil1i ::+    INum repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsOscil3 repr out a b where+  oscil3 ::+    a+    -> b+    -> INum repr+    -> repr out+  oscil3' :: a+    -> b+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsOscili repr out a b where+  oscili ::+    a+    -> b+    -> INum repr+    -> repr out+  oscili' :: a+    -> b+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsOscilikt repr out a b where+  oscilikt ::+    a+    -> b+    -> KSig repr+    -> repr out+  oscilikt' :: a+    -> b+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsOsciliktp repr  where+  osciliktp ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  osciliktp' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsOscilikts repr a b where+  oscilikts ::+    a+    -> b+    -> KSig repr+    -> ASig repr+    -> KSig repr+    -> repr (ASig repr)+  oscilikts' :: a+    -> b+    -> KSig repr+    -> ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsOsciln repr  where+  osciln ::+    KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsOscils repr  where+  oscils ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  oscils' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsOscilx repr  where+  oscilx ::+    KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsOut32 repr  where+  out32 ::+    ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> repr ()+++class (CsoundClass repr) => CsOutc repr  where+  outc ::+    [ASig repr]+    -> repr ()+++class (CsoundClass repr) => CsOutch repr  where+  outch ::+    [(KSig repr, ASig repr)]+    -> repr ()+++class (CsoundClass repr) => CsOuth repr  where+  outh ::+    ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> repr ()+++class (CsoundClass repr) => CsOutiat repr  where+  outiat ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsOutic repr  where+  outic ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsOutic14 repr  where+  outic14 ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsOutipat repr  where+  outipat ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsOutipb repr  where+  outipb ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsOutipc repr  where+  outipc ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsOutkat repr  where+  outkat ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsOutkc repr  where+  outkc ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsOutkc14 repr  where+  outkc14 ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsOutkpat repr  where+  outkpat ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsOutkpb repr  where+  outkpb ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsOutkpc repr  where+  outkpc ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsOutleta repr  where+  outleta ::+    VString repr+    -> ASig repr+    -> repr ()+++class (CsoundClass repr) => CsOutletf repr  where+  outletf ::+    VString repr+    -> FSig repr+    -> repr ()+++class (CsoundClass repr) => CsOutletk repr  where+  outletk ::+    VString repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsOutq1 repr  where+  outq1 ::+    ASig repr+    -> repr ()+++class (CsoundClass repr) => CsOutq2 repr  where+  outq2 ::+    ASig repr+    -> repr ()+++class (CsoundClass repr) => CsOutq3 repr  where+  outq3 ::+    ASig repr+    -> repr ()+++class (CsoundClass repr) => CsOutq4 repr  where+  outq4 ::+    ASig repr+    -> repr ()+++class (CsoundClass repr) => CsOutrg repr  where+  outrg ::+    KSig repr+    -> [ASig repr]+    -> repr ()+++class (CsoundClass repr) => CsOuts1 repr  where+  outs1 ::+    ASig repr+    -> repr ()+++class (CsoundClass repr) => CsOuts2 repr  where+  outs2 ::+    ASig repr+    -> repr ()+++class (CsoundClass repr) => CsOutx repr  where+  outx ::+    ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> repr ()+++class (CsoundClass repr) => CsOutz repr  where+  outz ::+    KSig repr+    -> repr ()+++class (CsoundClass repr) => CsP repr out  where+  p ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsPan repr  where+  pan ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+  pan' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+++class (CsoundClass repr) => CsPan2 repr a where+  pan2 ::+    ASig repr+    -> a+    -> repr (ASig repr, ASig repr)+  pan2' :: ASig repr+    -> a+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsPareq repr  where+  pareq ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  pareq' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPartials repr  where+  partials ::+    FSig repr+    -> FSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (FSig repr)+++class (CsoundClass repr) => CsPcauchy repr out  where+  pcauchy ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsPchbend repr out  where+  pchbend ::+    repr out+  pchbend' :: INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsPchmidi repr  where+  pchmidi ::+    repr (INum repr)+++class (CsoundClass repr) => CsPchmidib repr out  where+  pchmidib ::+    repr out+  pchmidib' :: INum repr+    -> repr out+++class (CsoundClass repr) => CsPchmidinn repr out  where+  pchmidinn ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsPchoct repr out  where+  pchoct ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsPconvolve repr d  where+  pconvolve ::+    ASig repr+    -> VString repr+    -> repr (TList d (ASig repr))+  pconvolve' :: ASig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsPcount repr  where+  pcount ::+    repr (INum repr)+++class (CsoundClass repr) => CsPdclip repr  where+  pdclip ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  pdclip' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPdhalf repr  where+  pdhalf ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+  pdhalf' :: ASig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPdhalfy repr  where+  pdhalfy ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+  pdhalfy' :: ASig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPeak repr a where+  peak ::+    a+    -> repr (KSig repr)+++class (CsoundClass repr) => CsPgmassign repr  where+  pgmassign ::+    INum repr+    -> VString repr+    -> repr ()+  pgmassign' :: INum repr+    -> VString repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsPgmchn repr  where+  pgmchn ::+    repr (KSig repr, KSig repr)+  pgmchn' :: INum repr+    -> repr (KSig repr, KSig repr)+++class (CsoundClass repr) => CsPhaser1 repr  where+  phaser1 ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  phaser1' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPhaser2 repr  where+  phaser2 ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPhasorbnk repr out a where+  phasorbnk ::+    a+    -> KSig repr+    -> INum repr+    -> repr out+  phasorbnk' :: a+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsPindex repr  where+  pindex ::+    INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsPinkish repr a where+  pinkish ::+    a+    -> repr (ASig repr)+  pinkish' :: a+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPitch repr  where+  pitch ::+    ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr, KSig repr)+  pitch' :: ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr, KSig repr)+++class (CsoundClass repr) => CsPitchac repr  where+  pitchac ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsPitchamdf repr  where+  pitchamdf ::+    ASig repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr, KSig repr)+  pitchamdf' :: ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr, KSig repr)+++class (CsoundClass repr) => CsPlanet repr  where+  planet ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr)+  planet' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr)+++class (CsoundClass repr) => CsPluck repr  where+  pluck ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  pluck' :: KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPoisson repr out  where+  poisson ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsPolyaft repr out  where+  polyaft ::+    INum repr+    -> repr out+  polyaft' :: INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsPolynomial repr  where+  polynomial ::+    ASig repr+    -> [KSig repr]+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPop_f repr  where+  pop_f ::+    repr (FSig repr)+++class (CsoundClass repr) => CsPort repr  where+  port ::+    KSig repr+    -> INum repr+    -> repr (KSig repr)+  port' :: KSig repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsPortk repr  where+  portk ::+    KSig repr+    -> KSig repr+    -> repr (KSig repr)+  portk' :: KSig repr+    -> KSig repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsPoscil repr out a b where+  poscil ::+    a+    -> b+    -> INum repr+    -> repr out+  poscil' :: a+    -> b+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsPoscil3 repr out  where+  poscil3 ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> repr out+  poscil3' :: KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsPow repr out a where+  pow ::+    a+    -> KSig repr+    -> repr out+  pow' :: a+    -> KSig repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsPowershape repr  where+  powershape ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+  powershape' :: ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPowoftwo repr out a where+  powoftwo ::+    a+    -> repr out+++class (CsoundClass repr) => CsPrealloc repr  where+  prealloc ::+    VString repr+    -> INum repr+    -> repr ()+  prealloc' :: VString repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsPrepiano repr d  where+  prepiano ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+  prepiano' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsPrint repr  where+  print ::+    [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsPrintf_i repr  where+  printf_i ::+    VString repr+    -> INum repr+    -> VString repr+    -> [(INum repr, INum repr)]+    -> repr ()+++class (CsoundClass repr) => CsPrintk repr  where+  printk ::+    INum repr+    -> KSig repr+    -> repr ()+  printk' :: INum repr+    -> KSig repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsPrintk2 repr  where+  printk2 ::+    KSig repr+    -> repr ()+  printk2' :: KSig repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsPrintks repr a where+  printks ::+    VString repr+    -> INum repr+    -> [a]+    -> repr ()+++class (CsoundClass repr) => CsPrints repr a where+  prints ::+    VString repr+    -> [a]+    -> repr ()+++class (CsoundClass repr) => CsProduct repr  where+  product ::+    [ASig repr]+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPset repr  where+  pset ::+    [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsPtrack repr  where+  ptrack ::+    ASig repr+    -> INum repr+    -> repr (KSig repr, KSig repr)+  ptrack' :: ASig repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr, KSig repr)+++class (CsoundClass repr) => CsPush repr  where+  push ::+    [(INum repr, INum repr)]+    -> repr ()+++class (CsoundClass repr) => CsPush_f repr  where+  push_f ::+    FSig repr+    -> repr ()+++class (CsoundClass repr) => CsPuts repr  where+  puts ::+    VString repr+    -> KSig repr+    -> repr ()+  puts' :: VString repr+    -> KSig repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsPvadd repr  where+  pvadd ::+    KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  pvadd' :: KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPvbufread repr  where+  pvbufread ::+    KSig repr+    -> VString repr+    -> repr ()+++class (CsoundClass repr) => CsPvcross repr  where+  pvcross ::+    KSig repr+    -> KSig repr+    -> VString repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  pvcross' :: KSig repr+    -> KSig repr+    -> VString repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPvinterp repr  where+  pvinterp ::+    KSig repr+    -> KSig repr+    -> VString repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPvoc repr  where+  pvoc ::+    KSig repr+    -> KSig repr+    -> VString repr+    -> repr (ASig repr)+  pvoc' :: KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsPvread repr  where+  pvread ::+    KSig repr+    -> VString repr+    -> INum repr+    -> repr (KSig repr, KSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsadsyn repr  where+  pvsadsyn ::+    FSig repr+    -> INum repr+    -> KSig repr+    -> repr (ASig repr)+  pvsadsyn' :: FSig repr+    -> INum repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr, PVS repr) => CsPvsanal repr  where+  pvsanal ::+    ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (FSig repr)+  pvsanal' :: ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsarp repr  where+  pvsarp ::+    FSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsbandp repr a b c d e where+  pvsbandp ::+    FSig repr+    -> a+    -> b+    -> c+    -> d+    -> repr (FSig repr)+  pvsbandp' :: FSig repr+    -> a+    -> b+    -> c+    -> d+    -> e+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsbandr repr a b c d e where+  pvsbandr ::+    FSig repr+    -> a+    -> b+    -> c+    -> d+    -> repr (FSig repr)+  pvsbandr' :: FSig repr+    -> a+    -> b+    -> c+    -> d+    -> e+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsbin repr out  where+  pvsbin ::+    FSig repr+    -> KSig repr+    -> repr (out,out)+++class (CsoundClass repr, PVS repr) => CsPvsblur repr  where+  pvsblur ::+    FSig repr+    -> KSig repr+    -> INum repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsbuffer repr  where+  pvsbuffer ::+    FSig repr+    -> INum repr+    -> repr (INum repr, KSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsbufread repr a b where+  pvsbufread ::+    KSig repr+    -> KSig repr+    -> repr (FSig repr)+  pvsbufread' :: KSig repr+    -> KSig repr+    -> a+    -> b+    -> INum repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvscent repr out  where+  pvscent ::+    FSig repr+    -> repr out+++class (CsoundClass repr, PVS repr) => CsPvscross repr  where+  pvscross ::+    FSig repr+    -> FSig repr+    -> KSig repr+    -> KSig repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsdemix repr  where+  pvsdemix ::+    FSig repr+    -> FSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsdisp repr  where+  pvsdisp ::+    FSig repr+    -> repr ()+  pvsdisp' :: FSig repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr, PVS repr) => CsPvsfilter repr a where+  pvsfilter ::+    FSig repr+    -> FSig repr+    -> a+    -> repr (FSig repr)+  pvsfilter' :: FSig repr+    -> FSig repr+    -> a+    -> INum repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsfread repr  where+  pvsfread ::+    KSig repr+    -> VString repr+    -> repr (FSig repr)+  pvsfread' :: KSig repr+    -> VString repr+    -> INum repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsfreeze repr  where+  pvsfreeze ::+    FSig repr+    -> KSig repr+    -> KSig repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsftr repr  where+  pvsftr ::+    FSig repr+    -> INum repr+    -> repr ()+  pvsftr' :: FSig repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr, PVS repr) => CsPvsftw repr  where+  pvsftw ::+    FSig repr+    -> INum repr+    -> repr (KSig repr)+  pvsftw' :: FSig repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsfwrite repr  where+  pvsfwrite ::+    FSig repr+    -> VString repr+    -> repr ()+++class (CsoundClass repr, PVS repr) => CsPvshift repr a b c d where+  pvshift ::+    FSig repr+    -> a+    -> KSig repr+    -> repr (FSig repr)+  pvshift' :: FSig repr+    -> a+    -> KSig repr+    -> b+    -> c+    -> d+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsifd repr  where+  pvsifd ::+    ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (FSig repr, FSig repr)+  pvsifd' :: ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (FSig repr, FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsin repr  where+  pvsin ::+    KSig repr+    -> repr (FSig repr)+  pvsin' :: KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsinfo repr  where+  pvsinfo ::+    FSig repr+    -> repr (INum repr, INum repr, INum repr, INum repr)+++class (CsoundClass repr, PVS repr) => CsPvsinit repr  where+  pvsinit ::+    INum repr+    -> repr (FSig repr)+  pvsinit' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvslock repr  where+  pvslock ::+    FSig repr+    -> KSig repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsmaska repr  where+  pvsmaska ::+    FSig repr+    -> INum repr+    -> KSig repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsmix repr  where+  pvsmix ::+    FSig repr+    -> FSig repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsmooth repr a b where+  pvsmooth ::+    FSig repr+    -> a+    -> b+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsmorph repr  where+  pvsmorph ::+    FSig repr+    -> FSig repr+    -> KSig repr+    -> KSig repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsosc repr  where+  pvsosc ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (FSig repr)+  pvsosc' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsout repr  where+  pvsout ::+    FSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr, PVS repr) => CsPvspitch repr  where+  pvspitch ::+    FSig repr+    -> KSig repr+    -> repr (KSig repr, KSig repr)+++class (CsoundClass repr, PVS repr) => CsPvstencil repr  where+  pvstencil ::+    FSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsvoc repr a where+  pvsvoc ::+    FSig repr+    -> FSig repr+    -> KSig repr+    -> KSig repr+    -> repr (FSig repr)+  pvsvoc' :: FSig repr+    -> FSig repr+    -> KSig repr+    -> KSig repr+    -> a+    -> repr (FSig repr)+++class (CsoundClass repr, PVS repr) => CsPvsynth repr  where+  pvsynth ::+    FSig repr+    -> repr (ASig repr)+  pvsynth' :: FSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsRand repr out a where+  rand ::+    a+    -> repr out+  rand' :: a+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsRandh repr out a b where+  randh ::+    a+    -> b+    -> repr out+  randh' :: a+    -> b+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsRandi repr out a b where+  randi ::+    a+    -> b+    -> repr out+  randi' :: a+    -> b+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsRandom repr out  where+  random ::+    KSig repr+    -> KSig repr+    -> repr out+++class (CsoundClass repr) => CsRandomh repr out a where+  randomh ::+    KSig repr+    -> KSig repr+    -> a+    -> repr out+++class (CsoundClass repr) => CsRandomi repr out a where+  randomi ::+    KSig repr+    -> KSig repr+    -> a+    -> repr out+++class (CsoundClass repr) => CsRbjeq repr  where+  rbjeq ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  rbjeq' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsReadclock repr  where+  readclock ::+    INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsReadk repr  where+  readk ::+    VString repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsReadk2 repr  where+  readk2 ::+    VString repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr, KSig repr)+++class (CsoundClass repr) => CsReadk3 repr  where+  readk3 ::+    VString repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr, KSig repr, KSig repr)+++class (CsoundClass repr) => CsReadk4 repr  where+  readk4 ::+    VString repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr, KSig repr, KSig repr, KSig repr)+++class (CsoundClass repr) => CsReadks repr  where+  readks ::+    VString repr+    -> INum repr+    -> repr (VString repr)+++class (CsoundClass repr) => CsRelease repr  where+  release ::+    repr (KSig repr)+++class (CsoundClass repr) => CsRemoteport repr  where+  remoteport ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsRemove repr  where+  remove ::+    VString repr+    -> repr ()+++class (CsoundClass repr) => CsRepluck repr  where+  repluck ::+    INum repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> ASig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsReson repr  where+  reson ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  reson' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsResonk repr  where+  resonk ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr)+  resonk' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsResonr repr  where+  resonr ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  resonr' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsResonx repr  where+  resonx ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  resonx' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsResonxk repr  where+  resonxk ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr)+  resonxk' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsResony repr  where+  resony ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> repr (ASig repr)+  resony' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsResonz repr  where+  resonz ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  resonz' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsResyn repr  where+  resyn ::+    FSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsReverb repr  where+  reverb ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+  reverb' :: ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsReverb2 repr  where+  reverb2 ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  reverb2' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsReverbsc repr  where+  reverbsc ::+    ASig repr+    -> ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr, ASig repr)+  reverbsc' :: ASig repr+    -> ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsRewindscore repr  where+  rewindscore ::+    repr ()+++class (CsoundClass repr) => CsRezzy repr a b where+  rezzy ::+    ASig repr+    -> a+    -> b+    -> repr (ASig repr)+  rezzy' :: ASig repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsRireturn repr  where+  rireturn ::+    repr ()+++class (CsoundClass repr) => CsRms repr  where+  rms ::+    ASig repr+    -> repr (KSig repr)+  rms' :: ASig repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsRnd repr out  where+  rnd ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsRnd31 repr out  where+  rnd31 ::+    KSig repr+    -> KSig repr+    -> repr out+  rnd31' :: KSig repr+    -> KSig repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsRound repr out a where+  round ::+    a+    -> repr out+++class (CsoundClass repr) => CsRspline repr out a b where+  rspline ::+    a+    -> b+    -> KSig repr+    -> KSig repr+    -> repr out+++class (CsoundClass repr) => CsRtclock repr out  where+  rtclock ::+    repr out+++class (CsoundClass repr) => CsSamphold repr out a b where+  samphold ::+    a+    -> b+    -> repr out+  samphold' :: a+    -> b+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsSandpaper repr  where+  sandpaper ::+    INum repr+    -> INum repr+    -> repr (ASig repr)+  sandpaper' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsScale repr  where+  scale ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsScanhammer repr  where+  scanhammer ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsScans repr  where+  scans ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  scans' :: KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsScantable repr  where+  scantable ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsScanu repr  where+  scanu ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsSchedule repr  where+  schedule ::+    VString repr+    -> INum repr+    -> INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsSchedwhen repr  where+  schedwhen ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsScoreline repr  where+  scoreline ::+    VString repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsScoreline_i repr  where+  scoreline_i ::+    VString repr+    -> repr ()+++class (CsoundClass repr) => CsSeed repr  where+  seed ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsSekere repr  where+  sekere ::+    INum repr+    -> INum repr+    -> repr (ASig repr)+  sekere' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsSemitone repr out a where+  semitone ::+    a+    -> repr out+++class (CsoundClass repr) => CsSeqtime repr  where+  seqtime ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsSeqtime2 repr  where+  seqtime2 ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsSetctrl repr  where+  setctrl ::+    INum repr+    -> VString repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsSetksmps repr  where+  setksmps ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsSetscorepos repr  where+  setscorepos ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsSfilist repr  where+  sfilist ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsSfinstr repr a b where+  sfinstr ::+    INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+  sfinstr' :: INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsSfinstr3 repr a b where+  sfinstr3 ::+    INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+  sfinstr3' :: INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsSfinstr3m repr a b where+  sfinstr3m ::+    INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  sfinstr3m' :: INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsSfinstrm repr a b where+  sfinstrm ::+    INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  sfinstrm' :: INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsSfload repr  where+  sfload ::+    VString repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsSflooper repr  where+  sflooper ::+    INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr, ASig repr)+  sflooper' :: INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsSfpassign repr  where+  sfpassign ::+    INum repr+    -> INum repr+    -> repr ()+  sfpassign' :: INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsSfplay repr a b where+  sfplay ::+    INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> repr (ASig repr, ASig repr)+  sfplay' :: INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsSfplay3 repr a b where+  sfplay3 ::+    INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> repr (ASig repr, ASig repr)+  sfplay3' :: INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsSfplay3m repr a b where+  sfplay3m ::+    INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> repr (ASig repr)+  sfplay3m' :: INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsSfplaym repr a b where+  sfplaym ::+    INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> repr (ASig repr)+  sfplaym' :: INum repr+    -> INum repr+    -> a+    -> b+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsSfplist repr  where+  sfplist ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsSfpreset repr  where+  sfpreset ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsShaker repr  where+  shaker ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  shaker' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsShl repr out a b where+  shl ::+    a+    -> b+    -> repr out+++class (CsoundClass repr) => CsShr repr out a b where+  shr ::+    a+    -> b+    -> repr out+++class (CsoundClass repr) => CsSin repr out a where+  sin ::+    a+    -> repr out+++class (CsoundClass repr) => CsSinh repr out a where+  sinh ::+    a+    -> repr out+++class (CsoundClass repr) => CsSininv repr out a where+  sininv ::+    a+    -> repr out+++class (CsoundClass repr) => CsSinsyn repr  where+  sinsyn ::+    FSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsSleighbells repr  where+  sleighbells ::+    KSig repr+    -> INum repr+    -> repr (ASig repr)+  sleighbells' :: KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsSlider16table repr  where+  slider16table ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsSlider16tablef repr  where+  slider16tablef ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsSlider8table repr  where+  slider8table ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsSlider8tablef repr  where+  slider8tablef ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsSndload repr  where+  sndload ::+    VString repr+    -> repr ()+  sndload' :: VString repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsSndloop repr  where+  sndloop ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, KSig repr)+++class (CsoundClass repr) => CsSndwarp repr d a b c where+  sndwarp ::+    a+    -> b+    -> c+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsSndwarpst repr d a b c where+  sndwarpst ::+    a+    -> b+    -> c+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsSockrecv repr  where+  sockrecv ::+    INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsSockrecvs repr  where+  sockrecvs ::+    INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsSocksend repr  where+  socksend ::+    ASig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsSocksends repr  where+  socksends ::+    ASig repr+    -> ASig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsSoundin repr d  where+  soundin ::+    VString repr+    -> repr (TList d (ASig repr))+  soundin' :: VString repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsSoundout repr  where+  soundout ::+    ASig repr+    -> VString repr+    -> repr ()+  soundout' :: ASig repr+    -> VString repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsSoundouts repr  where+  soundouts ::+    ASig repr+    -> ASig repr+    -> VString repr+    -> repr ()+  soundouts' :: ASig repr+    -> ASig repr+    -> VString repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsSpace repr  where+  space ::+    ASig repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+++class (CsoundClass repr) => CsSpat3d repr  where+  spat3d ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+  spat3d' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+++class (CsoundClass repr) => CsSpat3di repr  where+  spat3di ::+    ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+  spat3di' :: ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+++class (CsoundClass repr) => CsSpat3dt repr  where+  spat3dt ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  spat3dt' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsSpdist repr  where+  spdist ::+    INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsSplitrig repr  where+  splitrig ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> [KSig repr]+    -> repr ()+++class (CsoundClass repr) => CsSprintf repr  where+  sprintf ::+    VString repr+    -> VString repr+    -> [(INum repr, INum repr)]+    -> repr (VString repr)+++class (CsoundClass repr) => CsSpsend repr  where+  spsend ::+    repr (ASig repr, ASig repr, ASig repr, ASig repr)+++class (CsoundClass repr) => CsSqrt repr out a where+  sqrt ::+    a+    -> repr out+++class (CsoundClass repr) => CsStack repr  where+  stack ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsStatevar repr  where+  statevar ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+  statevar' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+++class (CsoundClass repr) => CsStix repr  where+  stix ::+    INum repr+    -> INum repr+    -> repr (ASig repr)+  stix' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsStrcat repr  where+  strcat ::+    VString repr+    -> VString repr+    -> repr (VString repr)+++class (CsoundClass repr) => CsStrcatk repr  where+  strcatk ::+    VString repr+    -> VString repr+    -> repr (VString repr)+++class (CsoundClass repr) => CsStrchar repr  where+  strchar ::+    VString repr+    -> repr (INum repr)+  strchar' :: VString repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsStrchark repr a where+  strchark ::+    VString repr+    -> repr (KSig repr)+  strchark' :: VString repr+    -> a+    -> repr (KSig repr)+++class (CsoundClass repr) => CsStrcmp repr  where+  strcmp ::+    VString repr+    -> VString repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsStrcmpk repr  where+  strcmpk ::+    VString repr+    -> VString repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsStrcpy repr  where+  strcpy ::+    VString repr+    -> repr (VString repr)+++class (CsoundClass repr) => CsStrcpyk repr  where+  strcpyk ::+    VString repr+    -> repr (VString repr)+++class (CsoundClass repr) => CsStrecv repr  where+  strecv ::+    VString repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsStreson repr  where+  streson ::+    ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsStrget repr  where+  strget ::+    INum repr+    -> repr (VString repr)+++class (CsoundClass repr) => CsStrindex repr  where+  strindex ::+    VString repr+    -> VString repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsStrindexk repr  where+  strindexk ::+    VString repr+    -> VString repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsStrlen repr  where+  strlen ::+    VString repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsStrlenk repr  where+  strlenk ::+    VString repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsStrlower repr  where+  strlower ::+    VString repr+    -> repr (VString repr)+++class (CsoundClass repr) => CsStrlowerk repr  where+  strlowerk ::+    VString repr+    -> repr (VString repr)+++class (CsoundClass repr) => CsStrrindex repr  where+  strrindex ::+    VString repr+    -> VString repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsStrrindexk repr  where+  strrindexk ::+    VString repr+    -> VString repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsStrset repr  where+  strset ::+    INum repr+    -> VString repr+    -> repr ()+++class (CsoundClass repr) => CsStrsub repr  where+  strsub ::+    VString repr+    -> repr (VString repr)+  strsub' :: VString repr+    -> INum repr+    -> INum repr+    -> repr (VString repr)+++class (CsoundClass repr) => CsStrsubk repr  where+  strsubk ::+    VString repr+    -> KSig repr+    -> KSig repr+    -> repr (VString repr)+++class (CsoundClass repr) => CsStrtod repr  where+  strtod ::+    VString repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsStrtol repr  where+  strtol ::+    VString repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsStrupper repr  where+  strupper ::+    VString repr+    -> repr (VString repr)+++class (CsoundClass repr) => CsStrupperk repr  where+  strupperk ::+    VString repr+    -> repr (VString repr)+++class (CsoundClass repr) => CsStsend repr  where+  stsend ::+    ASig repr+    -> VString repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsSub repr out a b where+  sub ::+    a+    -> b+    -> repr out+++class (CsoundClass repr) => CsSubinstr repr d  where+  subinstr ::+    VString repr+    -> [INum repr]+    -> repr (TList d (ASig repr))+++class (CsoundClass repr) => CsSubinstrinit repr  where+  subinstrinit ::+    VString repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsSum repr  where+  sum ::+    [ASig repr]+    -> repr (ASig repr)+++class (CsoundClass repr) => CsSvfilter repr  where+  svfilter ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr, ASig repr, ASig repr)+  svfilter' :: ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr)+++class (CsoundClass repr) => CsSyncgrain repr  where+  syncgrain ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsSyncloop repr  where+  syncloop ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  syncloop' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsSyncphasor repr a where+  syncphasor ::+    a+    -> ASig repr+    -> repr (ASig repr, ASig repr)+  syncphasor' :: a+    -> ASig repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsSystem repr a where+  system ::+    KSig repr+    -> VString repr+    -> repr (KSig repr)+  system' :: KSig repr+    -> VString repr+    -> a+    -> repr (KSig repr)+++class (CsoundClass repr) => CsSystem_i repr  where+  system_i ::+    INum repr+    -> VString repr+    -> repr (INum repr)+  system_i' :: INum repr+    -> VString repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsTab repr out a where+  tab ::+    a+    -> INum repr+    -> repr out+  tab' :: a+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsTab_i repr  where+  tab_i ::+    INum repr+    -> INum repr+    -> repr (INum repr)+  tab_i' :: INum repr+    -> INum repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsTable repr out a where+  table ::+    a+    -> INum repr+    -> repr out+  table' :: a+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsTable3 repr out a where+  table3 ::+    a+    -> INum repr+    -> repr out+  table3' :: a+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsTablecopy repr  where+  tablecopy ::+    KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsTablegpw repr  where+  tablegpw ::+    KSig repr+    -> repr ()+++class (CsoundClass repr) => CsTablei repr out a where+  tablei ::+    a+    -> INum repr+    -> repr out+  tablei' :: a+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsTableicopy repr  where+  tableicopy ::+    INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsTableigpw repr  where+  tableigpw ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTableikt repr out a where+  tableikt ::+    a+    -> KSig repr+    -> repr out+  tableikt' :: a+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsTableimix repr  where+  tableimix ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsTableiw repr  where+  tableiw ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  tableiw' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsTablekt repr out a where+  tablekt ::+    a+    -> KSig repr+    -> repr out+  tablekt' :: a+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsTablemix repr  where+  tablemix ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsTableng repr out  where+  tableng ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTablera repr  where+  tablera ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsTableseg repr  where+  tableseg ::+    INum repr+    -> INum repr+    -> INum repr+    -> [(INum repr, INum repr)]+    -> repr ()+++class (CsoundClass repr) => CsTablew repr a b where+  tablew ::+    a+    -> b+    -> INum repr+    -> repr ()+  tablew' :: a+    -> b+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsTablewa repr  where+  tablewa ::+    KSig repr+    -> ASig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsTablewkt repr a b where+  tablewkt ::+    a+    -> b+    -> KSig repr+    -> repr ()+  tablewkt' :: a+    -> b+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsTablexkt repr a where+  tablexkt ::+    a+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  tablexkt' :: a+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsTablexseg repr  where+  tablexseg ::+    INum repr+    -> INum repr+    -> INum repr+    -> [(INum repr, INum repr)]+    -> repr ()+++class (CsoundClass repr) => CsTabmorph repr  where+  tabmorph ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> [INum repr]+    -> repr (KSig repr)+++class (CsoundClass repr) => CsTabmorpha repr  where+  tabmorpha ::+    ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> [INum repr]+    -> repr (ASig repr)+++class (CsoundClass repr) => CsTabmorphak repr  where+  tabmorphak ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> [INum repr]+    -> repr (ASig repr)+++class (CsoundClass repr) => CsTabmorphi repr  where+  tabmorphi ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> [INum repr]+    -> repr (KSig repr)+++class (CsoundClass repr) => CsTabplay repr  where+  tabplay ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> [KSig repr]+    -> repr ()+++class (CsoundClass repr) => CsTabrec repr  where+  tabrec ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> [KSig repr]+    -> repr ()+++class (CsoundClass repr) => CsTabsum repr a b where+  tabsum ::+    INum repr+    -> repr (KSig repr)+  tabsum' :: INum repr+    -> a+    -> b+    -> repr (KSig repr)+++class (CsoundClass repr) => CsTabw repr a b where+  tabw ::+    a+    -> b+    -> INum repr+    -> repr ()+  tabw' :: a+    -> b+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsTabw_i repr  where+  tabw_i ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  tabw_i' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsTambourine repr  where+  tambourine ::+    KSig repr+    -> INum repr+    -> repr (ASig repr)+  tambourine' :: KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsTan repr out a where+  tan ::+    a+    -> repr out+++class (CsoundClass repr) => CsTanh repr out a where+  tanh ::+    a+    -> repr out+++class (CsoundClass repr) => CsTaninv repr out a where+  taninv ::+    a+    -> repr out+++class (CsoundClass repr) => CsTaninv2 repr out a b where+  taninv2 ::+    a+    -> b+    -> repr out+++class (CsoundClass repr) => CsTb0 repr out  where+  tb0 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb0_init repr  where+  tb0_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb1 repr out  where+  tb1 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb10 repr out  where+  tb10 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb10_init repr  where+  tb10_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb11 repr out  where+  tb11 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb11_init repr  where+  tb11_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb12 repr out  where+  tb12 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb12_init repr  where+  tb12_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb13 repr out  where+  tb13 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb13_init repr  where+  tb13_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb14 repr out  where+  tb14 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb14_init repr  where+  tb14_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb15 repr out  where+  tb15 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb15_init repr  where+  tb15_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb1_init repr  where+  tb1_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb2 repr out  where+  tb2 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb2_init repr  where+  tb2_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb3 repr out  where+  tb3 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb3_init repr  where+  tb3_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb4 repr out  where+  tb4 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb4_init repr  where+  tb4_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb5 repr out  where+  tb5 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb5_init repr  where+  tb5_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb6 repr out  where+  tb6 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb6_init repr  where+  tb6_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb7 repr out  where+  tb7 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb7_init repr  where+  tb7_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb8 repr out  where+  tb8 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb8_init repr  where+  tb8_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTb9 repr out  where+  tb9 ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTb9_init repr  where+  tb9_init ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsTbvcf repr a b where+  tbvcf ::+    ASig repr+    -> a+    -> b+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  tbvcf' :: ASig repr+    -> a+    -> b+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsTempest repr  where+  tempest ::+    KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+  tempest' :: KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsTempo repr  where+  tempo ::+    KSig repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsTempoval repr  where+  tempoval ::+    repr (KSig repr)+++class (CsoundClass repr) => CsTimedseq repr  where+  timedseq ::+    KSig repr+    -> INum repr+    -> [KSig repr]+    -> repr (KSig repr)+++class (CsoundClass repr) => CsTimeinstk repr  where+  timeinstk ::+    repr (KSig repr)+++class (CsoundClass repr) => CsTimeinsts repr  where+  timeinsts ::+    repr (KSig repr)+++class (CsoundClass repr) => CsTimek repr out  where+  timek ::+    repr out+++class (CsoundClass repr) => CsTimes repr out  where+  times ::+    repr out+++class (CsoundClass repr) => CsTival repr  where+  tival ::+    repr (INum repr)+++class (CsoundClass repr) => CsTlineto repr  where+  tlineto ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsTone repr  where+  tone ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+  tone' :: ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsTonek repr  where+  tonek ::+    KSig repr+    -> KSig repr+    -> repr (KSig repr)+  tonek' :: KSig repr+    -> KSig repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsTonex repr  where+  tonex ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+  tonex' :: ASig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsTradsyn repr  where+  tradsyn ::+    FSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsTrandom repr  where+  trandom ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsTranseg repr out  where+  transeg ::+    INum repr+    -> INum repr+    -> INum repr+    -> [INum repr]+    -> repr out+++class (CsoundClass repr) => CsTransegr repr out  where+  transegr ::+    INum repr+    -> INum repr+    -> INum repr+    -> [INum repr]+    -> repr out+++class (CsoundClass repr) => CsTrcross repr  where+  trcross ::+    FSig repr+    -> FSig repr+    -> KSig repr+    -> [KSig repr]+    -> repr (FSig repr)+++class (CsoundClass repr) => CsTrfilter repr  where+  trfilter ::+    FSig repr+    -> KSig repr+    -> INum repr+    -> repr (FSig repr)+++class (CsoundClass repr) => CsTrigger repr  where+  trigger ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsTrigseq repr  where+  trigseq ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> [KSig repr]+    -> repr ()+++class (CsoundClass repr) => CsTrirand repr out  where+  trirand ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsTrmix repr  where+  trmix ::+    FSig repr+    -> FSig repr+    -> repr (FSig repr)+++class (CsoundClass repr) => CsTrscale repr  where+  trscale ::+    FSig repr+    -> [KSig repr]+    -> repr (FSig repr)+++class (CsoundClass repr) => CsTrshift repr  where+  trshift ::+    FSig repr+    -> [KSig repr]+    -> repr (FSig repr)+++class (CsoundClass repr) => CsTrsplit repr  where+  trsplit ::+    FSig repr+    -> [KSig repr]+    -> repr (FSig repr, FSig repr)+++class (CsoundClass repr) => CsTurnoff repr  where+  turnoff ::+    repr ()+++class (CsoundClass repr) => CsTurnoff2 repr  where+  turnoff2 ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsTurnon repr  where+  turnon ::+    VString repr+    -> repr ()+  turnon' :: VString repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsUnirand repr out  where+  unirand ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsUpsamp repr  where+  upsamp ::+    KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsUrd repr out  where+  urd ::+    KSig repr+    -> repr out+++class (CsoundClass repr) => CsVadd repr a b where+  vadd ::+    INum repr+    -> KSig repr+    -> KSig repr+    -> repr ()+  vadd' :: INum repr+    -> KSig repr+    -> KSig repr+    -> a+    -> b+    -> repr ()+++class (CsoundClass repr) => CsVadd_i repr  where+  vadd_i ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  vadd_i' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVaddv repr a b c where+  vaddv ::+    INum repr+    -> INum repr+    -> KSig repr+    -> repr ()+  vaddv' :: INum repr+    -> INum repr+    -> KSig repr+    -> a+    -> b+    -> c+    -> repr ()+++class (CsoundClass repr) => CsVaddv_i repr  where+  vaddv_i ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  vaddv_i' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVaget repr  where+  vaget ::+    KSig repr+    -> ASig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsValpass repr a where+  valpass ::+    ASig repr+    -> KSig repr+    -> a+    -> INum repr+    -> repr (ASig repr)+  valpass' :: ASig repr+    -> KSig repr+    -> a+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsVaset repr  where+  vaset ::+    KSig repr+    -> KSig repr+    -> ASig repr+    -> repr ()+++class (CsoundClass repr) => CsVbap4 repr a b where+  vbap4 ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+  vbap4' :: ASig repr+    -> KSig repr+    -> a+    -> b+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+++class (CsoundClass repr) => CsVbap4move repr  where+  vbap4move ::+    ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> [INum repr]+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+++class (CsoundClass repr) => CsVbaplsinit repr  where+  vbaplsinit ::+    INum repr+    -> INum repr+    -> repr ()+  vbaplsinit' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVbapz repr a b where+  vbapz ::+    INum repr+    -> INum repr+    -> ASig repr+    -> KSig repr+    -> repr ()+  vbapz' :: INum repr+    -> INum repr+    -> ASig repr+    -> KSig repr+    -> a+    -> b+    -> repr ()+++class (CsoundClass repr) => CsVbapzmove repr  where+  vbapzmove ::+    INum repr+    -> INum repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsVcella repr  where+  vcella ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  vcella' :: KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVco2 repr a where+  vco2 ::+    KSig repr+    -> KSig repr+    -> repr (ASig repr)+  vco2' :: KSig repr+    -> KSig repr+    -> INum repr+    -> [a]+    -> repr (ASig repr)+++class (CsoundClass repr) => CsVco2ft repr  where+  vco2ft ::+    KSig repr+    -> repr (KSig repr)+  vco2ft' :: KSig repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsVco2ift repr  where+  vco2ift ::+    INum repr+    -> repr (INum repr)+  vco2ift' :: INum repr+    -> INum repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsVco2init repr  where+  vco2init ::+    INum repr+    -> repr (INum repr)+  vco2init' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsVcomb repr a where+  vcomb ::+    ASig repr+    -> KSig repr+    -> a+    -> INum repr+    -> repr (ASig repr)+  vcomb' :: ASig repr+    -> KSig repr+    -> a+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsVcopy repr a b c where+  vcopy ::+    INum repr+    -> INum repr+    -> KSig repr+    -> repr ()+  vcopy' :: INum repr+    -> INum repr+    -> KSig repr+    -> a+    -> b+    -> c+    -> repr ()+++class (CsoundClass repr) => CsVcopy_i repr  where+  vcopy_i ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  vcopy_i' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVdel_k repr  where+  vdel_k ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> repr (KSig repr)+  vdel_k' :: KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsVdelayk repr  where+  vdelayk ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> repr (KSig repr)+  vdelayk' :: KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsVdelayx repr  where+  vdelayx ::+    ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  vdelayx' :: ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsVdelayxq repr  where+  vdelayxq ::+    ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+  vdelayxq' :: ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+++class (CsoundClass repr) => CsVdelayxs repr  where+  vdelayxs ::+    ASig repr+    -> ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+  vdelayxs' :: ASig repr+    -> ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsVdelayxw repr  where+  vdelayxw ::+    ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  vdelayxw' :: ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsVdelayxwq repr  where+  vdelayxwq ::+    ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+  vdelayxwq' :: ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr, ASig repr, ASig repr)+++class (CsoundClass repr) => CsVdelayxws repr  where+  vdelayxws ::+    ASig repr+    -> ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+  vdelayxws' :: ASig repr+    -> ASig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr, ASig repr)+++class (CsoundClass repr) => CsVdivv repr a b c where+  vdivv ::+    INum repr+    -> INum repr+    -> KSig repr+    -> repr ()+  vdivv' :: INum repr+    -> INum repr+    -> KSig repr+    -> a+    -> b+    -> c+    -> repr ()+++class (CsoundClass repr) => CsVdivv_i repr  where+  vdivv_i ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  vdivv_i' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVecdelay repr  where+  vecdelay ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  vecdelay' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVeloc repr  where+  veloc ::+    repr (INum repr)+  veloc' :: INum repr+    -> INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsVexp repr a b where+  vexp ::+    INum repr+    -> KSig repr+    -> KSig repr+    -> repr ()+  vexp' :: INum repr+    -> KSig repr+    -> KSig repr+    -> a+    -> b+    -> repr ()+++class (CsoundClass repr) => CsVexp_i repr  where+  vexp_i ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  vexp_i' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVexpseg repr  where+  vexpseg ::+    INum repr+    -> INum repr+    -> INum repr+    -> [(INum repr, INum repr)]+    -> repr ()+++class (CsoundClass repr) => CsVexpv repr a b c where+  vexpv ::+    INum repr+    -> INum repr+    -> KSig repr+    -> repr ()+  vexpv' :: INum repr+    -> INum repr+    -> KSig repr+    -> a+    -> b+    -> c+    -> repr ()+++class (CsoundClass repr) => CsVexpv_i repr  where+  vexpv_i ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  vexpv_i' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVibes repr  where+  vibes ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsVibr repr  where+  vibr ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsVibrato repr  where+  vibrato ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (KSig repr)+  vibrato' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsVincr repr  where+  vincr ::+    ASig repr+    -> ASig repr+    -> repr ()+++class (CsoundClass repr) => CsVlimit repr  where+  vlimit ::+    INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVlinseg repr  where+  vlinseg ::+    INum repr+    -> INum repr+    -> INum repr+    -> [(INum repr, INum repr)]+    -> repr ()+++class (CsoundClass repr) => CsVlowres repr  where+  vlowres ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsVmap repr  where+  vmap ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  vmap' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVmirror repr  where+  vmirror ::+    INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVmult repr a b where+  vmult ::+    INum repr+    -> KSig repr+    -> KSig repr+    -> repr ()+  vmult' :: INum repr+    -> KSig repr+    -> KSig repr+    -> a+    -> b+    -> repr ()+++class (CsoundClass repr) => CsVmult_i repr  where+  vmult_i ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  vmult_i' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVmultv repr a b c where+  vmultv ::+    INum repr+    -> INum repr+    -> KSig repr+    -> repr ()+  vmultv' :: INum repr+    -> INum repr+    -> KSig repr+    -> a+    -> b+    -> c+    -> repr ()+++class (CsoundClass repr) => CsVmultv_i repr  where+  vmultv_i ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  vmultv_i' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVoice repr  where+  voice ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsVosim repr  where+  vosim ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  vosim' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsVphaseseg repr  where+  vphaseseg ::+    KSig repr+    -> INum repr+    -> INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsVport repr  where+  vport ::+    INum repr+    -> KSig repr+    -> INum repr+    -> repr ()+  vport' :: INum repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVpow repr a b where+  vpow ::+    INum repr+    -> KSig repr+    -> KSig repr+    -> repr ()+  vpow' :: INum repr+    -> KSig repr+    -> KSig repr+    -> a+    -> b+    -> repr ()+++class (CsoundClass repr) => CsVpow_i repr  where+  vpow_i ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  vpow_i' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVpowv repr a b c where+  vpowv ::+    INum repr+    -> INum repr+    -> KSig repr+    -> repr ()+  vpowv' :: INum repr+    -> INum repr+    -> KSig repr+    -> a+    -> b+    -> c+    -> repr ()+++class (CsoundClass repr) => CsVpowv_i repr  where+  vpowv_i ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  vpowv_i' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVpvoc repr  where+  vpvoc ::+    KSig repr+    -> KSig repr+    -> VString repr+    -> repr (ASig repr)+  vpvoc' :: KSig repr+    -> KSig repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsVrandh repr  where+  vrandh ::+    INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr ()+  vrandh' :: INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVrandi repr  where+  vrandi ::+    INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr ()+  vrandi' :: INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVsubv repr a b c where+  vsubv ::+    INum repr+    -> INum repr+    -> KSig repr+    -> repr ()+  vsubv' :: INum repr+    -> INum repr+    -> KSig repr+    -> a+    -> b+    -> c+    -> repr ()+++class (CsoundClass repr) => CsVsubv_i repr  where+  vsubv_i ::+    INum repr+    -> INum repr+    -> INum repr+    -> repr ()+  vsubv_i' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsVtaba repr  where+  vtaba ::+    ASig repr+    -> INum repr+    -> [ASig repr]+    -> repr ()+++class (CsoundClass repr) => CsVtabi repr  where+  vtabi ::+    INum repr+    -> INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsVtabk repr  where+  vtabk ::+    KSig repr+    -> INum repr+    -> [KSig repr]+    -> repr ()+++class (CsoundClass repr) => CsVtable1k repr  where+  vtable1k ::+    KSig repr+    -> [KSig repr]+    -> repr ()+++class (CsoundClass repr) => CsVtablea repr  where+  vtablea ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> [ASig repr]+    -> repr ()+++class (CsoundClass repr) => CsVtablei repr  where+  vtablei ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsVtablek repr  where+  vtablek ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> [KSig repr]+    -> repr ()+++class (CsoundClass repr) => CsVtablewa repr  where+  vtablewa ::+    ASig repr+    -> KSig repr+    -> INum repr+    -> [ASig repr]+    -> repr ()+++class (CsoundClass repr) => CsVtablewi repr  where+  vtablewi ::+    INum repr+    -> INum repr+    -> INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsVtablewk repr  where+  vtablewk ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> [KSig repr]+    -> repr ()+++class (CsoundClass repr) => CsVtabwa repr  where+  vtabwa ::+    ASig repr+    -> INum repr+    -> [ASig repr]+    -> repr ()+++class (CsoundClass repr) => CsVtabwi repr  where+  vtabwi ::+    INum repr+    -> INum repr+    -> [INum repr]+    -> repr ()+++class (CsoundClass repr) => CsVtabwk repr  where+  vtabwk ::+    KSig repr+    -> INum repr+    -> [KSig repr]+    -> repr ()+++class (CsoundClass repr) => CsVwrap repr  where+  vwrap ::+    INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsWaveset repr  where+  waveset ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+  waveset' :: ASig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsWeibull repr out  where+  weibull ::+    KSig repr+    -> KSig repr+    -> repr out+++class (CsoundClass repr) => CsWgbow repr  where+  wgbow ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  wgbow' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsWgbowedbar repr  where+  wgbowedbar ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+  wgbowedbar' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsWgbrass repr  where+  wgbrass ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  wgbrass' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsWgclar repr  where+  wgclar ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  wgclar' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsWgflute repr  where+  wgflute ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (ASig repr)+  wgflute' :: KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsWgpluck repr  where+  wgpluck ::+    INum repr+    -> INum repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> ASig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsWgpluck2 repr  where+  wgpluck2 ::+    INum repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsWguide1 repr a where+  wguide1 ::+    ASig repr+    -> a+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsWguide2 repr a b where+  wguide2 ::+    ASig repr+    -> a+    -> b+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsWrap repr out a where+  wrap ::+    a+    -> KSig repr+    -> KSig repr+    -> repr out+++class (CsoundClass repr) => CsWterrain repr  where+  wterrain ::+    KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsXadsr repr out  where+  xadsr ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+  xadsr' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr out+++class (CsoundClass repr) => CsXor repr out a b where+  xor ::+    a+    -> b+    -> repr out+++class (CsoundClass repr) => CsXout repr  where+  xout ::+    [(INum repr, INum repr)]+    -> repr ()+++class (CsoundClass repr) => CsXscanmap repr  where+  xscanmap ::+    INum repr+    -> KSig repr+    -> KSig repr+    -> repr (KSig repr, KSig repr)+  xscanmap' :: INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr (KSig repr, KSig repr)+++class (CsoundClass repr) => CsXscans repr  where+  xscans ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+  xscans' :: KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsXscansmap repr  where+  xscansmap ::+    KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> repr ()+  xscansmap' :: KSig repr+    -> KSig repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsXscanu repr  where+  xscanu ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> VString repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> KSig repr+    -> KSig repr+    -> ASig repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsXtratim repr  where+  xtratim ::+    INum repr+    -> repr ()+++class (CsoundClass repr) => CsXyin repr  where+  xyin ::+    INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr, KSig repr)+  xyin' :: INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> INum repr+    -> repr (KSig repr, KSig repr)+++class (CsoundClass repr) => CsZacl repr  where+  zacl ::+    KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsZakinit repr  where+  zakinit ::+    INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsZamod repr  where+  zamod ::+    ASig repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsZar repr  where+  zar ::+    KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsZarg repr  where+  zarg ::+    KSig repr+    -> KSig repr+    -> repr (ASig repr)+++class (CsoundClass repr) => CsZaw repr  where+  zaw ::+    ASig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsZawm repr  where+  zawm ::+    ASig repr+    -> KSig repr+    -> repr ()+  zawm' :: ASig repr+    -> KSig repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsZfilter2 repr  where+  zfilter2 ::+    ASig repr+    -> KSig repr+    -> KSig repr+    -> INum repr+    -> INum repr+    -> [INum repr]+    -> repr (ASig repr)+++class (CsoundClass repr) => CsZir repr  where+  zir ::+    INum repr+    -> repr (INum repr)+++class (CsoundClass repr) => CsZiw repr  where+  ziw ::+    INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsZiwm repr  where+  ziwm ::+    INum repr+    -> INum repr+    -> repr ()+  ziwm' :: INum repr+    -> INum repr+    -> INum repr+    -> repr ()+++class (CsoundClass repr) => CsZkcl repr  where+  zkcl ::+    KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsZkmod repr  where+  zkmod ::+    KSig repr+    -> KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsZkr repr  where+  zkr ::+    KSig repr+    -> repr (KSig repr)+++class (CsoundClass repr) => CsZkw repr  where+  zkw ::+    KSig repr+    -> KSig repr+    -> repr ()+++class (CsoundClass repr) => CsZkwm repr  where+  zkwm ::+    KSig repr+    -> KSig repr+    -> repr ()+  zkwm' :: KSig repr+    -> KSig repr+    -> INum repr+    -> repr ()
+ src/Language/XDsp/Semantics/CsoundExt/Core.hs view
@@ -0,0 +1,18 @@+module Language.XDsp.Semantics.CsoundExt.Core (+  CsoundClass (..)+)++where++import Language.XDsp.Semantics.Core+import Language.XDsp.Semantics.BasicExtensions++-- ---------------------------------+-- ---------------------------------+-- csound-specific language extensions.  Although these could be implemented+-- in other backends, doing so may be un-idiomatic++class (Dsp repr, StringVar repr) => CsoundClass repr where+  nchnls   :: Int -> repr Int+  set0dbfs :: Double -> repr Double+
+ src/Language/XDsp/Semantics/Extras.hs view
@@ -0,0 +1,28 @@+module Language.XDsp.Semantics.Extras (+  module Language.XDsp.Semantics.Extras.Delay+ ,module Language.XDsp.Semantics.Extras.FSig+ ,a+ ,k+ ,i+)++where++import           Language.XDsp.Semantics.Core++import           Language.XDsp.Semantics.Extras.Delay+import           Language.XDsp.Semantics.Extras.FSig++-- a few helper functions++-- | Restrict a value to `ASig` type+a :: Dsp repr => ASig repr -> ASig repr+a = id++-- | Restrict a value to `KSig` type+k :: Dsp repr => KSig repr -> KSig repr+k = id++-- | Restrict a value to `INum` type+i :: Dsp repr => INum repr -> INum repr+i = id
+ src/Language/XDsp/Semantics/Extras/Delay.hs view
@@ -0,0 +1,29 @@+{-# LANGUAGE TypeFamilies, MultiParamTypeClasses, FlexibleContexts #-}++module Language.XDsp.Semantics.Extras.Delay (+  Delay (..)+ ,DelayNet (..)+)++where++import Language.XDsp.Semantics.Core+import Control.Applicative++-- ---------------------------------+-- ---------------------------------+-- delay networks++class Dsp repr => Delay repr where+  delaySamp :: ASig repr -> repr (ASig repr)+  vdelay3   :: ASig repr+               -> ASig repr+               -> INum repr+               -> repr (ASig repr)++class Dsp repr => DelayNet repr where+  type DelayN repr :: * -> *+  runDelay :: INum repr -> ASig repr -> DelayN repr a -> repr a+  tapK     :: KSig repr -> DelayN repr (ASig repr)+  tapA     :: ASig repr -> DelayN repr (ASig repr)+  tapI     :: INum repr -> DelayN repr (ASig repr)
+ src/Language/XDsp/Semantics/Extras/FSig.hs view
@@ -0,0 +1,13 @@+{-# LANGUAGE TypeFamilies, MultiParamTypeClasses #-}++module Language.XDsp.Semantics.Extras.FSig++where+import Language.XDsp.Semantics.Core++-- ---------------------------------+-- ---------------------------------+-- fsig processing++class Dsp repr => PVS repr where+  data FSig repr :: *
+ tools/CsMaps.hs view
@@ -0,0 +1,40 @@+module CsMaps where++import qualified Data.Map as M+import qualified Data.Set as S++-- | classes that need to be imported qualified to prevent clashes+qualifiedNameMap :: M.Map String String+qualifiedNameMap = M.fromList [("CsOscili", "CSE")+                              ,("CsOscil",  "CSE")+                              ,("CsSum",    "CSE") ]++qualifyName :: String -> String+qualifyName nm = maybe nm ( ++ "." ++ nm) $ M.lookup nm qualifiedNameMap++-- | Map any csound names which are unallowed in Haskell to valid names+invalidNameMap :: M.Map String String+invalidNameMap = M.fromList [("in", "inCS")+                            ,("i",  "iCS")+                            ,("k",  "kCS")+                            ,("a",  "aCS")]++-- | Anything in this set is already bound as part of the core language+-- and shouldn't be re-bound+noReuseSet :: S.Set String+noReuseSet = S.fromList ["vdelay3"+                        ,"vdelay"+                        ,"out"+                        ,"outs"+                        ,"outq"+                        ,"outo"+                        ,"phasor"+                        ,"slider32table"+                        ,"slider32tablef"+                        ,"slider64table"+                        ,"slider64tablef" ]++-- | if a function needs a special context, add it+addCtxt :: String -> [String]+addCtxt str | take 3 str == "pvs" = ["PVS repr"] -- PVS context (for FSig)+addCtxt _ = []
+ tools/CsParser.hs view
@@ -0,0 +1,309 @@+module CsParser where++import           Control.Monad.Error+import           Control.Monad.State+import           Control.Monad.Writer+import           Data.List (intercalate)+import           Data.Maybe++-- http://www.perceptionfactory.com/csound/csound5extending.html+-- there's got to be a better way to encode this.  Maybe something like+-- a partial order?+mixL  a   b | a == b = a+mixL 'i' 'k' = 'k'+mixL 'i' 'a' = 'x'+mixL 'i' 'x' = 'x'+mixL 'i' 'S' = 'x'+mixL 'k' 'i' = 'k'+mixL 'k' 'a' = 'x'+mixL 'k' 'x' = 'x'+mixL 'k' 'S' = 'x'+mixL 'a' 'i' = 'x'+mixL 'a' 'k' = 'x'+mixL 'a' 'x' = 'x'+mixL 'a' 'S' = 'x'+mixL 'x' 'i' = 'x'+mixL 'x' 'k' = 'x'+mixL 'x' 'a' = 'x'+mixL 'S' 'i' = 'x'+mixL 'S' 'k' = 'x'+mixL 'S' 'a' = 'x'+mixL 'S' 'x' = 'x'+mixL _   _   = '*' -- don't have any means to handle other intypes yet.++-- | polyvar codes:+-- s : perf-time, a+k+-- c : control-time, k+i+S+-- v : any-time, a+k+i+S+mixLO :: Char -> Char -> Either String Char+mixLO 'v'  _  = return 'v'+mixLO  _  'v' = return 'v'+mixLO 's' 'i' = return 'v'+mixLO 's' 'c' = return 'v'+mixLO 's' 'S' = return 'v'+mixLO 's'  _  = return 's'+mixLO 'c' 's' = return 'v'+mixLO 'c' 'a' = return 'v'+mixLO 'c'  _  = return 'c' -- c,i,k,S+mixLO 'a' 'i' = return 'v'+mixLO 'a' 'k' = return 's'+mixLO 'a' 's' = return 's'+mixLO 'a' 'c' = return 'v'+mixLO 'a' 'S' = return 'v'+mixLO 'k' 'i' = return 'c'+mixLO 'k' 'a' = return 's'+mixLO 'k' 's' = return 's'+mixLO 'k' 'c' = return 'c'+mixLO 'k' 'S' = return 'c'+mixLO 'i' 'k' = return 'c'+mixLO 'i' 'a' = return 'v'+mixLO 'i' 'c' = return 'c'+mixLO 'i' 's' = return 'v'+mixLO 'i' 'S' = return 'c'+mixLO 'S' 'i' = return 'c'+mixLO 'S' 'k' = return 'c'+mixLO 'S' 'a' = return 'v'+mixLO 'S' 'c' = return 'c'+mixLO 'S' 's' = return 'v'+mixLO a b+  | a == b    = return a+  | otherwise = throwError $ "mixLO unexpected combination: " ++ [a,' ',b]++type ArgCtx r = StateT (Int,((Int,Int), Bool)) (Writer [String]) r++getLbl = do+  (x,b) <- get+  put (succ x,b)+  return (toEnum x)++incr = do+  (x,((i1,i2),b)) <- get+  if not b+    then put (x,((succ i1,i2),b))+    else put (x,((i1,succ i2),b))++setOpt = do+  (x,((i1,i2),b)) <- get+  if not b+    then put (x,((succ i1,i2),True))+    else put (x,((i1,succ i2),True))++tellS s = tell [s] >> return Nothing++optIRateInargs = "opqvjh"++parseInarg :: Char -> ArgCtx (Maybe String)+parseInarg 'a' = incr >> return (Just "ASig repr")+parseInarg 'k' = incr >> return (Just "KSig repr")+parseInarg 'i' = incr >> return (Just "INum repr")+parseInarg 'f' = incr >> return (Just "FSig repr")+parseInarg 'O' = setOpt >> getLbl >>= \l -> return $+  Just ([l]) -- optional i or k var+parseInarg 'p' = setOpt >> return (Just "INum repr")+parseInarg 'S' = incr >> return (Just "VString repr")+parseInarg 'T' = incr >> return (Just "VString repr") -- a file, which can either be a file name or a number (e.g. pvoc.nnn)+parseInarg 'x' = incr >> getLbl >>= \l -> return $+  Just [l] -- i or k var+parseInarg 'm' = incr >> return (Just "[INum repr]")+parseInarg 'M' = incr >> getLbl >>= \l -> return (Just $ "[" ++ [l] ++ "]")+parseInarg 'N' = incr >> return+  (Just "[(INum repr, INum repr)]")+parseInarg 'y' = incr >> return (Just "[ASig repr]")+parseInarg 'z' = incr >> return (Just "[KSig repr]")+parseInarg 'Z' = incr >> return (Just "[(KSig repr, ASig repr)]")+parseInarg c+  | c `elem` optIRateInargs = setOpt >> return (Just "INum repr")+parseInarg z   = tellS $ "unknown inarg: " ++ [z]++inargLbls :: Int -> Char -> ArgCtx (Maybe Int)+inargLbls i 'O' = parseInarg 'O' >> return (Just i)+inargLbls i 'x' = parseInarg 'x' >> return (Just i)+inargLbls i 'M' = parseInarg 'M' >> return (Just i)+inargLbls i c   = parseInarg c   >> return Nothing++-- | Left if in the instance head, Right if in the decl.+inArgInstanceInfo :: Char -> Either String String+inArgInstanceInfo 'a' = Right "(ASig (S n))"+inArgInstanceInfo 'k' = Right "(KSig (S n))"+inArgInstanceInfo 'i' = Right "(INum (S n))"+inArgInstanceInfo 'f' = Right "(FSig (S n))"+inArgInstanceInfo 'o' = Right "(INum (S n))"+inArgInstanceInfo 'O' = Left  "KVar "+inArgInstanceInfo 'p' = Right "(INum (S n))"+inArgInstanceInfo 'S' = Right "(VString (S n))"+inArgInstanceInfo 'T' = Right "(VString (S n))"+inArgInstanceInfo 'x' = Left  "Varable "+inArgInstanceInfo 'm' = Right "[INum (S n)]"+inArgInstanceInfo 'M' = Left  "Varable "+inArgInstanceInfo 'N' = Right "[(INum (S n), INum (S n))]"+inArgInstanceInfo 'y' = Right "[ASig (S n)]"+inArgInstanceInfo 'z' = Right "[KSig (S n)]"+inArgInstanceInfo 'Z' = Right "[(KSig (S n), ASig (S n))]"+inArgInstanceInfo _   = error "invalid inArg in 'inArgInstanceInfo'"++-- | modifications that change the number of inargs, must come before+--   other manipulations of inargs+preMungeInarg :: String -> String+preMungeInarg = concatMap f+ where+  f 'n' = "iN"+    -- convert an odd-numbered list to a required arg and even-numbered list+  f c   = [c]++-- | for an inarg, calc.+-- (totalNumArgs, [VarPos (0ix), VarName], Maybe reqNum)+getInArgTyVars :: String -> Either String (Int, [(Int,Char)], Maybe Int)+getInArgTyVars instrng' =+  either (Left)+         (\(tyvars,_,tnum,mreq) ->+             Right $ (tnum,zip (catMaybes mres) tyvars,mreq))+         (runParseI instrng)+ where+  instrng = preMungeInarg instrng'+  ((mres, _), _) =+    runWriter $ runStateT (mapM (uncurry inargLbls) $ zip [0..] instrng)+                          (fromEnum 'a', ((-1,-1), False))+  ++runParseI :: String -> Either String ([Char], [String], Int, Maybe Int) -- (type variables, args, totalnum, maybe number of required args)+runParseI instrng' =+  maybe (Left $ intercalate "\n\t" (instrng:errS))+        (\resstrn -> Right+                     (['a' .. toEnum (lastLbl-1)]+                     ,resstrn+                     ,numReq+numOpt+2+                     ,if hasOpts then Just numReq else Nothing))+        (sequence mres)+ where+  instrng = preMungeInarg instrng'+  ((mres, (lastLbl,((numReq,numOpt), hasOpts))), errS) =+    runWriter $ runStateT (mapM parseInarg instrng)+                          (fromEnum 'a', ((-1,-1), False))+++parseOutarg :: String -> Either String OType+parseOutarg ""  = Right U+parseOutarg "a" = Right A+parseOutarg "k" = Right K+parseOutarg "i" = Right I+parseOutarg "f" = Right F+parseOutarg "ik" = Right IK+parseOutarg "ki" = Right KI+parseOutarg "kk" = Right KK+parseOutarg "ff" = Right FF+parseOutarg "aa" = Right AA+parseOutarg "ak" = Right AK+parseOutarg "kkk"  = Right KKK+parseOutarg "aaa"  = Right AAA+parseOutarg "kkkk" = Right KKKK+parseOutarg "aaaa" = Right AAAA+parseOutarg "iiii" = Right IIII+parseOutarg "c" = Right C+parseOutarg "v" = Right V+parseOutarg "s" = Right S+parseOutarg "ss" = Right SS+parseOutarg "S" = Right Str+parseOutarg arg+ | arg == replicate (length arg) 'm' = Right MA+ | otherwise                         = Left $ "can't parse outarg: " ++ arg++data OType =+   A+ | K+ | I+ | F+ | U+ | IK+ | KI+ | KK+ | FF+ | AA+ | AK+ | AAA+ | KKK+ | AAAA+ | KKKK+ | IIII+ | C+ | V+ | S+ | SS+ | Str+ | MA+ deriving (Eq, Show, Read, Ord, Enum)++data OCtxt = OCtxt {+  var :: Bool+ ,nat :: Bool }+ deriving (Eq, Show)++hasOCtxt (OCtxt b1 b2) = b1 || b2++nullCtxt = OCtxt False False+outCtxt  = OCtxt True  False+natCtxt  = OCtxt False True++getCtxt (OCtxt False False) = ""+getCtxt (OCtxt True  False) = "out "+getCtxt (OCtxt False  True) = "d "+getCtxt (OCtxt True   True) = "out d "++-- | convert OType to a ctxtRepr (for mkClass)+ctxtRepr U  = (nullCtxt, "repr ()")+ctxtRepr A = (nullCtxt, "repr (ASig repr)")+ctxtRepr K = (nullCtxt, "repr (KSig repr)")+ctxtRepr I = (nullCtxt, "repr (INum repr)")+ctxtRepr F = (nullCtxt, "repr (FSig repr)")+ctxtRepr IK = (nullCtxt, "repr (INum repr, KSig repr)")+ctxtRepr KI = (nullCtxt, "repr (KSig repr, INum repr)")+ctxtRepr KK = (nullCtxt, "repr (KSig repr, KSig repr)")+ctxtRepr FF = (nullCtxt, "repr (FSig repr, FSig repr)")+ctxtRepr AA = (nullCtxt, "repr (ASig repr, ASig repr)")+ctxtRepr AK = (nullCtxt, "repr (ASig repr, KSig repr)")+ctxtRepr AAA = (nullCtxt, "repr (ASig repr, ASig repr, ASig repr)")+ctxtRepr KKK = (nullCtxt, "repr (KSig repr, KSig repr, KSig repr)")+ctxtRepr AAAA = (nullCtxt, "repr (ASig repr, ASig repr, ASig repr, ASig repr)")+ctxtRepr KKKK = (nullCtxt, "repr (KSig repr, KSig repr, KSig repr, KSig repr)")+ctxtRepr IIII = (nullCtxt, "repr (INum repr, INum repr, INum repr, INum repr)")+ctxtRepr MA   = (natCtxt, "repr (TList d (ASig repr))")+ctxtRepr S    = (outCtxt, "repr out")+ctxtRepr V    = (outCtxt, "repr out")+ctxtRepr C    = (outCtxt, "repr out")+ctxtRepr SS   = (outCtxt, "repr (out,out)")+ctxtRepr Str  = (nullCtxt, "repr (VString repr)")++iHasCtxt = fst . ctxtRepr++-- | convert OType to data for instance heads+instrCtx S  = Just ("PVar out",1)+instrCtx SS = Just ("PVar out",2)+instrCtx C  = Just ("KVar out",1)+instrCtx V  = Just ("Varable out",1)+instrCtx MA = Just ("Nat d",1)+instrCtx _  = Nothing++oHasCtxt = isJust . instrCtx++-- | determine the proper outtype for instance decls+monoCtxt A    = "(ASig (S n))"+monoCtxt K    = "(KSig (S n))"+monoCtxt I    = "(INum (S n))"+monoCtxt F    = "(FSig (S n))"+monoCtxt U    = "()"+monoCtxt IK   = "(INum (S n), KSig (S n))"+monoCtxt KI   = "(KSig (S n), INum (S n))"+monoCtxt KK   = "(KSig (S n), KSig (S n))"+monoCtxt FF   = "(FSig (S n), FSig (S n))"+monoCtxt AA   = "(ASig (S n), ASig (S n))"+monoCtxt AK   = "(ASig (S n), KSig (S n))"+monoCtxt AAA  = "(ASig (S n), ASig (S n), ASig (S n))"+monoCtxt KKK  = "(KSig (S n), KSig (S n), KSig (S n))"+monoCtxt AAAA = "(ASig (S n), ASig (S n), ASig (S n), ASig (S n))"+monoCtxt KKKK = "(KSig (S n), KSig (S n), KSig (S n), KSig (S n))"+monoCtxt IIII = "(INum (S n), INum (S n), INum (S n), INum (S n))"+monoCtxt Str  = "(VString (S n))"+monoCtxt MA   = "d"+monoCtxt S    = "out"+monoCtxt SS   = "out"+monoCtxt C    = "out"+monoCtxt V    = "out"
+ tools/CsoundImplTemplate.hs view
@@ -0,0 +1,823 @@+{-# LANGUAGE+     NoMonomorphismRestriction+    ,DoRec+    ,ExtendedDefaultRules+    ,TypeFamilies+    ,DeriveDataTypeable+    ,DeriveFunctor+    ,GeneralizedNewtypeDeriving+    ,ScopedTypeVariables+    ,MultiParamTypeClasses+    ,FlexibleInstances+    ,TupleSections+    ,OverlappingInstances+    ,TypeSynonymInstances #-}++module Language.XDsp.Implementations.Csound (+  S (..)+ ,BusType (..)+ ,HostOut (..)+ ,RType+ ,defaultRType+ ,unifyCsd+ ,writeHeader+ ,makeInstrument+ ,TList+ ,unTList'+ ,module Language.XDsp.Semantics.CsoundExt+)++where++import           Language.XDsp.Semantics+import           Language.XDsp.Semantics.CsoundExt hiding (CsOscil (..), CsOscili (..), CsSum (..))+import qualified Language.XDsp.Semantics.CsoundExt as CSE++import           Data.Char+import           Data.Data+import           Data.List (intersperse, intercalate)+import qualified Data.Map as M+import           Data.Maybe (fromMaybe, catMaybes)+import qualified Data.Set as S+import qualified Data.Text as T+import qualified Data.Text.Lazy as TL+import           Data.TypeLevel.Num ((:>=:), Nat, toInt)+import           Control.Monad.RWS+import           Control.Applicative+import           Control.Arrow++import           Text.Printf++-- ---------------------------------+-- ---------------------------------++-- |Initial csound pretty-printer++data CVar =+    Cnst Double+  | CStr String+  | CVar String+  deriving (Eq, Ord, Show, Read)++data VarType =+    A                  -- A-rate signal+  | K                  -- K-rate signal+  | I                  -- i-time value+  | F                  -- fsig+  | T                  -- function table+  | IC                 -- score i-statement+  | St                 -- String+  | U                  -- Unit+  | Tp VarType VarType -- tuple+  | T3 VarType VarType VarType         -- 3-tuple+  | T4 VarType VarType VarType VarType -- 4-element tuple+  | CList VarType      -- list+  deriving (Eq, Ord, Read, Show)++-- | get the initial character of a csound var from a VarType+mkChr :: VarType -> Char+mkChr T  = 'f'+mkChr IC = 'i'+mkChr St = 'i'  -- string type stored in ivals+mkChr x = toLower . head . show $ x++getLbl :: CVar -> String+getLbl (Cnst x)   = show x+getLbl (CStr s)   = show s+getLbl (CVar s)   = s++-- |Polyvariadic support for building argument lists+class ArgListBuilder r where+  appendToList :: [String] -> r++instance ArgListBuilder [String] where+  appendToList = reverse++instance (Varable a, ArgListBuilder r) => ArgListBuilder (a -> r) where+  appendToList arg = appendToList . (\acc a -> getVarLbl a : acc) arg++mkOp0 :: Varable out => String -> S n out+mkOp0 opname = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s\n" outName opname+  return out++-- |helper function to create a 1-argument opcode instance.+-- I should make these with TH, but that would require having "genName" in scope+-- which means S would need to be in scope, but then all the S instances+-- would be orphans, which I don't want either...+mkOp1 :: (Varable a, Varable out) => String -> a -> S n out+mkOp1 opname a1 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname (getVarLbl a1)+  return out++mkOp2 opname a1 a2 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2)+  return out++mkOp3 opname a1 a2 a3 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3)+  return out++mkOp4 opname a1 a2 a3 a4 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4)+  return out++mkOp5 opname a1 a2 a3 a4 a5 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5)+  return out++mkOp6 opname a1 a2 a3 a4 a5 a6 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6)+  return out++mkOp7 opname a1 a2 a3 a4 a5 a6 a7 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7)+  return out++mkOp8 opname a1 a2 a3 a4 a5 a6 a7 a8 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7 a8)+  return out++mkOp9 opname a1 a2 a3 a4 a5 a6 a7 a8 a9 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7 a8 a9)+  return out++mkOp10 opname a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7 a8 a9 a10)+  return out++mkOp11 opname a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11)+  return out++mkOp12 opname a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12)+  return out++mkOp13 opname a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13)+  return out++mkOp17 opname a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15 a16 a17 = do+  (out, outName) <- genName+  tellOrc $ printf "%s %s %s\n" outName opname+    (argCleaner $ appendToList [] a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15 a16 a17)+  return out++-- | remove null arguments; these appear when a list of arguments is empty.+argCleaner :: [String] -> String+argCleaner = intercalate ", " . filter (Prelude.not . null)++mkOp14 = error "mkOp14"+mkOp15 = error "mkOp15"+mkOp16 = error "mkOp16"+mkOp18 = error "mkOp18"+mkOp19 = error "mkOp19"+mkOp22 = error "mkOp22"+mkOp26 = error "mkOp26"+mkOp32 = error "mkOp32"+mkOp83 = error "mkOp83"+mkOp99 = error "mkOp99"+mkOp51 = error "mkOp51"+mkOp34 = error "mkOp34"+mkOp43 = error "mkOp43"++-- ------------------------------------------+-- ------------------------------------------+-- sco helpers++-- | A score item.  The "Card" name is old-school+data Card = Card VarType [String] deriving (Eq, Read, Show)++card2str :: Card -> String+card2str (Card typ args) = mkChr typ : unwords args ++ "\n"++writeCard :: Card -> S n ()+writeCard = tellSco . card2str++mkTbl :: Int -> Int -> Int -> [Int] -> Card+mkTbl nm time sz args = Card T . map show $ nm:time:sz:args++-- |Create a 0-filled f-statement in the score section.+mkScoreBuf :: Int -> Int -> S n ()+mkScoreBuf nm sz = writeCard $ mkTbl nm 0 sz [17,0,0]++-- | Holds data on a score item for memoization purposes.+data CardM = CardM VarType String String deriving (Eq, Ord, Show)++cacheBuf :: String -> Int -> CardM+cacheBuf lbl = CardM T lbl . show++-- ------------------------------------------+-- ------------------------------------------+-- external interface helpers++data BusType = KBus | TblBus Int deriving (Eq, Read, Show)++-- |Specifies details for a Host output described within the language.+-- First string is a host-specified label.  Second is an auto-generated+-- name (e.g. tablenum)+data HostOut = HostOut {+  busType :: BusType,+  busLbl  :: String,+  busName :: String } deriving (Eq, Read, Show)++-- ------------------------------------------+-- ------------------------------------------++data CacheKey =+ CKC CardM    -- score cache+ deriving (Eq, Ord, Show)++type WCache  = M.Map CacheKey CVar+type GenMap  = M.Map VarType Int+type ICache = S.Set Int+data SState  = SState {+  wcache :: WCache+ ,genMap :: GenMap+ ,iCache :: ICache}++type ScoType = TL.Text+type OrcType = TL.Text+type HostType = [HostOut]++type WType = (ScoType, OrcType, HostType)+type RType = (Integer, Integer) -- SR and ksmps++defaultRType = (44100,16)++newtype S n a = S { unS :: RWS RType WType SState a }+  deriving (Functor, Applicative, Monad, Typeable)++instance MonadFix (S n) where+  mfix f = S $ mfix (unS . f)++instance MonadState (S n) where+  type StateType (S n) = SState+  get = S get+  put = S . put++instance MonadWriter (S n) where+  type WriterType (S n) = WType+  tell   = S . tell+  listen = S . listen . unS+  pass   = S . pass . unS++instance MonadReader (S n) where+  type EnvType (S n) = RType+  ask   = S ask+  local f = S . local f . unS++csdHeader =+  "<CsoundSynthesizer>\n\+  \<CsOptions>\n\+  \%s\n\+  \</CsOptions>\n"++-- -------------------------+-- helpers for working with states++getGen :: S n GenMap+getGen = fmap genMap get++putGen :: GenMap -> S n ()+putGen newstate = modify (\ss -> ss {genMap = newstate})++cache  :: CacheKey -> CVar -> S n ()+cache key val = do+  SState cmap gen imap <- get+  put $ SState (M.insert key val cmap) gen imap++cacheInstr :: Int -> S n ()+cacheInstr n = modify (\ss -> let ic' = S.insert n (iCache ss) in ss { iCache = ic' })++instrInCache :: Int -> S n Bool+instrInCache n = do+  (SState _ _ imap) <- get+  return $ S.member n imap++tellOrc :: String -> S n ()+tellOrc s = tell (TL.pack s,mempty, mempty)++tellSco :: String -> S n ()+tellSco s = tell (mempty,TL.pack s,mempty)++tellHost :: HostOut -> S n ()+tellHost s = tell (mempty,mempty, [s])++runS :: S n a -> RType -> (a, SState, WType)+runS e rt = runRWS (unS e) rt (SState M.empty M.empty S.empty)++evalS :: S n a -> RType -> a+evalS e rt = let (a,_,_) = runS e rt in a++getWritten :: RType -> S n x -> WType+getWritten rt e = let (_,_,w) = runS e rt in w++-- |Creates a CSD formatted String from args and an x-dsp expression.+unifyCsd :: [String] -> RType -> S n x -> (TL.Text, [HostOut])+unifyCsd args r = unifyCsd' args . getWritten r++-- |Creates a CSD file from an argument list and Writer output+unifyCsd' :: [String] -> WType -> (TL.Text, [HostOut])+unifyCsd' args (orc, sco, host) = (csd, host)+ where+  oH = TL.pack "<CsInstruments>\n"+  oF = TL.pack "\n</CsInstruments>\n"+  sH = TL.pack "<CsScore>\n"+  sF = TL.pack "\ne\n</CsScore>\n</CsoundSynthesizer>\n"++  csd = TL.concat [TL.pack (printf csdHeader (unwords args))+                  ,oH ,orc ,oF ,sH ,sco ,sF]++class Varable s where+  genName   :: S n (s, String)+  getVarLbl :: s -> String++class Varable s => PVar s where++class Varable s => KVar s where++-- |Create a new number of the appropriate type.+-- This can be made into a name by prepending the type character.+mkName :: VarType -> S n Int+mkName typ = do+  gen <- getGen+  let num = fromMaybe 1 $ M.lookup typ gen+  putGen $ M.alter (const $ Just (succ num)) typ gen+  return num+++-- ---------------------------------+-- ---------------------------------+-- Instances++instance Dsp (S n) where+  data (ASig (S n)) = S_A CVar+  data (KSig (S n)) = S_K CVar+  data (INum (S n)) = S_IN CVar+  getSr    = fst <$> ask+  getKsmps = snd <$> ask++instance Constants (S n) where+  cnst = return . S_IN . Cnst+  ckig = return . S_K . Cnst+  csig = return . S_A . Cnst++instance Varable (ASig (S n)) where+  genName = do+    SState omap gen imap <- get+    let num = fromMaybe 1 $ M.lookup A gen+        nm  = 'a' : show num+    put $ SState omap (M.alter (const $ Just (succ num)) A gen) imap+    return (S_A $ CVar nm, nm)+  getVarLbl (S_A c) = getLbl c++instance PVar (ASig (S n)) where++instance Varable (KSig (S n)) where+  genName = do+    SState omap gen imap <- get+    let num = fromMaybe 1 $ M.lookup K gen+        nm  = 'k' : show num+    put $ SState omap (M.alter (const $ Just (succ num)) K gen) imap+    return (S_K $ CVar nm, nm)+  getVarLbl (S_K c) = getLbl c++instance PVar (KSig (S n)) where+instance KVar (KSig (S n)) where++instance Varable (INum (S n)) where+  genName = do+    SState omap gen imap <- get+    let num = fromMaybe 1 $ M.lookup I gen+        nm  = 'i' : show num+    put $ SState omap (M.alter (const $ Just (succ num)) I gen) imap+    return (S_IN $ CVar nm, nm)+  getVarLbl (S_IN c) = getLbl c++instance Varable () where+  genName            = return ((), "")+  getVarLbl _        = "()"++instance Varable String where+  genName = error "Can't call 'genName' on String directly"+  getVarLbl s = '"' : s ++ "\""++instance Varable (VString (S n)) where+  genName = do+    SState omap gen imap <- get+    let num = fromMaybe 1 $ M.lookup St gen+        nm  = 'S' : show num+    put $ SState omap (M.alter (const $ Just (succ num)) St gen) imap+    return (S_VS $ CVar nm, nm)+  getVarLbl (S_VS c) = getLbl c++instance KVar (VString (S n)) where++instance (Varable a, Varable b) => Varable (a,b) where+  genName = do+    (o1,nm1) <- genName+    (o2,nm2) <- genName+    return ((o1,o2), nm1 ++ ", " ++ nm2)+  getVarLbl (a,b)      = getVarLbl a ++ ", " ++ getVarLbl b++instance (Varable a, Varable b, Varable c) =>+ Varable (a,b,c) where+  genName = do+    (o1,nm1) <- genName+    (o2,nm2) <- genName+    (o3,nm3) <- genName+    return ((o1,o2,o3), intercalate ", " [nm1, nm2, nm3])+  getVarLbl (a,b,c) =+    intercalate ", " [getVarLbl a, getVarLbl b,getVarLbl c]++instance (Varable a, Varable b, Varable c, Varable d) => Varable (a,b,c,d) where+  genName = do+    (o1,nm1) <- genName+    (o2,nm2) <- genName+    (o3,nm3) <- genName+    (o4,nm4) <- genName+    return ((o1,o2,o3,o4), intercalate ", " [nm1, nm2, nm3, nm4])+  getVarLbl (a,b,c,d) =+    intercalate ", " [getVarLbl a, getVarLbl b,getVarLbl c, getVarLbl d]++instance Varable a => Varable [a] where+  genName             = error "Can't generate names for arbitrary lists"+  getVarLbl           = intercalate ", " . map getVarLbl++instance forall d a. (Varable a, Nat d) => Varable (TList d a) where+  genName = do+    outss <- replicateM (toInt (undefined :: d)) genName+    return (TList $ map fst outss, intercalate ", " $ map snd outss)+  getVarLbl           = intercalate ", " . map getVarLbl . unTList++instance KVar (INum (S n)) where++instance PVS (S n) where+  data FSig (S n) = S_FSig CVar++instance Varable (FSig (S n)) where+  genName = do+    SState omap gen imap <- get+    let num = fromMaybe 1 $ M.lookup F gen+        nm  = 'f' : show num+    put $ SState omap (M.alter (const $ Just (succ num)) F gen) imap+    return (S_FSig $ CVar nm, nm)+  getVarLbl (S_FSig c) = getLbl c++-- | need this to directly use numeric literals as arguments.+instance Varable Double where+  genName   = error "genName shouldn't be called with Doubles"+  getVarLbl = show++instance StringVar (S n) where+  data VString (S n) = S_VS CVar++-- ---------------------------------+-- ---------------------------------+-- The csound class+instance CsoundClass (S n) where+  nchnls n   = tellOrc (printf "nchnls = %i\n" n) >> return n+  set0dbfs n = tellOrc (printf "0dbfs = %f\n" n) >> return n++-- ---------------------------------+-- ---------------------------------+-- Numeric support for signals+instance Show (ASig (S n)) where+  show (S_A s) = show s++instance Eq (ASig (S n)) where+  (S_A a) == (S_A b) = a == b++instance Num (ASig (S n)) where+  (S_A a) + (S_A b) = S_A . CVar $ printf "(%s + %s)" (getLbl a) (getLbl b)+  (S_A a) - (S_A b) = S_A . CVar $ printf "(%s - %s)" (getLbl a) (getLbl b)+  (S_A a) * (S_A b) = S_A . CVar $ printf "(%s * %s)" (getLbl a) (getLbl b)+  abs _       = error "abs called on (ASig (S n))"+  signum      = error "signum called on (ASig (S n))"+  fromInteger = S_A . Cnst . fromInteger++instance Fractional (ASig (S n)) where+  (S_A a) / (S_A b) = S_A . CVar $ printf "(%s / %s)" (getLbl a) (getLbl b)+  fromRational = S_A . Cnst . fromRational++instance Show (KSig (S n)) where+  show (S_K s) = show s++instance Eq (KSig (S n)) where+  (S_K a) == (S_K b) = a == b++instance Num (KSig (S n)) where+  (S_K a) + (S_K b) = S_K . CVar $ printf "(%s + %s)" (getLbl a) (getLbl b)+  (S_K a) - (S_K b) = S_K . CVar $ printf "(%s - %s)" (getLbl a) (getLbl b)+  (S_K a) * (S_K b) = S_K . CVar $ printf "(%s * %s)" (getLbl a) (getLbl b)+  abs _       = error "abs called on (KSig (S n))"+  signum      = error "signum called on (KSig (S n))"+  fromInteger = S_K . Cnst . fromInteger++instance Fractional (KSig (S n)) where+  (S_K a) / (S_K b) = S_K . CVar $ printf "(%s / %s)" (getLbl a) (getLbl b)+  fromRational = S_K . Cnst . fromRational++instance Show (INum (S n)) where+  show (S_IN s) = show s++instance Eq (INum (S n)) where+  (S_IN a) == (S_IN b) = a == b++instance Num (INum (S n)) where+  (S_IN (Cnst a)) + (S_IN (Cnst b)) = S_IN $ Cnst (a+b)+  (S_IN a) + (S_IN b) = S_IN . CVar $ printf "(%s + %s)" (getLbl a) (getLbl b)+  (S_IN (Cnst a)) - (S_IN (Cnst b)) = S_IN $ Cnst (a-b)+  (S_IN a) - (S_IN b) = S_IN . CVar $ printf "(%s - %s)" (getLbl a) (getLbl b)+  (S_IN (Cnst a)) * (S_IN (Cnst b)) = S_IN $ Cnst (a*b)+  (S_IN a) * (S_IN b) = S_IN . CVar $ printf "(%s * %s)" (getLbl a) (getLbl b)+  abs _       = error "abs called on (INum (S n))"+  signum      = error "signum called on (INum (S n))"+  fromInteger = S_IN . Cnst . fromInteger++instance Fractional (INum (S n)) where+  (S_IN (Cnst a)) / (S_IN (Cnst b)) = S_IN . Cnst $ a/b+  (S_IN a) / (S_IN b) = S_IN . CVar $ printf "(%s / %s)" (getLbl a) (getLbl b)+  fromRational = S_IN . Cnst . fromRational++instance Show s => Show ((S n) s) where+  show s = show $ evalS s defaultRType++instance Eq e => Eq ((S n) e) where+  e1 == e2 = evalS ((==) <$> e1 <*> e2) defaultRType++instance Num e => Num ((S n) e) where+  e1 + e2     = (+) <$> e1 <*> e2+  e1 - e2     = (-) <$> e1 <*> e2+  e1 * e2     = (*) <$> e1 <*> e2+  abs         = fmap Prelude.abs+  signum      = fmap signum+  fromInteger = pure . fromInteger++instance Fractional e => Fractional ((S n) e) where+  e1 / e2 = (/) <$> e1 <*> e2+  recip   = fmap recip+  fromRational = pure . fromRational++-- ---------------------------------+-- ---------------------------------+-- core language extensions++-- | supports assignment+instance Varable a => Asn (S n) a where+  asn = mkOp1 "="++-- | supports output+instance Out (S n) where+  out = tellOrc . printf "       out %s\n" . getVarLbl+  outs a1 a2 = do+    (tellOrc $ printf "       outs %s, %s\n" (getVarLbl a1) (getVarLbl a2))+  outq a1 a2 a3 a4 = do+    (tellOrc $ printf "       outs %s, %s, %s, %s\n"+      (getVarLbl a1) (getVarLbl a2) (getVarLbl a3) (getVarLbl a4))+  outo a1 a2 a3 a4 a5 a6 a7 a8 = do+    (tellOrc $ printf "       outs %s, %s, %s, %s, %s, %s, %s, %s\n"+      (getVarLbl a1) (getVarLbl a2) (getVarLbl a3) (getVarLbl a4)+      (getVarLbl a5) (getVarLbl a6) (getVarLbl a7) (getVarLbl a8))++-- ---------------------------------+-- ---------------------------------+-- Buffers (function tables)++-- | creation of buffers+instance Buffer (S n) where+  type Buf (S n) = INum (S n)+  emptyBuffer sz = do+    bufNum <- mkName T+    mkScoreBuf bufNum sz+    return $ fromIntegral bufNum++instance (Varable a) => BufferR (S n) a a where+  lookupAt = flip (mkOp2 "tablei")++-- | creation of host-variable buffers+instance VBuf (S n) where+  vbuf lbl sz = do+    (SState cmap gen imap) <- get+    case M.lookup (CKC $ cacheBuf lbl sz) cmap of+      Just nm -> return $ S_IN nm+      Nothing -> do+        bufNum <- mkName T+        mkScoreBuf bufNum sz+        tellHost . HostOut (TblBus sz) lbl $ show bufNum+        let res = Cnst $ fromIntegral bufNum+        cache (CKC $ cacheBuf lbl sz) res+        return $ S_IN res++-- ---------------------------------+-- ---------------------------------+-- Instruments++instance (Nat m, Nat n, Show n, m :>=: n) => NumArgs S m n where+  getArg n = return . S_IN . CVar $ 'p': show n++-- | Labelled blocks (basic instrument creation)+instance LblBlock (S n) where+  type ArgTag (S n) = n+  type ArgTyp (S n) = Either String Double+  data Block (S n) = Instr Int+  lblBlock num e = do+    isCached <- instrInCache num+    when (Prelude.not isCached) $ do+      tellOrc (printf "instr %d\n" num) >> e >> tellOrc "endin\n\n"+      clearBlockData+      cacheInstr num+    return $ Instr num+  runBlock = runBlock'++getArgVal :: Either String Double -> String+getArgVal = either show show++makeInstrument :: S n () -> S n (Block (S n))+makeInstrument e = do+  SState _ _ imap <- get+  maybe (lblBlock 1 e) (\(n, _) -> lblBlock (n+1) e) $ S.maxView imap++-- | After labelling a block (csound instr), we need to clear the opcode+-- caches, otherwise code could be invalidly shared between instruments.+-- We can clear the name generator too (except for table nums).+clearBlockData :: S n ()+clearBlockData = do+  (SState cmap genmap imap) <- get+  let cmap' = M.mapMaybeWithKey cmf cmap+      genmap' = M.mapMaybeWithKey gmf genmap+  put $ SState cmap' genmap' imap+ where+  cmf k       v = Just v+  gmf T n       = Just n+  gmf _ _       = Nothing++-- | Runs a block (instr).+runBlock' ::+  Block (S n)+  -> Double+  -> Double+  -> TList m (Either String Double)+  -> S n ()+runBlock' (Instr blkLbl) startIn dur args =+  writeCard . Card IC $ [show blkLbl, show startIn, show dur]+                        ++ map getArgVal (unTList args)++-- runBlock' should have the constraint (n :>=: m), but that doesn't work+-- because the constraint isn't passed through the LblBlock class.+-- It's not a problem because the constraint is enforced by "getArg", so+-- only valid arguments will be used.++-- | Writes the header data+writeHeader :: Int -> Double -> S n ()+writeHeader nc dbfs = do+  (sr,ksmps) <- ask+  setSR sr+  setKSmps ksmps+  nchnls nc+  set0dbfs dbfs+  return ()++setSR n       = tellOrc (printf "sr = %i\n" n) >> return n+setKSmps n    = tellOrc (printf "ksmps = %i\n" n) >> return n++-- ---------------------------------+-- ---------------------------------+-- phasor+instance Phasor (S n) (KSig (S n)) (KSig (S n)) where+  phasor = mkOp1 "phasor"++instance (Varable a) => Phasor (S n) (ASig (S n)) a where+  phasor = mkOp1 "phasor"++-- oscillators++-- | Supports table-lookup oscillators+instance (Varable a, Varable b, PVar out) => Oscil (S n) out a b where+  oscil   = mkOp3 "oscil3"+  oscil'  = mkOp4 "oscil3"++-- ---------------------------------+-- ---------------------------------+-- delays+instance Delay (S n) where+  delaySamp = mkOp1 "delay1"+  vdelay3   = mkOp3 "vdelay3"++-- delay networks+instance DelayNet (S n) where+  type DelayN (S n) = SDelay n+  runDelay  = runDelay'+  tapA      = tap'+  tapK      = tap'+  tapI      = tap'++newtype SDelay n a = SDelay { unDelay :: S n a }+  deriving (Functor)++instance Applicative (SDelay n) where+  pure = SDelay . pure+  (SDelay a) <*> (SDelay b) = SDelay (a <*> b)++runDelay' :: INum (S n) -> ASig (S n) -> SDelay n a -> S n a+runDelay' maxdel insig dl = do+  tellOrc $ printf "aNull delayr %s\n" (getVarLbl maxdel)+  v <- unDelay dl+  tellOrc $ printf "    delayw %s\n" (getVarLbl insig)+  return v++tap' :: Varable b => b -> SDelay n (ASig (S n))+tap' dtime = SDelay $ mkOp1 "deltap3" dtime+++-- ---------------------------------+-- ---------------------------------+-- test instruments++-- | very basic block+t1 = do+  v <- csig 1000+  outs v v++-- | allocate a "variable buffer" (i.e. host-updated buffer)+t2 = do+  buf <- vbuf "a buffer" 8192+  so <- oscil 1000 440 buf+  outs so so++-- | delay networks++-- | simple delay with constant signal+t3 = do+  so <- runDelay 1 1000 (tapK 1)+  outs so so++t4 = do+  buf <- vbuf "a buffer" 8192+  so <- oscil 1000 440 buf+  let d = (\d1 d2 -> 0.5*d1+0.25*d2) <$> tapI 1 <*> tapI 2+  dl <- runDelay 2 so d+  sig <- asn $ so + dl+  outs sig sig++t5 = do+  buf <- vbuf "a buffer" 8192+  so  <- oscil 1000 440 buf+  let d = (\d1 d2 -> 0.5*d1+0.25*d2) <$> tapI 1 <*> tapI 2+  rec dl <- runDelay 2 (so+dl) d+  sig <- asn $ so + dl+  outs sig sig++t5' = do+  buf <- vbuf "a buffer" 8192+  so  <- oscil 1000 440 buf+  let d = (\d1 d2 -> 0.5*d1+0.25*d2) <$> tapI 1 <*> tapI 2+  rec dl <- runDelay 2 (so + 0.1*dl) d+  sig <- asn $ so + dl+  outs sig sig++-- | additive synthesis.  Shared buffer, uses the Num instance for signals.+t6 = do+  so  <- zipWithM (\fq buf -> oscil 1000 (fq*110) buf) [4..] (replicate 20 1)+  so' <- asn $ sum so+  outs so' so'++-- | using fold to make an oscil stack.  Note that emptyBuffer is *not*+-- memoized.+t8 = do+  buf <- emptyBuffer 8192+  stack <- foldM (\a f -> f a) (40)+                       (replicate 4 (\fq -> oscil 1000 fq buf))+  outs stack stack++-- | It's necessary to use monadic sequencing (here implicit in makeInstruments)+-- to chain instruments together+all1 = mapM makeInstrument [t1,t2, t3, t4, t5', t6, t8]
+ tools/foo.csd view
@@ -0,0 +1,24 @@+<CsoundSynthesizer>+<CsOptions>+-d+</CsOptions>+<CsInstruments>++    sr = 44100+    ksmps = 1+    nchnls = 2+    0dbfs  = 1+++instr 1+a1 oscili 0.8, 440, 1+  outs a1, a1+endin++</CsInstruments>+<CsScore>+f1 0 1024 10 1+i 1 0 0.5+e+</CsScore>+</CsoundSynthesizer>
+ tools/gen_Csound_Classes.sh view
@@ -0,0 +1,6 @@+#!/bin/bash++# move the Csound classes to Language/XDsp/Semantics/CsoundExt/All.hs++runghc "-hide-package mtl" "-framework CoreFoundation" mkClass.hs+cp allOps.txt ../src/Language/XDsp/Semantics/CsoundExt/All.hs
+ tools/gen_Csound_backend.sh view
@@ -0,0 +1,8 @@+#!/bin/bash++# combine the Csound Template file and the auto-generated instances, then+# move them to Language/XDsp/Implementations/Csound.hs++runghc "-hide-package mtl" "-framework CoreFoundation" mkOp.hs+cp CsoundImplTemplate.hs ../src/Language/XDsp/Implementations/Csound.hs+cat csdInstances.txt >> ../src/Language/XDsp/Implementations/Csound.hs
+ tools/mkClass.hs view
@@ -0,0 +1,94 @@+import           CsMaps+import           CsParser++import           Sound.Csound+import           Control.Arrow ((***))+import           Control.Applicative ((*>), (<*))+import           Control.Monad.Error+import           Control.Monad.State+import           Control.Monad.Writer+import qualified Data.Map as M+import           Data.Maybe+import qualified Data.Set as S+import           Text.Printf+import           Data.Char+import           Data.List (intercalate)++-- create a class description from OpcodeListEntry++-- | the opcodelist has duplicate entries for overloaded opcodes.+-- merge them to single polymorphic variants, collecting information+-- on errors+mergeOpcodeList :: [OpcodeListEntry] -> ([String], [OpcodeListEntry])+mergeOpcodeList = fmap M.elems . foldr fn ([],M.empty)+ where+  fn ocl (errs,mp) =+   let onm = opcodeName ocl+   in case M.lookup onm mp of+        Nothing   -> (errs,M.insert onm ocl mp)+        Just prev -> either (\err' -> (err':errs,mp))+                            (\n' -> (errs,M.insert onm n' mp))+                            (mixOcl ocl prev)+++mixOcl :: OpcodeListEntry -> OpcodeListEntry -> Either String OpcodeListEntry+mixOcl a b | opcodeName a == opcodeName b = do+  los <- zipWithM mixLO (ouTypes a) (ouTypes b)+  return $ OpcodeListEntry (opcodeName a) los (zipWith mixL (inTypes a) (inTypes b))+mixOcl a b = throwError "mixOcl called with non-matching entries"++type SpCtx = String -- stub++cap :: String -> String+cap []     = []+cap (a:as) = toUpper a:as++unCap :: String -> String+unCap []     = []+unCap (a:as) = toLower a:as++mkClass :: SpCtx -> OpcodeListEntry -> Writer [String] String+mkClass ctx ole = case (runParseI (inTypes ole), fmap ctxtRepr $ parseOutarg (ouTypes ole)) of+  (Right i, Right o) -> return $ topline i o ++ mainline i o ++ oline i o+  (Left ie, Left oe) -> tell [opc,ie,oe] >> return ""+  (Left ie, _)       -> tell [opc,ie] >> return ""+  (_,       Left oe) -> tell [opc,oe] >> return ""+ where+  opc = let n' = unCap $ opcodeName ole+        in fromMaybe n' $ M.lookup n' invalidNameMap+  topline (invars,inargs,_,reqNum) (hasOut,outarg) =+    printf "class %s %s repr %s%s where\n"+           ("(" ++ intercalate ", " (ctx:addCtxt (opcodeName ole)) ++ ") =>")+           ("Cs" ++ cap opc)+           (getCtxt hasOut)+           (intercalate " " $ map (:[]) invars)+  mainline (invars,inargs,_,reqNum) (hasOut,outarg) =+    printf "  %s ::\n    %s\n"+           opc+           (intercalate "\n    -> " $ (maybe id take reqNum inargs) ++ [outarg])+  oline (invars,inargs,_,reqNum) (hasOut,outarg) =+    maybe "" (const $ printf "  %s' :: %s\n"+                             opc+                             (intercalate "\n    -> " $ inargs ++ [outarg]))+             reqNum++allOps = do+  ops <- runCsound (compile "-d foo.csd" >> newOpcodeList <* cleanup)+  return $ either (error . show) id ops++writeOut fn ctx ops = do+  writeFile fn . intercalate "\n\n" $+    filter (not .null) (exts:mkModule allModName:vals)+  writeFile ("err_" ++ fn) $ intercalate "\n\n" (errs ++ errs1)+ where+  (errs1, ops') = mergeOpcodeList $ filter (not . flip S.member noReuseSet . opcodeName) ops+  (vals,errs) = runWriter $ mapM (mkClass ctx) ops'++exts = "{-# LANGUAGE TypeFamilies, MultiParamTypeClasses, FlexibleContexts #-}"++mkModule modname =+  "module " ++ modname ++ " where\n\nimport Language.XDsp.Semantics.Core\nimport Language.XDsp.Semantics.CsoundExt.Core\nimport Language.XDsp.Semantics.Extras\nimport Language.XDsp.Semantics.BasicExtensions"++allModName = "Language.XDsp.Semantics.CsoundExt.All"++main = allOps >>= writeOut "allOps.txt" "CsoundClass repr"
+ tools/mkOp.hs view
@@ -0,0 +1,116 @@+module Main (main) where++import           CsMaps+import           CsParser++import           Sound.Csound+import           Control.Arrow ((***), first)+import           Control.Applicative ((*>), (<*))+import           Control.Monad.Error+import           Control.Monad.State+import           Control.Monad.Writer+import qualified Data.Map as M+import qualified Data.Set as S+import           Data.Maybe+import           Text.Printf+import           Data.Char+import           Data.Either+import           Data.List (intercalate)++foldM1 f [] = error "foldM1 called on empty list"+foldM1 f (x:xs) = foldM f x xs++fromRight (Right val) = val+fromRight n           = error $ "fromRight called on Left" ++ show n++-- scheme for handling instances:+-- group all opcodes by name and determine var positions+-- group opcodes by output (a,k,i, other)+-- merge each group, separate instance for each output type+-- k-inputs can be k- or i-, use the KVar class++-- | partition opcode list into a list of+--  (name, fully-merged opcode, opcodes merged by outarg)+partitionOutarg :: [OpcodeListEntry]+  -> ([String], [(String, OpcodeListEntry, [(OType,OpcodeListEntry)])])+partitionOutarg = partitionEithers . map mungeTup . M.assocs . foldr f M.empty+ where+  -- make map of (name) to list of opcodes+  f ocl = M.insertWith (++) (opcodeName ocl) [ocl]+  g ocl = M.insertWith (++) (either (const SS) id . parseOutarg $ ouTypes ocl) [ocl]+  mungeTup (nm, ocls) = do+    fullMerge <- foldM1 mixOcl ocls+    let (chk,oMap) = M.mapEither (foldM1 mixOcl) $ foldr g M.empty ocls+    when (not $ M.null chk) (error "chk map isn't empty, shouldn't happen")+    return (nm, fullMerge, M.assocs oMap)++mixOcl :: OpcodeListEntry -> OpcodeListEntry -> Either String OpcodeListEntry+mixOcl a b | opcodeName a == opcodeName b = do+  los <- zipWithM mixLO (ouTypes a) (ouTypes b)+  return $ OpcodeListEntry (opcodeName a) los (zipWith mixL (inTypes a) (inTypes b))+mixOcl a b = throwError "mixOcl called with non-matching entries"++type SpCtx = String -- stub++cap :: String -> String+cap []     = []+cap (a:as) = toUpper a:as++unCap :: String -> String+unCap []     = []+unCap (a:as) = toLower a:as+++-- ops' :: (Name, MergedOp, [(OType, MergedOp)])+-- for each MergedOp, get the tyvar positions+-- then write an instance for each OType, filling in the tyvars++mkInstance :: String -> OpcodeListEntry -> (OType, OpcodeListEntry)+  -> Writer [String] String+mkInstance _ flmrg (otype, ole) = + case (getInArgTyVars (inTypes flmrg), parseOutarg (ouTypes flmrg)) of+   (Right i, Right o) -> return $ topline i o ++ mainline i o ++ oline i o+   (Left ie, Left oe) -> tell [opc,ie,oe] >> return ""+   (Left ie, _)       -> tell [opc,ie] >> return ""+   (_,       Left oe) -> tell [opc,oe] >> return ""+ where+  opc = let n' = unCap $ opcodeName ole+        in fromMaybe n' $ M.lookup n' invalidNameMap+  lookupInTyp (pos,vnm) = either+                          (\nm' -> Left $ nm' ++ [vnm])+                          (Right)+                          (inArgInstanceInfo $ (inTypes ole) !! pos)+  tyVars (pos,vnm) = either (const [vnm])+                            id+                            (inArgInstanceInfo $ (inTypes ole) !! pos)+  -- inargs :: [(VarPos, VarName)]+  topline (tnum,inargs,reqNum) fmOt =+    printf "instance %s %s (S n) %s where\n"+           (if null allHd then ""+             else printf "(%s) =>" (intercalate ", " allHd))+           (qualifyName $ "Cs" ++ cap opc)+           allDecl+     where+       (inHd, _) = partitionEithers $ map lookupInTyp inargs+       -- if the instance outtype needs a context, provide it+       allHd = maybe inHd ((:inHd) . fst) (instrCtx otype)+       inDecls = map tyVars inargs+       allDecl = unwords $ if oHasCtxt fmOt then (monoCtxt otype:inDecls) else inDecls+  mainline (tnum,inargs,reqNum) _ =+    printf "  %s = mkOp%d \"%s\"\n" opc (fromMaybe tnum reqNum) opc+  oline (tnum,inargs,reqNum) _ =+    maybe "" (const $ printf "  %s' = mkOp%d \"%s\"\n" opc tnum opc) reqNum++allOps = do+  ops <- runCsound (compile "-d foo.csd" >> newOpcodeList <* cleanup)+  return $ either (error . show) id ops++writeOut fn ctx ops = do+  writeFile fn $ intercalate "\n\n" . filter (not . null) $ concat vals+  writeFile ("err_" ++ fn) $ intercalate "\n\n" (errs ++ errs1)+ where+  -- ops' :: [ (Name, MergedOp, [(OType, MergedOp)]) ]+  (errs1, ops') = partitionOutarg $ filter (not . flip S.member noReuseSet . opcodeName) ops+  (vals,errs) = runWriter $ mapM (\(a,b,c) -> mapM (mkInstance a b) c) ops'++main = allOps >>= writeOut "csdInstances.txt" "CsoundClass repr =>"
+ x-dsp.cabal view
@@ -0,0 +1,46 @@+Name:                x-dsp+Version:             0.2+Synopsis:            A embedded DSL for manipulating DSP languages in Haskell+Description:         Provides a tagless-final language family for manipulating+                     audio programming languages (e.g. Csound, Supercollider).+                     A CSound backend is provided, however the language is+                     completely open so others can be added by users.+Homepage:            http://jwlato.webfactional.com/haskell/x-dsp+License:             GPL-3+License-file:        LICENSE+Author:              John W. Lato+Maintainer:          jwlato@gmail.com+Category:            Sound, Music+Build-type:          Simple+Cabal-version:       >=1.6++extra-source-files:+  README, tools/CsMaps.hs, tools/CsParser.hs, tools/CsoundImplTemplate.hs,+  tools/foo.csd, tools/gen_Csound_Classes.sh, tools/gen_Csound_backend.sh,+  tools/mkClass.hs, tools/mkOp.hs++Library+  Hs-Source-Dirs:    src+  Exposed-modules:   Language.XDsp.Semantics+                     Language.XDsp.Semantics.BasicExtensions+                     Language.XDsp.Semantics.Core+                     Language.XDsp.Semantics.CsoundExt+                     Language.XDsp.Semantics.CsoundExt.All+                     Language.XDsp.Semantics.CsoundExt.Core+                     Language.XDsp.Semantics.Extras+                     Language.XDsp.Semantics.Extras.Delay+                     Language.XDsp.Semantics.Extras.FSig+                     Language.XDsp.Implementations.Csound+                     Language.XDsp.Implementations.HaskellNative+  Build-depends:     base             >= 3   && < 5+                    ,array            >= 0.2 && < 0.4+                    ,bytestring       >= 0.9 && < 0.10+                    ,containers       >= 0.2 && < 0.5+                    ,monads-tf        >= 0.1 && < 0.2+                    ,text             >= 0.7 && < 0.13+                    ,transformers     >= 0.2 && < 0.3+                    ,type-level       >= 0.2 && < 0.3++source-repository head+  type:     darcs+  location: http://www.tiresiaspress.us/haskell/x-dsp