h$ccW>      !"#$%&'()*+,-./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.y 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 listprimus9compose a two arg function followed by a one arg function    8methods 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 terminatesprimus4apply a function to a list and convert to a list of primuslike  with stateprimuslike  * 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<$(Aprimusdifference between two foldables but quick exit if lhs is larger than rhsBprimuserrorCprimus.leftovers from rhs: ie lhs is smaller than rhsDprimus same sizeEprimuslhs is larger than rhsFprimusleft/right fold over a list giving the caller access state "z" (for finite containers only)Gprimusleft/right fold over a list giving the caller access state "z" (for finite containers only)Hprimusleft/right fold that gives access to past input (reverse order) and future inputIprimusleft/right fold that gives access to past input (reverse order) and future inputJprimussame as F or G but skips stateKprimussame as F or G but skips stateLprimuslike # but reverses the order of the listMprimusmonadic unfoldrNprimusmonadic unfoldlOprimustraverse a container using Pprimus:fill a traversable with a list and fail if not enough dataQprimusfill a traversable with a list and fail if there are leftovers: see PRprimus+run a function against the contents of the  container as a nonempty listSprimus+run a function against the contents of the  container as a listTprimus8pad fill "as" to the right or left with values from "zs"Uprimus8pad fill "as" to the right or left with values from "zs"Vprimushave to call a second time if the left container is bigger than the right oneWprimuszip a foldable into a traversable container and return any leftoversXprimuspredicate for DYprimuscompare lengths of foldablesZprimus<<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 primusAprimusOne 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.D 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-3NoneE  !"#$%&AEDBCFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghrstuvwxyz{|}~ commonly used type families(c) Grant Weyburne, 2022BSD-3None./Kprimus,peel off the bottom-most index in the matrixprimusget 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 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 typeprimussnoc a type list to a typeprimus0cons a type to a nonempty list at the type levelprimus#ensure that two types are not equalprimus 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 5 like # but keeps history of all successes(c) Grant Weyburne, 2022BSD-3None'(./2567<>?Uprimuslike  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 unitprimusW*primuszippable version of primusunwrap primus#iso for the zipnonempty constructor&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                           !#$ %primus-0.2.0.0-5opKMxg0qrt6KidnjOCOLM Primus.Bool Primus.ErrorPrimus.AsMaybe Primus.Fold Primus.Enum Primus.Lens Primus.ListPrimus.NonEmpty Primus.Num1 Primus.One Primus.RepPrimus.TypeLevel Primus.LRHistPrimus.ZipNonEmpty Paths_primus Control.MonadunlesswhenLRHistData.List.NonEmptyiterate Data.Listunfoldr partitionspaninitstailsreversesortBysplits1unfoldMbreakzipWithzipWithMscanrscanlPrimusboolM boolMaybe boolEither boolThese boolThese'unlessMBwhenMB programmError normalError compileError forceRight forceRightPfrfrplmsgnenep fromList1 fromList1P.@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 unfoldrRepLastTInitT++ITupleC toITupleC fromITupleC FromITupleT ToITupleT FirstConsTUnsnocTApplyConstraintsApplyConstraintApplyConstraints1SnocTCons1TNotEqTCLengthTSndsFstsSndFst:=> 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.TheseTheseLeftpartitionHereTherepartitionTheseStateLR*semigroupoids-5.3.7-EmwtsntDvJyH8EoXM8N43nData.Semigroup.Foldable.Class Foldable1 Data.FoldableFoldableGHC.ListGHC.EnumEnumenumFromThenTopredsucctoEnumThisThatGHC.Baseid replicate replicateMsumNonEmptygroupBy1takesplitAt"pos-0.2.0.0-BtJ1nCMEhtcLjKXMgmwfdBData.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 pPositivespPosIntpPospIntPosTNS nsLengthPfromNSP fromNSTotalPlengthghc-prim GHC.TypesNatControl.ApplicativeZipList