<%      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred Safe-Inferred      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopNone 5Decimal number. As indicated in the General Decimal  Arithmetic specification, a  might be a finite number = (perhaps the most common type) or it might be infinite or a  not-a-number. decClass% will tell you a little more about a  particular . The Ctx monad >The General Decimal Arithmetic specification states that most  computations occur within a context, which affects the manner ; in which computations are done (for instance, the context ? determines the rounding algorithm). The context also carries H the flags that computations can set (for instance, a computation might A set a flag to indicate that the result is rounded or inexact or > was a division by zero.) The Ctx monad carries this context. q*Creates a new Quad. Uninitialized, so don't export this  function.  Converts a & to a string. May use non-scientific  notation, but only if that's unambiguous; otherwise, uses  scientific notation. +In the decNumber C library, this is called toString ; the name - was changed here because this function doesn't return a Haskell  r. <Compares using an IEEE 754 total ordering, which takes into ? account the exponent. IEEE 754 says that this function might B return different results depending upon whether the operands are  canonical;  are always canonical so you don't need to worry  about that here.  True only if x& is less than zero and is not an NaN.  True only if x is a zero.  True only if x) is greater than zero and is not an NaN. sThe Show instance uses . t Like the u1 instance, this uses an IEEE 754 total ordering. v;The Eq instance depends on an IEEE 754 total ordering. In % particular, note that, for example, 7.5 is not equal to 7.50.  See  2http://speleotrove.com/decimal/decifaq4.html#order wxyz{|}~qstvwxyz{|}~qwxyz{|}~qstv Trustworthyy =An adjusted exponent is the value of an exponent of a number @ when that number is expressed as though in scientific notation > with one digit before any decimal point. This is the finite 0 exponent + (number of significant digits - 1). (A list of digits, less than or equal to  8 long. Accompanies an NaN, potentially with diagnostic ? information (I do not know if decNumber actually makes use of  this.) (A list of digits, less than or equal to  long. % Corresponds only to finite numbers. A single decimal digit. >A pure Haskell type which holds information identical to that  in a . "=The signed integer which indicates the power of ten by which  the coefficient is multiplied. (,The number is negative or the negative zero )"The number is positive or is zero *Different categories of . +A container for multiple , indicating which are set and  which are not. An instance of  so you can throw it if / you want (no functions in this module throw.) ,;A single error or warning condition that may be set in the  . . Round toward positive infinity. /Round away from zero. 00.5 rounds up 10.5 rounds to nearest even 20.5 rounds down 3Round toward zero - truncate 4 Round toward negative infinity. 5Round for reround 60/0; is undefined. It sets this flag and returns a quiet NaN. 70A non-zero dividend is divided by zero. Unlike 0/0 , it has a % defined result (a signed Infinity). 8Sometimes raised by _ and |. 9>Raised on a variety of invalid operations, such as an attempt  to use Z on an operand that is an NaN. :>One or more non-zero coefficient digits were discarded during  rounding. ;(A result is both subnormal and inexact. <9The exponent of a result is too large to be represented. ="A source string (for instance, in b ) contained  errors. AIs this , set? BA + with no , set. C?The current status flags, which indicate results from previous  computations. D-Set the current status to whatever you wish. FThe current rounding method G#Change the current rounding method HBy default, rounding is set to 1. No status flags are set B initially. Returns the final status flags along with the result  of the computation. ILike H& but does not return the final flags. JSignaling NaN K Quiet NaN LNegative infinity MNegative normal number NNegative subnormal number OThe negative zero PThe positive zero QA positive subnormal number RA positive normal number SPositive infinity T?Absolute value. NaNs are handled normally (the sign of an NaN # is not affected, and an sNaN sets 9. V+Digit-wise logical and. Operands must be:  zero or positive  integers  comprise only zeroes and/or ones If not, 9 is set. W$More information about a particular . X Compares two # numerically. The result might be -1, 0,  1, or NaN, where -1 means x is less than y, 0 indicates  numerical equality, 1$ means y is greater than x. NaN is $ returned only if x or y is an NaN. 'Thus, this function does not return an  because the  result might be an NaN. Y Wrapper for X that returns an  rather than a   . Returns Just LT rather than -1, Just EQ rather than  0, and Just GT rather than 1, and Nothing rather than NaN. 1 This is a pure function; it does not affect the . ZSame as X-, but a quietNaN is treated like a signaling  NaN (sets 9). [Same as ( but compares the absolute value of the  two arguments. \ copySign x y returns z, which is a copy of x but has the  sign of y+. This function never raises any signals. ]?Number of significant digits. If zero or infinite, returns 1. 2 If NaN, returns number of digits in the payload. _divideInteger x y( returns the integer part of the result B (rounded toward zero), with an exponent of 0. If the the result / would not fit because it has too many digits,  8 is set. `Fused multiply add;  fma x y z calculates  x * y + z. The ? multiply is carried out first and is exact, so the result has  only one final rounding. b@Reads a ByteString, which can be in scientific, engineering, or  "regular"3 decimal notation. Also reads NaN, Infinity, etc. % Will return a signaling NaN and set 9 if the  string given is invalid. 5In the decNumber C library, this function was called   fromString,; the name was changed here because it doesn' t take a  regular Haskell r. d4Digit-wise logical inversion. The operand must be:  zero or positive  integers  comprise only zeroes and/or ones If not, 9 is set. eTrue if x is neither infinite nor a NaN. fTrue for infinities. gTrue if x is finite and has exponent of 0; False otherwise. " This tests the exponent, not the adjusted exponent. This can % lead to results you may not expect: 6isInteger . evalCtx . fromByteString . pack $ "3.00e2"True3isInteger . evalCtx . fromByteString . pack $ "3e2"False6isInteger . evalCtx . fromByteString . pack $ "3.00e0"Falseh True only if x. is zero or positive, an integer (finite with 7 exponent of 0), and the coefficient is only zeroes and/ or ones. iTrue for NaNs. j True only if x) is finite, non-zero, and not subnormal. k True only if x is a signaling NaN. l True only if x- has a sign of 1. Note that zeroes and NaNs  may have sign of 1. m True only if x/ is subnormal - that is, finite, non-zero, and ' with a magnitude less than 10 ^ emin. nlogB x7 Returns the adjusted exponent of x, according to IEEE  754 rules. If x% is infinite, returns +Infinity. If x is $ zero, the result is -Infinity, and 7 is set. If  x* is less than zero, the absolute value of x is used. If x A is one, the result is 0. NaNs are propagated as for arithmetic  operations. omax x y7 returns the larger argument; if either (but not both)  x or y7 is a quiet NaN then the other argument is the result; < otherwise, NaNs, are handled as for arithmetic operations. pLike o4 but the absolute values of the arguments are used. qmin x y8 returns the smaller argument; if either (but not both)  x or y7 is a quiet NaN then the other argument is the result; < otherwise, NaNs, are handled as for arithmetic operations. rLike q4 but the absolute values of the arguments are used. s)Negation. Result has the same effect as 0 - x when the - exponent of the zero is the same as that of x, if x is  finite. u%Decrements toward negative infinity. v%Increments toward positive infinity. wnextToward x y returns the next  in the direction of  y. x4Digit wise logical inclusive Or. Operands must be:  zero or positive  integers  comprise only zeroes and/or ones If not, 9 is set. ySame effect as 0 + x' where the exponent of the zero is the  same as that of x if x& is finite). NaNs are handled as for  arithmetic operations. z quantize x y returns z which is x set to have the same  quantum as y2; that is, numerically the same value but rounded 5 or padded if necessary to have the same exponent as y . Useful # for rounding monetary quantities. {:Reduces coefficient to its shortest possible form without ; changing the value of the result by removing all possible  trailing zeroes. |>Remainder from integer division. If the intermediate integer  does not fit within a Quad, 8 is raised. }Like |- but the nearest integer is used for for the 0 intermediate result instead of the result from _. ~ rotate x y) rotates the digits of x to the left (if y is  positive) or right (if y$ is negative) without adjusting the  exponent or sign of x. y is the number of positions to ! rotate and must be in the range negate  to   coefficentLen. 7NaNs are propagated as usual. No status is set unless y is " invalid or an operand is an NaN. >True only if both operands have the same exponent or are both - NaNs (quiet or signaling) or both infinite.  scaleB x y calculates  x * 10 ^ y. y must be an integer ; (finite with exponent of 0) in the range of plus or minus 2 *   + ), typically resulting from  n9. Underflow and overflow might occur; NaNs propagate as  usual.  shift x y/ shifts digits the digits of x to the left (if y  is positive) or right (if y$ is negative) without adjusting the  exponent or sign of x*. Any digits shifted in from the left or  right will be 0. y7 is a count of positions to shift; it must be a finite  integer in the range negate  to   . NaNs propagate as usual. If x is infinite ? the result is an infinity of the same sign. No status is set / unless y is invalid or the operand is an NaN. *Returns a string in engineering notation. +In the decNumber C library, this is called  toEngString; the = name is changed here because the function does not return a  regular Haskell r. :Uses the rounding method given rather than the one in the  ;. If the operand is infinite, an NaN, or if the result of $ rounding is outside the range of a , then  9 is set. : is not set even if rounding  occurred. Like . but if rounding removes non-zero digits then  : is set. 9Rounds to an integral using the rounding mode set in the . = If the operand is infinite, an infinity of the same sign is @ returned. If the operand is an NaN, the result is the same as @ for other arithmetic operations. If rounding removes non-zero  digits then : is set. toIntegralValue r x returns an integral value of x using  the rounding mode r& rather than the one specified in the . ? If the operand is an NaN, the result is the same as for other  arithmetic operations. : is not set even if rounding  occurred.  toUInt32 r x returns the value of x, rounded to an integer & if necessary using the rounding mode r rather than the one  given in the . If x& is infinite, or outside of the range  of a , then 9 is set. : is " not set even if rounding occurs. ;The negative zero converts to 0 and is valid, but negative  numbers are not valid. Same as . but if rounding removes non-zero digits then  : is set. 3Identifies the version of the decNumber C library. 4Digit-wise logical exclusive or. Operands must be:  zero or positive  integers  comprise only zeroes and/or ones If not, 9 is set. 8A Quad whose coefficient, exponent, and sign are all 0. A Quad with coefficient , exponent 0, and sign ). +The minimum and maximum possible exponent. >The smallest possible adjusted exponent that is still normal. 5 Adjusted exponents smaller than this are subnormal. Like /, but returns the size of the regular exponent $ rather than the adjusted exponent. 9Ensures that the exponent is within the range allowed by  . An Exponent whose value is 0.  Decodes a . to a pure Haskell type which holds identical  information. Encodes a new . 3Converts a Decoded to scientific notation. Unlike  0 this will always use scientific notation. For ; NaNs and infinities, the notation is identical to that of B decNumber (see Decimal Arithmetic Specification page 19). This  means that a quiet NaN is NaN while a signaling NaN is sNaN,  and infinity is Infinity. BLike decQuadToString, the payload of an NaN is not shown if it is  zero. =Converts Decoded to ordinary decimal notation. For NaNs and 2 infinities, the notation is identical to that of .  Unlike 1, though the result can always be converted back  to a  using b, the number of significant + digits might change. For example, though 1.2E3 has two  significant digits, using ordinary on this value and then  reading it back in with fromByteString will give you 1200E0, $ which has four significant digits. :Converts a Decoded to a Rational. Returns Nothing if the  Decoded is not finite.  Creates a  '. Checks to ensure it is not null and  that it is not longer than  and that it does not + have leading zeroes (if it is 0, a single  is allowed). Coefficient of  Coefficient of   Creates a  (. Checks to ensure it is not null, not  longer than * and that it does not have leading zeroes  (if it is 0, a single  is allowed). Payload of [D0] 7The most significant digit is at the head of the list. !The most significant digit is at 8 the head of the list. Sign of number is not relevant. +Maximum number of digits in a coefficient. 'Maximum number of digits in a payload.  True only if x. is zero or positive, an integer (finite with 7 exponent of 0), and the coefficient is only zeroes and/ or ones. = The sign must be Sign0 (that is, you cannot have a negative  zero.)  True only if x) is less than zero and is not an NaN. It's not C enough for the sign to be Sign1; the coefficient (if finite) must  be greater than zero. /True for any zero (negative or positive zero). 2The number of significant digits. Zero returns 1. @Show gives you a comma-separated list of flags that are set, or & an empty string if no flags are set.    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~9Sign. Zero if sign is zero; non-zero if sign is not zero  (that is, is negavite.)  Exponent  Coefficient   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~-./012345,6789:;<=+>?@ABCDEFGHI*JKLMNOPQRSWbacUt`^_|}z{XYZ[opqrefghijklmysT\uvwVxd~n]  "## ')($&%!     ! "#$&%')(*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe  Decimals with a total ordering.  Deka wraps a . Only finite  may become a ; * no infinities or NaN values are allowed.  is a member of  and , making it easy to use for > elementary arithmetic. Any time you perform arithmetic, the @ results are always exact. The arithmetic functions will throw 4 exceptions rather than give you an inexact result.  is not a member  because it is generally A impossible to perform division without getting inexact results,  and  never holds inexact results. @Thrown by arithmetic functions in the Num class, as this is the  only way to indicate errors. <A computation set flags. This will happen if, for example, 6 you calculate a result that is out of range, such as maxBound + maxBound :: Deka7Could not convert an integer to a Deka; it is too big. )Convert any integral to a Deka. Returns  if the 4 integer is too big to fit into a Deka (34 digits). :Convert a string to a Deka. You can use ordinary numeric  strings, such as 3.25 , or exponential notation, like 325E-2. ) More information on your choices is at:  4http://speleotrove.com/decimal/daconvs.html#reftonum AYou cannot use strings that represent an NaN or an infinity. If @ you do that, or use an otherwise invalid string, this function  returns . 9Change a Quad to a Deka. Only succeeds for finite Quad. "Ord compares by a total ordering. !Eq compares by a total ordering.  Many of the  functions will throw  if their @ arguments are out of range or if they produce results that are 1 out of range or inexact. For functions that don't throw, you can  use  rather than , or you can use  Data.Deka.Quad instead of . &Ord compares by value. For instance, compare 3.5 3.500 ==  EQ. %Eq compares by value. For instance,  3.5 == 3.500.   Safe-Inferred      !!"#$%&'()%*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|} ~ ty(/012ttttt deka-0.4.0.4Data.Deka.Quad Data.DekaData.Deka.Docs.ExamplesData.Deka.DocsData.Deka.DecnumberData.Deka.Internal C'uint32_t C'int32_tQuadCtx toByteString compareTotal isNegativeisZero isPositive AdjustedExp unAdjustedExpPayload unPayload Coefficient unCoefficientDigitD9D8D7D6D5D4D3D2D1D0DecodeddSigndValueValueNaNInfiniteFiniteExponent unExponent SignalingQuietSignSign1Sign0DecClassFlagsFlagRound roundCeilingroundUp roundHalfUp roundHalfEven roundHalfDown roundDown roundFloor round05UpdivisionUndefineddivisionByZerodivisionImpossibleinvalidOperationinexact underflowoverflowconversionSyntaxunFlagssetFlag clearFlag checkFlag emptyFlags getStatus setStatus mapStatusgetRoundsetRoundrunCtxevalCtxsNanqNannegInf negNormal negSubnormalnegZeroposZero posSubnormal posNormalposInfabsaddanddecClasscompare compareOrd compareSignalcompareTotalMagcopySigndigitsdivide divideIntegerfma fromInt32fromByteString fromUInt32invertisFinite isInfinite isInteger isLogicalisNaNisNormal isSignalingisSigned isSubnormallogBmaxmaxMagminminMagminusmultiply nextMinusnextPlus nextTowardorplusquantizereduce remainder remainderNearrotate sameQuantumscaleBshiftsubtracttoEngByteStringtoInt32 toInt32ExacttoIntegralExacttoIntegralValuetoUInt32 toUInt32Exactversionxorzeroone minMaxExp minNormalAdj minNormalExpexponent zeroExponenttoBCDfromBCD scientificordinarydecodedToRational digitToInt intToDigit digitToChar coefficientzeroCoefficientoneCoefficientpayload zeroPayloaddigitsToIntegerintegralToDigitscoefficientLen payloadLen dIsFinite dIsInfinite dIsInteger dIsLogicaldIsNaN dIsNegative dIsNormal dIsPositive dIsSignaling dIsSigned dIsSubnormaldIsZerodDigits adjustedExpadjustedToExponentdIsSNaNdIsQNaN dIsNegInf dIsNegNormaldIsNegSubnormal dIsNegZero dIsPosZerodIsPosSubnormal dIsPosNormal dIsPosInfDekaTunDekaTDekaunDeka DekaErrorFlagged IntegerTooBigintegralToDeka strToDeka quadToDekaexamples C'decQuadc'decQuad'bytes C'decClass C'decContextc'decContext'digitsc'decContext'emaxc'decContext'eminc'decContext'roundc'decContext'trapsc'decContext'statusc'decContext'clamp C'uint64_t C'uint16_t C'uint8_t C'roundingunsafe'c'decQuadVersionunsafe'c'decQuadSameQuantumunsafe'c'decQuadRadixunsafe'c'decQuadIsZerounsafe'c'decQuadIsSubnormalunsafe'c'decQuadIsSignedunsafe'c'decQuadIsSignalingunsafe'c'decQuadIsPositiveunsafe'c'decQuadIsNormalunsafe'c'decQuadIsNegativeunsafe'c'decQuadIsNaNunsafe'c'decQuadIsInfiniteunsafe'c'decQuadIsLogicalunsafe'c'decQuadIsIntegerunsafe'c'decQuadIsFiniteunsafe'c'decQuadIsCanonicalunsafe'c'decQuadDigitsunsafe'c'decQuadClassStringunsafe'c'decQuadClassunsafe'c'decQuadCopyunsafe'c'decQuadCopySignunsafe'c'decQuadCopyNegateunsafe'c'decQuadCopyAbsunsafe'c'decQuadCanonicalunsafe'c'decQuadCompareTotalMagunsafe'c'decQuadCompareTotalunsafe'c'decQuadCompareSignalunsafe'c'decQuadCompareunsafe'c'decQuadXorunsafe'c'decQuadToIntegralExactunsafe'c'decQuadToIntegralValueunsafe'c'decQuadToBCDunsafe'c'decQuadSubtractunsafe'c'decQuadShiftunsafe'c'decQuadScaleBunsafe'c'decQuadRotateunsafe'c'decQuadRemainderNearunsafe'c'decQuadRemainderunsafe'c'decQuadReduceunsafe'c'decQuadQuantizeunsafe'c'decQuadPlusunsafe'c'decQuadOrunsafe'c'decQuadNextTowardunsafe'c'decQuadNextPlusunsafe'c'decQuadNextMinusunsafe'c'decQuadMultiplyunsafe'c'decQuadMinusunsafe'c'decQuadMinMagunsafe'c'decQuadMinunsafe'c'decQuadMaxMagunsafe'c'decQuadMaxunsafe'c'decQuadLogBunsafe'c'decQuadInvertunsafe'c'decQuadFromBCDunsafe'c'decQuadFMAunsafe'c'decQuadDivideIntegerunsafe'c'decQuadDivideunsafe'c'decQuadAndunsafe'c'decQuadAddunsafe'c'decQuadAbsunsafe'c'decQuadZerounsafe'c'decQuadToUInt32Exactunsafe'c'decQuadToUInt32unsafe'c'decQuadToStringunsafe'c'decQuadToEngStringunsafe'c'decQuadShowunsafe'c'decQuadSetExponentunsafe'c'decQuadSetCoefficientunsafe'c'decQuadGetExponentunsafe'c'decQuadGetCoefficientunsafe'c'decQuadFromStringunsafe'c'decQuadFromUInt32!unsafe'c'decQuadFromPackedCheckedunsafe'c'decQuadFromPackedunsafe'c'decQuadFromInt32unsafe'c'decQuadToInt32Exactunsafe'c'decQuadToInt32unsafe'c'decContextDefaultc'NULLc'DEC_ROUND_CEILINGc'DEC_ROUND_UPc'DEC_ROUND_HALF_UPc'DEC_ROUND_HALF_EVENc'DEC_ROUND_HALF_DOWNc'DEC_ROUND_DOWNc'DEC_ROUND_FLOORc'DEC_ROUND_05UPc'DEC_ROUND_MAXp'decContext'statusp'decContext'roundc'DEC_INIT_DECQUADc'DEC_CLASS_SNANc'DEC_CLASS_QNANc'DEC_CLASS_NEG_INFc'DEC_CLASS_NEG_NORMALc'DEC_CLASS_NEG_SUBNORMALc'DEC_CLASS_NEG_ZEROc'DEC_CLASS_POS_ZEROc'DEC_CLASS_POS_SUBNORMALc'DEC_CLASS_POS_NORMALc'DEC_CLASS_POS_INFc'DEC_Conversion_syntaxc'DEC_Division_by_zeroc'DEC_Division_impossiblec'DEC_Division_undefinedc'DEC_Insufficient_storage c'DEC_Inexactc'DEC_Invalid_contextc'DEC_Invalid_operationc'DEC_Overflow c'DEC_Clamped c'DEC_Roundedc'DEC_Subnormalc'DEC_Underflowc'DEC_IEEE_754_Division_by_zeroc'DEC_IEEE_754_Inexact c'DEC_IEEE_754_Invalid_operationc'DEC_IEEE_754_Overflowc'DEC_IEEE_754_Underflow c'DEC_Errors c'DEC_NaNsc'DEC_Condition_Lengthc'DEC_INIT_BASEc'DEC_INIT_DECIMAL32c'DEC_INIT_DECIMAL64c'DEC_INIT_DECIMAL128c'DECQUAD_Bytesc'DECQUAD_Pmaxc'DECQUAD_Eminc'DECQUAD_Emaxc'DECQUAD_EmaxDc'DECQUAD_Biasc'DECQUAD_Stringc'DECQUAD_EconLc'DECQUAD_Decletsc'DECQUAD_Ehighp'decQuad'bytesc'DECFLOAT_Signc'DECFLOAT_NaNc'DECFLOAT_qNaNc'DECFLOAT_sNaNc'DECFLOAT_Infc'DECFLOAT_MinSp c'DECPPLUSALTc'DECPMINUSALT c'DECPPLUS c'DECPMINUSc'DECPPLUSALT2c'DECPUNSIGNED$fStorableC'decQuad$fStorableC'decContextnewQuadbaseGHC.BaseString $fShowQuad $fOrdQuadghc-prim GHC.ClassesEq$fEqQuadMkStringunQuadunCtx BinaryCtxFreeBooleanboolean binaryCtxFreemkString $fMonadCtx$fApplicativeCtx $fFunctorCtx GHC.Exception Exception GHC.TypesOrdering $fShowFlags GetRoundedTernaryUnaryGetBinaryUnaryunRoundunarybinaryunaryGetternary getRoundedtoDecNumberBCD getDecoded sciFinitesciNaN onyFinite$fEnumAdjustedExp$fBoundedAdjustedExp $fEnumPayload$fBoundedPayload$fEnumCoefficient$fBoundedCoefficient$fEnumExponent$fBoundedExponent$fShowDecClass$fExceptionFlags $fShowFlag $fShowRoundGHC.NumNumGHC.RealReal Fractional Data.MaybeNothing $fOrdDekaT $fEqDekaT $fNumDeka fromInteger $fOrdDeka$fEqDekaeval $fBoundedDeka $fRealDeka$fExceptionDekaError