!>      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~          None =>?@ACHVXThe  type class is used to implement functions that have a variable number of arguments. It provides a family of type isomorphisms "fun x_x_UNI8773_x_x args -> res,where Gfun = a1 -> a2 -> ... -> an -> res, args = (a1, (a2, (..., (an, ()))))."Multiple curry: map a function (a [sub 1], (a0[sub 2], (x_x_UNI8230_x_x, ())) x_x_UNI8594_x_x b to its curried form a[sub 1] x_x_UNI8594_x_x a8[sub 2] x_x_UNI8594_x_x x_x_UNI8230_x_x x_x_UNI8594_x_x b."Multiple uncurry: map a function a[sub 1] x_x_UNI8594_x_x a8[sub 2] x_x_UNI8594_x_x x_x_UNI8230_x_x x_x_UNI8594_x_x b to its uncurried form (a [sub 1], (a0[sub 2], (x_x_UNI8230_x_x, ())) x_x_UNI8594_x_x b.%Often a low-level function, such as  or , throws an error because of a failure of some low-level condition, such as "list too short". To produce error messages that are meaningful to user-level code, these functions do not have a hard-coded error message. Instead, they input a stub error message.FA meaningful error message typically consists of at least three parts:^the name of the user-level function where the error occurred, for example: "reverse_generic";swhat the function was doing when the error occurred, for example: "operation not permitted in reversible circuit";Ka specific low-level reason for the error, for example: "dynamic lifting".|Thus, a meaningful error message may be: "reverse_generic: operation not permitted in reversible circuit: dynamic lifting".The problem is that the three pieces of information are not usually present in the same place. The user-level function is often a wrapper function that performs several different mid-level operations (e.g., transforming, reversing). The mid-level function knows what operation was being performed when the error occurred, but often calls a lower-level function to do the actual work (e.g., encapsulating).Therefore, a stub error message is a function that inputs some lower-level reason for a failure (example: "list too short") and translates this into a higher-level error message (example: "qterm: shape of parameter does not data: list too short").Sometimes, the stub error message may also ignore the low-level message and completely replace it by a higher-level one. For example, a function that implements integers as bit lists may wish to report a problem with integers, rather than a problem with the underlying lists. The type  a b witnesses the fact that a and bL are the same type. In other words, this type is non-empty if and only if a = bh. This property is not guaranteed by the type system, but by the API, via the fact that the operators U, V, and W are the only exposed constructors for this type. The implementation of this type is deliberately hidden, as this is the only way to guarantee its defining property.Identity types are useful in certain situations. For example, they can be used to define a data type which is polymorphic in some type variable xC, and which has certain constructors that are only available when x7 is a particular type. For example, in the declaration Gdata ExampleType x = Constructor1 x | Constructor2 x (Identity x Bool), Constructor1 is available for all x, but  Constructor2 is only available when x = .The identity monad. Using m = 2 gives useful special cases of monadic functions. kA string buffer holds a string that is optimized for fast concatenation. Note that this is an instance of   , and hence   operations (in particular N]) can be applied to string buffers. The following functions are synonyms of the respective  - functions, and are provided for convenience. {The type of bidirectional lists. This is similar to [a], but optimized for fast concatenation and appending on both sides. -The type of bit vectors. True = 1, False = 0.A  is just like an E, except that it supports some additional efficient operations: to find the smallest unused key, to find the set of all keys ever used in the past, and to reserve a set of keys so that they will not be allocated. Moreover, it keeps track of the highest key ever used (whether or not it is still used in the current map).3Apply a function to a specified position in a list.7Overwrite an element at a specified position in a list.$Check whether a list has duplicates. string character replacement$: Replace the first occurrence of  character in string by  replacement.$Insert the elements of a list in an  (cf. ).%Insert the given key-value pair in a `, but only if the given key is not already present. If the key is present, keep the old value. Take two s m [sub 1] and m[sub 2], and form a new  whose domain is that of m[sub 2], and whose value at k is the pair (m [sub 1] ! k, m [sub 2] ! k$). It is an error if the domain of m)[sub 2] is not a subset of the domain of m[sub 1]. Take two 's with the same domain, and form a new Y whose values are pairs. It is an error if the two inputs don't have identical domains.Like E, but also takes an error message to use in case of domain mismatch.%Map a function over all values in an .Monadic version of (. Map a function over all values in an .Delete a key from the .Delete a list of keys from a .#Insert a new key-value pair in the . (Insert a list of key-value pairs in the ."Look up the value at a key in the  . Return  if not found.&Check whether the given key is in the . The empty . !Return the first free key in the %, but without actually using it yet.!Return the next k unused keys in the ', but without actually using them yet." Convert a  to an .#*Return the smallest key never used in the .,Return the set of all keys ever used in the .$ A wire is dirty& if it is touched but currently free. Reserve a key in the . If the key is not free, do nothing. The key must have been used before; for example, this is the case if it was returned by $.%Reserve a set of keys in the . For any keys that are not free, do nothing. All keys must have been used before; for example, this is the case if they were returned by $.Unreserve a key in the . If the key is currently used, do nothing. The key must have been reserved before, and (therefore) must have been used before.& Unreserve a list of keys in the . If any key is currently used, do nothing. All keys must have been reserved before, and (therefore) must have been used before.'Make an exact copy of the , except that the set of touched wires is initially set to the set of used wires. In other words, we mark all free and reserved wires as untouched.(Like *H, but also pass a loop counter to the function being iterated. Example: )loop_with_index 3 x f = f 2 (f 1 (f 0 x)))Monadic version of (. Thus,  loop_with_indexM 3 x0 fwill do the following: ?do x1 <- f 0 x0 x2 <- f 1 x1 x3 <- f 2 x2 return x3*Iterate a function n times. Example: loop 3 x f = f (f (f x))+Monadic version of *.,A right-to-left version of T: Evaluate each action in the sequence from right to left, and collect the results.-Same as ,, but ignore the result..A "strict" version of C, i.e., raises an error when the lists are not of the same length./Like .F, but also takes an explicit error message to use in case of failure.0A "right strict" version of K, i.e., raises an error when the left list is shorter than the right one. 1 A version of 0F that also takes an explicit error message to use in case of failure.2A "strict" version of C, i.e., raises an error when the lists are not of the same length.3A "right strict" version of J, i.e., raises an error when the right list is shorter than the left one.4A right-to-left version of r, which is also "right strict", i.e., raises an error when the right list is shorter than the left one. Example: -zipRightWithM f [a,b] [x,y] = [f a x, f b y],computed right-to-left.5Same as 4, but ignore the result.6FFold over two lists with state, and do it right-to-left. For example, 'foldRightPairM (w0, [1,2,3], [a,b,c]) fwill do the following: Mdo w1 <- f (w0, 3, c) w2 <- f (w1, 2, b) w3 <- f (w2, 1, a) return w37Like 6, but ignore the final result.83Combine right-to-left zipping and folding. Example: fold_right_zip f (w0, [a,b,c], [x,y,z]) = (w3, [a',b',c']) where f (w0,c,z) = (w1,c') f (w1,b,y) = (w2,b') f (w2,a,x) = (w3,a')9Monadic version of 8.:A "for" loop. Counts from a to b in increments of s.Standard notation:  6for i = a to b by s do commands end forOur notation: &for a b s $ \i -> do commands endfor;rMark the end of a "for"-loop. This command actually does nothing, but can be used to make the loop look prettier.<FIterate a parameter over a list of values. It can be used as follows: Rforeach [1,2,3,4] $ \n -> do <<<loop body depending on the parameter n>>> endfor.The loop body will get executed once for each n x_x_UNI8712_x_x {1,2,3,4}.=+Every monad is a functor. Input a function f : a x_x_UNI8594_x_x b and output m f : m a x_x_UNI8594_x_x m b.>?Remove an outer application of a monad from a monadic function.?Take two functions f : a x_x_UNI8594_x_x b and g : c x_x_UNI8594_x_x d, and return f x_x_UNI8853_x_x g : a x_x_UNI8853_x_x c x_x_UNI8594_x_x c x_x_UNI8853_x_x d.@Monadic version of ?.ATake two functions f : a x_x_UNI8594_x_x b and g : c x_x_UNI8594_x_x d, and return f x_x_UNI215_x_x g : a x_x_UNI215_x_x c x_x_UNI8594_x_x c x_x_UNI215_x_x d.BMonadic version of A.CA version of the  function that returns an .DConvert an integer to a bit vector. The first argument is the length in bits, and the second argument the integer to be converted. The conversion is big-headian (or equivalently, little-tailian), i.e., the head of the list holds the integer's most significant digit.EConvert an integer to a bit vector. The first argument is the length in bits, and the second argument the integer to be converted. The conversion is little-headian (or equivalently, big-tailian), i.e., the head of the list holds the integer's least significant digit.FConvert a bit vector to an integer. The conversion is big-headian (or equivalently, little-tailian), i.e., the head of the list holds the integer's most significant digit. This function is unsigned, i.e., the integer returned is x_x_UNI8805_x_x 0.G+Convert a bit vector to an integer, signed.H#Exclusive or operation on booleans.I&Exclusive or operation on bit vectors.J+A general list-to-string function. Example: ;string_of_list "{" ", " "}" "{}" show [1,2,3] = "{1, 2, 3}"KK b s: if b =  , return s;, else the empty string. This function is for convenience.LConvert a List to a  .M Convert a   to a List.NFast concatenation of  s or string buffers.O The empty  .PConcatenate a list of  s.Q$Convert a string to a string buffer.R$Convert a string buffer to a string.SThe empty string buffer.T%Concatenate a list of string buffers.UWitness the fact that a=a.VWitness the fact that a=b implies b=a.WWitness the fact that a=b and b=c implies a=c.XThe identity function  : a x_x_UNI8594_x_x b, provided that a and b are the same type.V  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXV !"#$%&'*(8./0123+)45967,-:;<=>?@ABC DEFGHIJK LMNOP QRST UVWXNone>HVڔayExit with an error message after a command line error. This also outputs information on where to find command line help.b(Parse a string to an integer, or return  on failure.c0Parse a string to a list of integers, or return  on failure.dParse a string to a  , or return  on failure.eIn an association list, find the key that best matches the given string. If one key matches exactly, return the corresponding key-value pair. Otherwise, return a list of all key-value pairs whose key have the given string as a prefix. This list could be of length 0 (no match), 1 (unique match), or greater (ambiguous key). Note: the keys in the association list must be lower case. The input string is converted to lower case as well, resulting in case-insensitive matching.fPretty-print a list of possible values for a parameter. The first argument is the name of the parameter, and the second argument is its enumeration.abcdefabcdefNone>HV-gA data type for handlers.hDefault action.iIgnore the signal.j>Handle the signal in a new thread when the signal is received.kLike j(, but only handle the first such signal.%An operating system specific handler.l8A data type for signals. This can be extended as needed.mControl-C event.n-TERM signal (POSIX) or Close event (Windows).oFInstall a handler for the given signal. The old handler is returned. pmRun a block of code with a given signal handler. The previous handler is restored when the block terminates.Map an abstract l to a POSIX specific .Map a g to a POSIX specific handler.POSIX implementation of o. ghijklmnop lmnghijkopNone>HV{qSequentially try one or more IO computations, until one of them completes without an IO error. If all of them fail, re-throw the error from the last one.rr zoom pdffile(: Call a system-specific PDF viewer on pdffile file. The zoomE argument is out of 100 and may or may not be ignored by the viewer.sLike r, but specialized to Windows.tLike r, but specialized to Mac OS.uLike r, but specialized to Linux.qrstuqrstuNone &'>HSVXvTA container type to hold a source of randomness. This can hold any instance of the  class.vwvwNone>HV ycA 4x_x_UNI215_x_x4-matrix is represented as a 2x_x_UNI215_x_x2-matrix of 2x_x_UNI215_x_x2-matrices.z1Represent a 2x_x_UNI215_x_x2-matrix as a 4-tuple.{dIn general, Pauli operators can commute, or anti-commute, so we need to add signs or x_x_UNI177_x_xi.4The generators of a stabilizer group require a sign.[The Pauli operators can be used to generate a stabilizer group for the Clifford operators."Returns a boolean as to whether a  is negative (i.e.. ).Returns the negation of a .Two signs can be multiplied.Two {s can be multiplied. Extract a  embedded in a {8, or throw an error if the argument is not an embedded .FThe Levi-Civita symbol, for the permutations of three Pauli operators.,The Kronecker delta for two Pauli operators.The combination of the commutation and anti-commutation operators can be used to essentially multiply an (ordered) pair of Pauli operators.(Give the matrix for each Pauli operator.Scale a 2-by-2 matrix.PIf a matrix is Pauli, then return the Pauli operator, otherwise throw an error.4Matrix multiplication for 2x_x_UNI215_x_x2-matrices.BCompute the transpose of a 2x_x_UNI215_x_x2 complex-valued matrix.Return the matrix for Pauli-Y , which is iXZ.QThe tensor product of two 2x_x_UNI215_x_x2-matrices is a 4x_x_UNI215_x_x4 matrix.QA controlled operation can be expressed with just the operation to be controlled.STake the tensor of a pair of Pauli operators, and return a 4x_x_UNI215_x_x4 matrix. Scale a 4x_x_UNI215_x_x4 matrix.}If a matrix is the tensor product of two Pauli operators, then return the pair of Pauli operators, otherwise throw an error.4Matrix multiplication for 4x_x_UNI215_x_x4 matrices.:The transpose of a 4x_x_UNI215_x_x4 complex valued matrix.The tensor product IY can be defined by i(IX)(IZ).$yz{}|~${}|~zy None =>?HVaHVXl Lifted version of '(:)' :: a -> [a] -> [a].Lifted version of  '[]' :: [a].Lifted version of  :: [a] -> [a].Lifted version of  :: [a] -> [a].Lifted version of '(++)' :: [a] -> [a] -> [a].Lifted version of .lifted version of  lifted version of  lifted version of  Lifted version of 8 !Lifted version of the combinator . Lifted version of  :: String -> aN. Using it will make the circuit generation fail with the error described in .Lifted version of  :: (a,b) -> b             None>HVs0Type for the monad encapsulating error messages.Shortcut for 'Either String a'.<Set an error message, to be thrown. Usage: -errorMsg "an error happened" Make a ! computation error-message aware.RThrow the error that has been created, using the given string as a prefix. Usage: HextractQ "name of function: " $ do <<commands that may thow an error>> None>HV  The monad. Shortcut to StateT LiftState ErrMsgQ.State of the monad."How many times each name is bound.The template prefix .The name of the monad. An empty state.!"Retrieve the state from the monad."Set the state of the monad.#From  to .$From  to .%Get  out of &Set an error message.'0Increase the number of binds of a variable name.(0Decrease the number of binds of a variable name.)5Run a computation with a particular name being bound.*>Run a computation with a particular list of names being bound.+"Say whether a given name is bound.,Set the template prefix.-Get the template prefix..Set the monad name./Get the monad name.0Make a name out of a string.1+Make a name out of a string, monadic-style.2.Make any string into a string containing only  [0-9a-zA-Z_.].. For example, it replaces any occurrence of "+" with  "symb_plus_".3CTake a string and make it into a valid Haskell name starting with  "template_".4+Look for the corresponding "template" name.5,Make a the template version of a given name.62Print on the terminal a monadic, printable object.7!Project patterns out of a clause.8CCheck that the list is a non-empty repetition of the same element.9wReturns the length of the patterns in a list of clauses. Throw an error if the patterns do not have all the same size." !"#$%&'()*+,-./0123456789" !"#$%&'()*+,-./0123456789 None >HSVXC= Datatype to encode the notation  x <- expr.? Expression@Variable name.AConstant name.BLiteral.C Application.DLambda abstraction.ETuple.F If-then-else.GLet-construct.HCase distinctionIList: [...].Jhardcoded constant for .Khardcoded constant for .LFirst-level declaration.NMatch term construct.P Patterns.QLiteral.RVariable name.STuple.T Wildchar.UList as [...].VCons: h:t.W Literals.X Characters.Y Integers.ZReals.[mThere are no "guarded bodies". One net effect is to make the "where" construct equivalent to a simple "let".\ A simple do: list of monadic let followed by a computation.]+Get the set of variable names in a pattern.^Substitution in a N._Substitution in a L.`Substitution in an ?.a,Substitution of several variables in one go.bDowngrading TH literals to ?.cDowngrading TH literals to P.d&Take a list of patterns coming from a where: section and output a list of fresh names for normalized letys. Also gives a mapping for substituting inside the expressions. Assume all names in the list of patterns are distinct.eBuild a let-expression out of pieces.fBuild a N out of a TH clausegTFrom a list of TH clauses, make a case-distinction wrapped in a lambda abstraction.hDowngrade expressions.iDowngrade match-constructs.j"Downgrade bodies into expressions.kDowngrade patterns.l#Downgrade first-level declarations.m2Downgrade any declarations (including the ones in where -constructs).n1Abstract syntax tree of the type of the function .o1Abstract syntax tree of the type of the function .pUpgrade literalsqUpgrade patterns.rUpgrade match-constructs.sUpgrade declarations.tUpgrade expressions.u8Variable referring to the lifting function for integers.v5Variable referring to the lifting function for reals.wLifting literals.xLifting patterns.yLifting match-constructs.zLifting declarations.{!Lifting first-level declarations.|Lifting expressions.}Wmake a declaration into a template-declaration (by renaming with the template-prefix).~.pretty-printing Template Haskell declarations.-Pretty-printing Template Haskell expressions.Pretty-printing expressions.WLift a list of declarations. The first argument is the name of the monad to lift into.NLift an expression. The first argument is the name of the monad to lift into.F=>?KJIHGFEDCBA@LMNOPUTVSRQWZYX[\]^_`abcdefghijklmnopqrstuvwxyz{|}~F[WZYXPUTVSRQNOLM?KJIHGFEDCBA@=>\]^_`abcdefghijklmnopqrstuvwxyz{|}~None>HV{     None =>?@ACHV.In almost all instances, the standard form can also be deduced from the tupled form; the only exception is the unary case. The I class includes no new methods, adding just this functional dependency.While the methods of ! are always copied from those of v, they are renamed, so that use of these methods tells the type checker it can use the extra functional dependency.*This type class relates types of the form  t = (a,b,c,d)C (x_x_UNI8220_x_xtupled formx_x_UNI8221_x_x) to types of the form s = (a,(b,(c,(d,()))))o (x_x_UNI8220_x_xstandard formx_x_UNI8221_x_x), and provides a way to convert between the two representations.=The tupled form can always be deduced from the standard form.For example, maps (a,(b,(c,(d,())))) to  (a,b,c,d).For example, maps  (a,b,c,d) to (a,(b,(c,(d,())))).None =>?HVd Types in the k class have an "origin", i.e., an element that can conveniently serve as the starting point for intervals.ZInputs any element of the type and outputs the corresponding "zero" element, for example: %zero ([1,2],3,True) = ([0,0],0,False)The  class contains types for which an interval of values can be specified by giving a lower bound and an upper bound. Intervals are specified as  min max, for example: =interval (0,0) (1,2) = [(0,0),(0,1),(0,2),(1,0),(1,1),(1,2)].Takes a range (min,max5) and returns a list of all values with lower bound min and upper bound max. min max3: returns a list of all elements from the range (min,max'). This is actually just a synonym of . n k min max: returns every nth element from the range (min,max), starting with the k th element. g min max@: returns an infinite list of random samples from the range (min,max%), using the random number generator g. A variant of  that omits the min argument, and uses the  element of the type instead. A variant of  that omits the min argument, and uses the  element of the type instead. A variant of  that omits the min argument, and uses the  element of the type instead.samples every n0th element from the list, starting with element ksame as *, but throw an error if length don't matchLists7-Tuples6-Tuples5-Tuples4-TuplesTriplesPairs0-tuples  None 12>HV: !!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                  ! " # $ % & &  ' ( ) * + , - - . / / 0 1 2 3 4 5 6 ( ) ' 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M M N O P Q R S T U V W X Y Z  [ \ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                           mainQuipper.Utils.TemplateQuipper.Utils.SamplingQuipper.Utils.AuxiliaryQuipper.Utils.CommandLineQuipper.Utils.PortableSignalsQuipper.Utils.PreviewQuipper.Utils.RandomSourceQuipper.Utils.Stabilizers.Pauli"Quipper.Utils.Stabilizers.Clifford Quipper.Utils.Template.Auxiliary Quipper.Utils.Template.ErrorMsgQQuipper.Utils.Template.LiftQQuipper.Utils.Template.LiftingQuipper.Utils.TupleQuipper.Internal.QData qcdata_zipqcdata_promote Control.MonadzipWithMQuipper.Utils.Typeabletemplate-haskellLanguage.Haskell.TH.SyntaxQDec!random-1.1-3ypV4EIycgb35PKjTYYr5q System.RandomRandomCurrymcurrymuncurryErrMsgIdentityIdgetIdStrbufBListBoollistXIntMapapplyAt overwriteAthas_duplicates substituteintset_inserts map_provide intmap_zipintmap_zip_errmsg intmap_map intmap_mapMxintmap_deletexintmap_deletesxintmap_insertxintmap_insertsxintmap_lookupxintmap_member xintmap_emptyxintmap_freshkeyxintmap_freshkeysxintmap_to_intmap xintmap_size xintmap_dirtyxintmap_reservesxintmap_unreservesxintmap_makecleanloop_with_indexloop_with_indexMlooploopMsequence_rightsequence_right_ zip_strictzip_strict_errmsgzip_rightstrictzip_rightstrict_errmsgzipWith_strictzipWith_rightstrictzipRightWithRightStrictMzipRightWithRightStrictM_foldRightPairMfoldRightPairM_fold_right_zipfold_right_zipMforendforforeachmmap monad_join1 map_either map_eitherMmap_pair map_pairM int_ceilingboollist_of_int_bhboollist_of_int_lhint_of_boollist_unsigned_bhint_of_boollist_signed_bhbool_xor boollist_xorstring_of_listoptional blist_of_list list_of_blist+++ blist_empty blist_concatstrbuf_of_stringstring_of_strbuf strbuf_empty strbuf_concat reflexivitysymmetry transitivityidentity $fShowXIntMap $fShowBList $fFunctorId$fApplicativeId $fMonadId$fShowIdentity$fCurry->(,)res $fCurryb()boptfail parse_intparse_list_int parse_double match_enum show_enumHandlerDefaultIgnoreCatch CatchOnceSignal InterruptCloseinstallHandler with_handlertry_several_IOsystem_pdf_viewerwindows_pdf_viewermacos_pdf_viewerlinux_pdf_viewer RandomSource$fShowRandomSourceMatrix2Matrix1SignPlusMinusIPlusIOneSignPlusMinusPauliIXYZnegativenegate multiply_signmultiply_signPlussignPlus_to_sign levi_civitakronecker_deltacommute toMatrix1scale1 fromMatrix1multiplyMatrix1 transpose1my_Ytensor1control1 toMatrix2scale2 fromMatrix2multiplyMatrix2 transpose2my_IY $fShowSign$fShowSignPlus $fShowPauli $fEqPauli $fOrdSign$fEqSign CliffordCirc MinUnitary2 MinPauli2IXXIIZZIUnitary2 MinUnitaryMinPauliXminZminUnitaryTableauSTQubit next_qubitsigntableaude_sign de_tableaulookup empty_tableau add_qubit from_minimal from_matrix apply_unitaryapply_unitary_row from_minimal2 from_matrix2from_matrix_controlledapply_unitary2measurereducemultiply multiply_dexx_minx'x''yy_miny'y''zz_minz'z''hh_minh'h''ss_mins's''ee_mine'e''cnotcnot_mincnot'cnot''czcz_mincz'cz'' init_qubit init_qubitsgate_Xgate_Ygate_Zgate_Hgate_S gate_Unitary controlled_X controlled_Z gate_Unitary2 measure_qubitmeasure_qubits show_tableauevalsimswap controlled_Z'bellmeasure_bell00 controlled_ifteleport test_teleport random_bool $fShowTableau$fEq->$fEq->0template_symb_colon_%template_symb_obracket_symb_cbracket_ template_init template_lasttemplate_symb_plus_symb_plus_ template_zip3template_foldltemplate_reversetemplate_zipWithtemplate_fold_right_ziptemplate_symb_dollar_template_error template_sndErrMsgQerrorMsgembedQextractQ$fFunctorErrMsgQ$fApplicativeErrMsgQ$fMonadErrMsgQLiftQ LiftQState LiftStateboundVarprefix monadNameemptyLiftStategetStatesetState embedErrMsgQ addToBoundVarremoveFromBoundVar withBoundVar withBoundVars isBoundVar setPrefix getPrefix setMonadName getMonadNamemkNamenewNamesanitizeStringtemplateStringlookForTemplatemakeTemplateName prettyPrint clauseGetPatsequalNEListEltsclausesLengthPats$fFunctorLiftQ$fApplicativeLiftQ $fMonadLiftQBindSExpVarEConELitEAppELamETupECondELetECaseEListEReturnEMAppEValDMatchPatLitPVarPTupPWildPListPConPLitCharLIntegerL RationalLBodydoE getVarNames substMatchsubstDecsubstExp mapSubstExp litTHtoExpAST litTHtoPatASTnormalizePatInExp whereToLet clauseToMatchclausesToLambda expTHtoAST matchTHtoAST bodyTHtoAST patTHtoASTfirstLevelDecTHtoAST decTHtoAST typReturnEtypMAppE litASTtoTH patASTtoTH matchASTtoTH decASTtoTH expASTtoTH liftIntegerL liftRationalL liftLitAST liftPatAST liftMatchAST liftDecASTliftFirstLevelDecAST liftExpASTmakeDecTemplateprettyPrintASTprettyPrintLiftExpTHprettyPrintLiftExpAST decToMonad expToMonad $fShowLit $fShowPat $fShowExp $fShowDec $fShowMatchTupletupleuntuple TupleOrUnary weak_tuple weak_untuple$fTupleOrUnary(,,,,,,,,,)(,)$fTupleOrUnary(,,,,,,,,)(,)$fTupleOrUnary(,,,,,,,)(,)$fTupleOrUnary(,,,,,,)(,)$fTupleOrUnary(,,,,,)(,)$fTupleOrUnary(,,,,)(,)$fTupleOrUnary(,,,)(,)$fTupleOrUnary(,,)(,)$fTupleOrUnary(,)(,)$fTupleOrUnarya(,)$fTupleOrUnary()()$fTuple(,,,,,,,,,)(,)$fTuple(,,,,,,,,)(,)$fTuple(,,,,,,,)(,)$fTuple(,,,,,,)(,)$fTuple(,,,,,)(,)$fTuple(,,,,)(,)$fTuple(,,,)(,)$fTuple(,,)(,) $fTuple(,)(,) $fTuple()()ZerozeroIntervalinterval sample_all sample_step sample_random sample_all0 sample_step0sample_random0 $fRandom[]$fRandom(,,,,,,)$fRandom(,,,,,)$fRandom(,,,,) $fRandom(,,,) $fRandom(,,) $fRandom(,) $fRandom() $fInterval[]$fInterval(,,,,,,)$fInterval(,,,,,)$fInterval(,,,,)$fInterval(,,,)$fInterval(,,) $fInterval(,) $fInterval()$fIntervalBool$fIntervalDouble$fIntervalInteger $fIntervalInt$fZero[]$fZero(,,,,,,) $fZero(,,,,,) $fZero(,,,,) $fZero(,,,) $fZero(,,) $fZero(,)$fZero() $fZeroBool $fZeroDouble $fZeroInteger $fZeroIntghc-prim GHC.TypesBoolcontainers-0.6.0.1Data.IntMap.InternalIntMapData.IntSet.InternalIntSetinsertData.Map.InternalMapintmap_ziprightbase GHC.MaybeNothingxintmap_touchedxintmap_reservexintmap_unreserveData.TraversablesequenceGHC.ListzipzipWithGHC.Realceiling integer-gmpGHC.Integer.TypeIntegerTrueGHC.BaseidDouble OSHandlerossignal unix-2.7.2.2System.Posix.Signals oshandlerinstallHandler_posix RandomGeninitlastzip3 Data.Foldablefoldlreverse$GHC.ErrerrorString Data.Tuplesndreturn>>= list_stepsafe_zip