h$g Z      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                             Safe-Inferredboolean methods(c) Grant Weyburne, 2022BSD-3 Safe-Inferred. primusmonadic version of ! predicate appears first unlike primus create a  using a predicate and a function for the success case predicate appears first unlike primus create a  using a predicate and functions for the failure and success case predicates appear first unlike primus create a  using two predicates and functions for the This case and That case False + * == This (a -> e) True + False == That (a -> b) True + True == These (a -> e) (a -> b) -- "a" effectively appears twicepredicates appear first unlike primus similar to  but allows you to override the  casepredicates appear first unlike primus6 but makes the "a" parameter available to the callbackprimus6 but makes the "a" parameter available to the callback error methods(c) Grant Weyburne, 2022BSD-3 Safe-Inferred.e primusindicates a programmer errorprimusindicates a user error primusindicates a compiler error primusunsafe force an error if  primusunsafe force an error if  primusunsafe force an error if  primusunsafe force an error if primusprepend an error messageprimus.unsafe conversion from list to a nonempty listprimus.unsafe conversion from list to a nonempty listprimus.unsafe conversion from list to a nonempty listprimus.unsafe conversion from list to a nonempty list    miscellaneous functions(c) Grant Weyburne, 2022BSD-3 Safe-Inferred.iprimusmore flexible version of 3 that allows differing types for the same containerprimusmore flexible version of  that allows differing types for the same container but using two parametersprimusmore flexible version of 3 that allows differing types for the same containerprimus9compose a two arg function followed by a one arg function8methods with termination(c) Grant Weyburne, 2022BSD-3 Safe-Inferred>?primus for use with  using a fixed "e"primusflexible "e" to use with eg $: Bool is also validprimusconverts to a  for failure typesprimus similar to  but terminate using primuslike  but terminate using  >>> unfoldrT (splitAt 2) [1..8] [[1,2],[3,4],[5,6],[7,8]] vs >>> unfoldr (s -> if null s then Nothing else Just (splitAt 2 s)) [1..8] [[1,2],[3,4],[5,6],[7,8]] primusrun a functions against each side of a tuple and stitch them together for use with  where "s" is a tuple and you want to stop as soon as the either terminates primus4apply a function to a list and convert to a list of !primuslike   with state"primuslike #* ignoring the second element of the result#primuslike   but use $ on the results (swapped version of )$primuslike   but use  on the results%primus similar to  using % for failure (support Bool and These)&primuslike % but doesn't continue in the  case'primuslike % with state(primuslike ) with state)primuslike %, but ignore the second element of the result !"#$%&'() !#$"%&')(fold and unfolds(c) Grant Weyburne, 2022BSD-3 Safe-Inferred .567< (Dprimusdifference between two foldables but quick exit if lhs is larger than rhsEprimuserrorFprimus.leftovers from rhs: ie lhs is smaller than rhsGprimus same sizeHprimuslhs is larger than rhsIprimusleft/right fold over a list giving the caller access state "z" (for finite containers only)Jprimusleft/right fold over a list giving the caller access state "z" (for finite containers only)Kprimusleft/right fold that gives access to past input (reverse order) and future inputLprimusleft/right fold that gives access to past input (reverse order) and future inputMprimussame as I or J but skips stateNprimussame as I or J but skips stateOprimuslike # but reverses the order of the listPprimusmonadic unfoldrQprimusmonadic unfoldlRprimustraverse a container using Sprimus:fill a traversable with a list and fail if not enough dataTprimusfill a traversable with a list and fail if there are leftovers: see SUprimus+run a function against the contents of the  container as a nonempty listVprimus+run a function against the contents of the  container as a listWprimus8pad fill "as" to the right or left with values from "zs"Xprimus8pad fill "as" to the right or left with values from "zs"Yprimushave to call a second time if the left container is bigger than the right oneZprimuszip a foldable into a traversable container and return any leftovers[primuspredicate for G\primuscompare lengths of foldables]primus>h<primus0represents the status of a split a nonempty listprimuspossible results for determining if a nonempty list is in ascending orderprimus?generated enumerable sequence is shorter than the original listprimusfirst mismatchprimusboth sequences matchprimusrepresents an optional , ie Maybe (Either (NonEmpty a) (NonEmpty b))primus"extra values on the left hand sideprimus both values have the same lengthprimus#extra values on the right hand sideprimus=zips two nonempty lists together and puts any leftovers into primus predicateprimus4zips two lists together and puts any leftovers into primus'conversion from list to a nonempty listprimus=split a nonempty list into a nonempty list of nonempty chunksprimussplit a nonempty list into a nonempty list of nonempty chunks given a chunk size and how many to skip each iteration can decide the size of the chunks and how many elements to skipprimuscreates a nonempty container of length "sz" with chunks of a given size: @see ! must fill the container exactlyprimusfills a container "tz" with chunks of size "len" must fill the container exactlyprimusunfoldr for a nonempty listwill not terminate if the user keeps returning a larger [s] than receivedprimus for a nonempty listprimus for a nonempty listprimus for a nonempty listprimus for a nonempty listprimus for a nonempty listprimus for a nonempty listprimus(predicate for an ascending nonempty listprimuspredicate for primusshows the first failure or if the length of the enum is too shortprimussnoc for a nonempty listprimusunsnoc for a nonempty listprimusuncons for a nonempty listprimuscons iso from primussnoc iso from primus/ but applies the predicate to adjacent elementsprimus;partition duplicates elements together with their positiionprimus"foldMapM" for nonempty containers: uses Semigroup instead of Monoidprimus" for nonempty resultsprimus for a nonempty listprimus for a nonempty list but doesnt guarantee the number of elementsprimuscomparator for primusCrprimusOne holds a single value. To use wprint we need a SOP Generics instanceprimusunwrap  3representable methods for use with fixed containers(c) Grant Weyburne, 2022BSD-3 Safe-Inferred.F primusbuilds a representable from the left using past and future inputsprimussame as  but associates to the rightprimus.fill a representable container with a foldableprimusload a fixed container with "a"s using the relative position "i"primus$ with rep indexprimus% with rep indexprimuslike & passes in the $ index and removes the first elementprimuslike ' passes in the # index and removes the last elementprimus5left/right unfold from the right into a Representableprimus5left/right unfold from the right into a Representable  (common modules(c) Grant Weyburne, 2022BSD-3NoneG  !"#$%&'()DHGEFIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkuvwxyz{|}~ commonly used type families(c) Grant Weyburne, 2022BSD-3None./O.primusget the head of a nonempty listprimus,peel off the bottom-most index in the matrixprimusget the init of a nonempty listprimusget the init of a listprimusappend two type level listsprimus;conversions to and from an inductive tuple and a flat tupleprimus/convert an inductive tuple to a flat tuple typeprimus/convert a flat tuple type to an inductive tupleprimus+cons a type to the first element in a tupleprimus!unsnoc a type level nonempty listprimus!uncons a type level nonempty listprimuscreate a constraint from a list of types and list of constraints that take a typeprimuscreate a constraint from a list of types and a constraint that take a typeprimuscreate a constraint from a type and list of constraints taking a typeprimus+append two nonempty lists at the type levelprimussnoc a type list to a typeprimussnoc a type list to a typeprimus#snoc a nonempty list type to a typeprimus0cons a type to a nonempty list at the type levelprimus#ensure that two types are not equalprimus,get the length of a type level nonempty listprimus at the typelevelprimus"map snd" at the typelevelprimus"map fst" at the typelevelprimus"snd" at the typelevelprimus"fst" at the typelevelprimustype level boolean implicationprimus(fail with error message if "b" is 'Falseprimusextract an int from a 5like # but keeps history of all successes(c) Grant Weyburne, 2022BSD-3None'(./2567<>?Y6primuslike  but keeps track of history of all successes if there is a failure it wraps the previous successes and stops adding data to  "e" the error type "as" is the typelevel list in reverse order that tracks all previous "a"s "a" is the latest success typeprimuswraps an existing errorprimus-wraps previous nested successes with an errorprimusinitial success valueprimussubsequent successprimusconstructor for , with more convenient type application orderprimusconstructor for , with more convenient type application orderprimusconstructor for , with more convenient type application orderprimusconstructor for , with more convenient type application orderprimussmart constructor for primussmart constructor for primussmart constructor for primussmart constructor for primus initialise  with an  by wrapping a unitprimus initialise  with an  by wrapping a unitprimusZprimuszippable version of primusunwrap primus#iso for the zipnonempty constructor)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                               !                                                                                                                             $&'#%primus-0.1.0.0-JZPYdato8RmBxJD1q2Trmv Primus.Bool Primus.Error Primus.ExtraPrimus.AsMaybe Primus.Fold Primus.Enum Primus.Lens Primus.ListPrimus.NonEmpty Primus.Num1 Primus.One Primus.RepPrimus.TypeLevel Primus.LRHistPrimus.ZipNonEmpty Paths_primus Control.Monadunlesswhen Data.FunctiononLRHistData.List.NonEmptyiterate Data.Listunfoldr partitionspaninitstailsreversesortBysplits1unfoldMbreakzipWithzipWithMscanrscanlPrimusboolM boolMaybe boolEither boolThese boolThese'unlessMBwhenMB programmError normalError compileError forceRight forceRightPfrfrplmsgnenep fromList1 fromList1Pon1on2 comparing1.@ApTheseFapTheseFApTheseapTheseAsMaybetoMaybe iterateT1unfoldrTpairsTtoTheseT toTheseTSfilterTpartitionEithersTpartitionTheseTspanTspanTAltspanTS takeWhileTS takeWhileT$fAsMaybeIdentityz$fAsMaybe(,,)b $fAsMaybe(,)b $fAsMaybeArgz $fAsMaybe[]b1$fAsMaybeMaybeb1$fAsMaybeEitherb1$fAsMaybeTheseb1$fApTheseeaIdentityz$fApTheseea(,,)b$fApTheseea(,)b$fApTheseeaArgz$fApTheseea[]b1$fApTheseeaBoolb$fApTheseeaMaybeb1$fApThesee1aEitherb1$fApThesee1aTheseb1$fApTheseFeaIdentityz$fApTheseFea(,,)b$fApTheseFea(,)b$fApTheseFeaArgz$fApTheseFea[]b1$fApTheseFeaBoolb$fApTheseFeaMaybeb1$fApTheseFe1aEitherb1$fApTheseFe1aTheseb1CLCountCErrorCLTCEQCGThistMapLhistMapRpFoldRpFoldL histMapL' histMapR'unfoldlunfoldrMunfoldlM traverseLRfillTraversablefillTraversableExactwrap1wrapLpadRpadL zipExtrasTzipExtrasRight clOrderingcompareLengths compareLengthcompareLengthByzipWithTchunkNchunkN' zipWithExactzipExactinitsTtailsTreverseTsortByT postscanr postscanlunzipFreverseF$fMonadStateLR$fApplicativeStateLR$fFunctorStateLR $fOrdCLCount $fShowCLCount $fEqCLCount$fFunctorCLCount$fTraversableCLCount$fFoldableCLCount universe1 universe1R enumFrom1enumTo1 enumFromThen1enumFromThenTo1 enumFromTo1 enumFrom1RpredSafesuccSafetoEnumTraversablecapacity toEnumListintegerToIntSafeintegerToEnumSafe toEnumList1fromEnumFoldablefromEnumFoldable1succTraversablepredTraversableuniverseTraversable TraversalIsoLens'Lenslensiso_Fst_SndSplitL SplitLNegSplitLLTSplitLEQSplitLGTpairsOf1pairsOf2pairsOf'chunksOfallEqual allEqualBysplitAtL splitAtLGEsetAtL updateAtLatLatNoteL lengthExactzipWithLongest zipLongestsplitspartitionEithersL'partitionEithersLpartitionTheseL'partitionTheseL spanMaybe' spanMaybe partitionMsnocLunsnocL $fOrdSplitL $fShowSplitL $fEqSplitLSplit1SplitLTSplitEQSplitGTSeq1S1ShortS1FailS1OkMLRMLRLeftMLREqualMLRRightzipWithExtras1 mlrOrdering zipWithExtras fromList1LR chunksOf1 chunksRange1 chunkNLen1 chunkNLen unfoldr1NE replicate1 replicate1M partition1span1break1sum1 isSequence1 seq1OrderingisEnumAscendingsnoc1unsnoc1uncons1 consNonEmpty snocNonEmptygroupByAdjacent1 findDupsBy foldMapM1 unfoldrM1take1splitAt1split1Ordering splitAt1' splitAt1GE splitAts1 lengthExact1iterateMaybe1' iterateMaybe1 iterateN1splits3 spanAdjacent1breakAdjacent1appendL1appendR1setAt1 updateAt1at1 replicatePlengthPunits1unitsFsumP $fOrdSplit1 $fShowSplit1 $fEqSplit1 $fShowSeq1$fEqSeq1 $fOrdSeq1 $fFunctorSeq1 $fShowMLR$fEqMLR$fOrdMLRNum1 toInteger1 fromInteger1.+.-.*negate1abs1signum1succ1pred1withOpwithOp2withOp3withOp4 $fNum1Int64 $fNum1Int32 $fNum1Int16 $fNum1Int8 $fNum1Int $fNum1Word64 $fNum1Word32 $fNum1Word16 $fNum1Word8 $fNum1Pos $fNum1NaturalOneunOne$fTraversable1One $fMonadOne $fApplyOne$fApplicativeOne $fDataOne $fGenericOne$fGeneric1TYPEOne $fShowOne$fEqOne$fOrdOne$fTraversableOne $fReadOne $fFunctorOne $fFoldableOne$fSemigroupOne $fMonoidOne $fNFDataOne $fNFData1One$fFoldable1One buildRepL buildRepRfillRep toEnumRep izipWithR izipWithRF ipostscanr ipostscanl unfoldlRep unfoldrRepHead1TLast1TInit1TInitT++ITupleC toITupleC fromITupleC FromITupleT ToITupleT FirstConsTUnsnocTUnconsTApplyConstraintsApplyConstraintApplyConstraints1App1TSnoc1LTSnocTSnoc1TCons1TNotEqTCLen1TLengthSndsFstsSndFst:=> FailUnlesspnat$fITupleC(,,,,,,,,,)$fITupleC(,,,,,,,,)$fITupleC(,,,,,,,)$fITupleC(,,,,,,)$fITupleC(,,,,,)$fITupleC(,,,,)$fITupleC(,,,) $fITupleC(,,) $fITupleC(,) $fITupleCOneLhSkipLhRhiRhrhi'rh'lh'lhskip'rhirhlhlhskip eitherToLH maybeToLH lhToEitherI lhToEitherlhToEitherTuplesvalidateLRHistlhBoollhMaybelhMaybe'lhEither lhEither'appLRappLRSappLRBtraverseLRHisttraverseLRHistB$fBitraversableLRHist$fBifoldableLRHist$fBifunctorLRHist $fReadLRHist $fReadLRHist0$fSemigroupLRHist$fMonoidLRHist$fMonoidLRHist0 $fOrgAC:a' $fOrgAC[]a' $fRHistC: $fRHistC[] $fEqLRHist $fOrdLRHist $fShowLRHist$fTraversableLRHist$fFoldableLRHist$fFunctorLRHist ZipNonEmpty unZipNonEmpty_Zip1$fIsListZipNonEmpty$fTraversable1ZipNonEmpty$fApplyZipNonEmpty$fApplicativeZipNonEmpty$fSemigroupZipNonEmpty$fMonoidZipNonEmpty$fDataZipNonEmpty$fGenericZipNonEmpty$fGeneric1TYPEZipNonEmpty$fShowZipNonEmpty$fEqZipNonEmpty$fOrdZipNonEmpty$fTraversableZipNonEmpty$fReadZipNonEmpty$fNFDataZipNonEmpty$fNFData1ZipNonEmpty$fFoldableZipNonEmpty$fFoldable1ZipNonEmpty$fFunctorZipNonEmptyversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNamebase Data.Boolbool GHC.MaybeMaybe Data.EitherEither$these-1.1.1.1-HvJGKxaeYPR1jVMtgZOtPT Data.TheseTheseLeftghc-prim GHC.ClassescomparepartitionHereTherepartitionTheseStateLR*semigroupoids-5.3.7-EmwtsntDvJyH8EoXM8N43nData.Semigroup.Foldable.Class Foldable1 Data.FoldableFoldableGHC.ListGHC.EnumEnumenumFromThenTopredsucctoEnumThisThatGHC.Baseid replicate replicateMsumNonEmptygroupBy1takesplitAt!pos-0.1.0.0-G5PmLxDyM8rBA3ANVZcZVData.PosPosGHC.NumNuminteger-wired-inGHC.Integer.TypeInteger%adjunctions-4.4-EKQHqR16z51dgCsGKYMQ2Data.Functor.RepRep_20P_19P_18P_17P_16P_15P_14P_13P_12P_11P_10P_9P_8P_7P_6P_5P_4P_3P_2P_1PposRange toPositives fromPositives_PfromNPfromNpredPsuccPmaxP productPIntproductPsafeDivPdivModP divModNextP eitherPos unsafePosminusP+!*!unP pPositivespPosIntpPospIntPosTNSC nsLengthPfromNSP fromNSTotalPlength GHC.TypesNatControl.ApplicativeZipList