{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-}

{-# HLINT ignore "Redundant if" #-}

-- | Functions operating on `BuiltinList`.
module PlutusTx.BuiltinList (
  BuiltinList,
  cons,
  uncons,
  empty,
  singleton,
  null,
  caseList',
  caseList,
  map,
  elem,
  find,
  any,
  all,
  (!!),
  (++),
  (<|),
  append,
  findIndices,
  filter,
  mapMaybe,
  length,
  and,
  or,
  notElem,
  foldr,
  foldl,
  concat,
  concatMap,
  listToMaybe,
  uniqueElement,
  revAppend,
  reverse,
  replicate,
  findIndex,
  head,
  last,
  tail,
  take,
  drop,
  dropWhile,
  elemBy,
  nub,
  nubBy,
  zipWith,
) where

import PlutusTx.Builtins qualified as B
import PlutusTx.Builtins.HasOpaque
import PlutusTx.Builtins.Internal qualified as BI
import PlutusTx.Eq
import PlutusTx.ErrorCodes
import PlutusTx.Ord
import PlutusTx.Prelude hiding (mapMaybe)

-- | Plutus Tx version of 'Data.List.:' for 'BuiltinList'.
cons :: forall a. a -> BuiltinList a -> BuiltinList a
cons :: forall a. a -> BuiltinList a -> BuiltinList a
cons = a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
BI.mkCons
{-# INLINEABLE cons #-}

-- | Infix version of 'cons'.
infixr 5 <|

(<|) :: forall a. a -> BuiltinList a -> BuiltinList a
<| :: forall a. a -> BuiltinList a -> BuiltinList a
(<|) = a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
cons
{-# INLINEABLE (<|) #-}

-- | Plutus Tx version of 'Data.List.uncons' for 'BuiltinList'.
uncons :: forall a. BuiltinList a -> Maybe (a, BuiltinList a)
uncons :: forall a. BuiltinList a -> Maybe (a, BuiltinList a)
uncons = BuiltinList a -> Maybe (a, BuiltinList a)
forall a. BuiltinList a -> Maybe (a, BuiltinList a)
B.uncons
{-# INLINEABLE uncons #-}

-- | Plutus Tx version of '[]' for 'BuiltinList'.
empty :: forall a. (MkNil a) => BuiltinList a
empty :: forall a. MkNil a => BuiltinList a
empty = BuiltinList a
forall a. MkNil a => BuiltinList a
B.mkNil
{-# INLINEABLE empty #-}

-- | Plutus Tx version of 'Data.List.null' for 'BuiltinList'.
null :: forall a. BuiltinList a -> Bool
null :: forall a. BuiltinList a -> Bool
null = BuiltinList a -> Bool
forall a. BuiltinList a -> Bool
B.null
{-# INLINEABLE null #-}

-- | Make a list with one element.
singleton :: forall a. (MkNil a) => a -> BuiltinList a
singleton :: forall a. MkNil a => a -> BuiltinList a
singleton a
x = a
x a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a
forall a. MkNil a => BuiltinList a
empty
{-# INLINEABLE singleton #-}

caseList' :: forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' :: forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' = r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
B.caseList'
{-# INLINEABLE caseList' #-}

caseList :: forall a r. (() -> r) -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList :: forall a r.
(() -> r) -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList = (() -> r) -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
forall a r.
(() -> r) -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
B.caseList
{-# INLINEABLE caseList #-}

-- | Plutus Tx version of 'Data.List.map' for 'BuiltinList'.
map :: forall a b. (MkNil b) => (a -> b) -> BuiltinList a -> BuiltinList b
map :: forall a b. MkNil b => (a -> b) -> BuiltinList a -> BuiltinList b
map a -> b
f = BuiltinList a -> BuiltinList b
go
 where
  go :: BuiltinList a -> BuiltinList b
  go :: BuiltinList a -> BuiltinList b
go = BuiltinList b
-> (a -> BuiltinList a -> BuiltinList b)
-> BuiltinList a
-> BuiltinList b
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' BuiltinList b
forall a. MkNil a => BuiltinList a
empty (\a
x BuiltinList a
xs -> a -> b
f a
x b -> BuiltinList b -> BuiltinList b
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a -> BuiltinList b
go BuiltinList a
xs)
{-# INLINEABLE map #-}

-- | Plutus Tx version of 'Data.List.mapMaybe' for 'BuiltinList'.
mapMaybe :: forall a b. (MkNil b) => (a -> Maybe b) -> BuiltinList a -> BuiltinList b
mapMaybe :: forall a b.
MkNil b =>
(a -> Maybe b) -> BuiltinList a -> BuiltinList b
mapMaybe a -> Maybe b
f = BuiltinList a -> BuiltinList b
go
 where
  go :: BuiltinList a -> BuiltinList b
  go :: BuiltinList a -> BuiltinList b
go =
    BuiltinList b
-> (a -> BuiltinList a -> BuiltinList b)
-> BuiltinList a
-> BuiltinList b
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList'
      BuiltinList b
forall a. MkNil a => BuiltinList a
empty
      ( \a
x BuiltinList a
xs -> case a -> Maybe b
f a
x of
          Maybe b
Nothing -> BuiltinList a -> BuiltinList b
go BuiltinList a
xs
          Just b
y  -> b
y b -> BuiltinList b -> BuiltinList b
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a -> BuiltinList b
go BuiltinList a
xs
      )
{-# INLINEABLE mapMaybe #-}

-- | Does the element occur in the list?
elem :: forall a. (Eq a) => a -> BuiltinList a -> Bool
elem :: forall a. Eq a => a -> BuiltinList a -> Bool
elem a
a = BuiltinList a -> Bool
go
 where
  go :: BuiltinList a -> Bool
  go :: BuiltinList a -> Bool
go = Bool -> (a -> BuiltinList a -> Bool) -> BuiltinList a -> Bool
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' Bool
False (\a
x BuiltinList a
xs -> if a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
x then Bool
True else BuiltinList a -> Bool
go BuiltinList a
xs)
{-# INLINEABLE elem #-}

-- | Returns the leftmost element matching the predicate, or `Nothing` if there's no such element.
find :: forall a. (a -> Bool) -> BuiltinList a -> Maybe a
find :: forall a. (a -> Bool) -> BuiltinList a -> Maybe a
find a -> Bool
p = BuiltinList a -> Maybe a
go
 where
  go :: BuiltinList a -> Maybe a
  go :: BuiltinList a -> Maybe a
go = Maybe a
-> (a -> BuiltinList a -> Maybe a) -> BuiltinList a -> Maybe a
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' Maybe a
forall a. Maybe a
Nothing (\a
x BuiltinList a
xs -> if a -> Bool
p a
x then a -> Maybe a
forall a. a -> Maybe a
Just a
x else BuiltinList a -> Maybe a
go BuiltinList a
xs)
{-# INLINEABLE find #-}

-- | Determines whether any element of the structure satisfies the predicate.
any :: forall a. (a -> Bool) -> BuiltinList a -> Bool
any :: forall a. (a -> Bool) -> BuiltinList a -> Bool
any a -> Bool
p = BuiltinList a -> Bool
go
 where
  go :: BuiltinList a -> Bool
  go :: BuiltinList a -> Bool
go = Bool -> (a -> BuiltinList a -> Bool) -> BuiltinList a -> Bool
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' Bool
False (\a
x BuiltinList a
xs -> if a -> Bool
p a
x then Bool
True else BuiltinList a -> Bool
go BuiltinList a
xs)
{-# INLINEABLE any #-}

-- | Determines whether all elements of the list satisfy the predicate.
all :: forall a. (a -> Bool) -> BuiltinList a -> Bool
all :: forall a. (a -> Bool) -> BuiltinList a -> Bool
all a -> Bool
p = BuiltinList a -> Bool
go
 where
  go :: BuiltinList a -> Bool
  go :: BuiltinList a -> Bool
go = Bool -> (a -> BuiltinList a -> Bool) -> BuiltinList a -> Bool
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' Bool
True (\a
x BuiltinList a
xs -> if a -> Bool
p a
x then BuiltinList a -> Bool
go BuiltinList a
xs else Bool
False)
{-# INLINEABLE all #-}

{-| Get the element at a given index.
This function throws an error if the index is negative or larger than the length
of the list.
-}
infixl 9 !!

(!!) :: forall a. BuiltinList a -> Integer -> a
!! :: forall a. BuiltinList a -> Integer -> a
(!!) BuiltinList a
xs Integer
i
  | Integer
i Integer -> Integer -> Bool
`B.lessThanInteger` Integer
0 = BuiltinString -> a
forall a. BuiltinString -> a
traceError BuiltinString
builtinListNegativeIndexError
  | Bool
otherwise =
      (() -> () -> a)
-> (a -> BuiltinList a -> () -> a) -> BuiltinList a -> () -> a
forall a r.
(() -> r) -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
B.caseList
        (\()
_ann -> BuiltinString -> () -> a
forall a. BuiltinString -> a
traceError BuiltinString
builtinListIndexTooLargeError)
        (\a
y BuiltinList a
_rest ()
_ann -> a
y)
        (Integer -> BuiltinList a -> BuiltinList a
forall a. Integer -> BuiltinList a -> BuiltinList a
BI.drop Integer
i BuiltinList a
xs)
        ()
{-# INLINEABLE (!!) #-}

-- | Plutus Tx version of 'Data.List.length' for 'BuiltinList'.
length :: forall a. BuiltinList a -> Integer
length :: forall a. BuiltinList a -> Integer
length = (a -> Integer -> Integer) -> Integer -> BuiltinList a -> Integer
forall a b. (a -> b -> b) -> b -> BuiltinList a -> b
foldr (\a
_ -> Integer -> Integer -> Integer
B.addInteger Integer
1) Integer
0
{-# INLINEABLE length #-}

-- | Returns the conjunction of a list of Bools.
and :: BuiltinList BuiltinBool -> Bool
and :: BuiltinList BuiltinBool -> Bool
and = (BuiltinBool -> Bool) -> BuiltinList BuiltinBool -> Bool
forall a. (a -> Bool) -> BuiltinList a -> Bool
all (\BuiltinBool
x -> BuiltinBool -> Bool -> Bool -> Bool
forall a. BuiltinBool -> a -> a -> a
BI.ifThenElse BuiltinBool
x Bool
True Bool
False)

-- | Returns the disjunction of a list of Bools.
or :: BuiltinList BuiltinBool -> Bool
or :: BuiltinList BuiltinBool -> Bool
or = (BuiltinBool -> Bool) -> BuiltinList BuiltinBool -> Bool
forall a. (a -> Bool) -> BuiltinList a -> Bool
any (\BuiltinBool
x -> BuiltinBool -> Bool -> Bool -> Bool
forall a. BuiltinBool -> a -> a -> a
BI.ifThenElse BuiltinBool
x Bool
True Bool
False)
{-# INLINEABLE or #-}

-- | The negation of `elem`.
notElem :: forall a. (Eq a) => a -> BuiltinList a -> Bool
notElem :: forall a. Eq a => a -> BuiltinList a -> Bool
notElem a
a = Bool -> Bool
not (Bool -> Bool) -> (BuiltinList a -> Bool) -> BuiltinList a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> BuiltinList a -> Bool
forall a. Eq a => a -> BuiltinList a -> Bool
elem a
a
{-# INLINEABLE notElem #-}

-- | Plutus Tx version of 'Data.List.foldr' for 'BuiltinList'.
foldr :: forall a b. (a -> b -> b) -> b -> BuiltinList a -> b
foldr :: forall a b. (a -> b -> b) -> b -> BuiltinList a -> b
foldr a -> b -> b
f b
acc = BuiltinList a -> b
go
 where
  go :: BuiltinList a -> b
  go :: BuiltinList a -> b
go = b -> (a -> BuiltinList a -> b) -> BuiltinList a -> b
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' b
acc (\a
x BuiltinList a
xs -> a -> b -> b
f a
x (BuiltinList a -> b
go BuiltinList a
xs))
{-# INLINEABLE foldr #-}

-- | Plutus Tx velsion of 'Data.List.foldl' for 'BuiltinList'.
foldl :: forall a b. (b -> a -> b) -> b -> BuiltinList a -> b
foldl :: forall a b. (b -> a -> b) -> b -> BuiltinList a -> b
foldl b -> a -> b
f = b -> BuiltinList a -> b
go
 where
  go :: b -> BuiltinList a -> b
  go :: b -> BuiltinList a -> b
go b
acc = b -> (a -> BuiltinList a -> b) -> BuiltinList a -> b
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' b
acc (\a
x BuiltinList a
xs -> b -> BuiltinList a -> b
go (b -> a -> b
f b
acc a
x) BuiltinList a
xs)
{-# INLINEABLE foldl #-}

-- | Plutus Tx version of '(Data.List.++)' for 'BuiltinList'.
infixr 5 ++

(++) :: forall a. BuiltinList a -> BuiltinList a -> BuiltinList a
++ :: forall a. BuiltinList a -> BuiltinList a -> BuiltinList a
(++) BuiltinList a
l BuiltinList a
r = (a -> BuiltinList a -> BuiltinList a)
-> BuiltinList a -> BuiltinList a -> BuiltinList a
forall a b. (a -> b -> b) -> b -> BuiltinList a -> b
foldr a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
(<|) BuiltinList a
r BuiltinList a
l
{-# INLINEABLE (++) #-}

-- | Plutus Tx version of 'Data.List.append' for 'BuiltinList'.
append :: forall a. BuiltinList a -> BuiltinList a -> BuiltinList a
append :: forall a. BuiltinList a -> BuiltinList a -> BuiltinList a
append = BuiltinList a -> BuiltinList a -> BuiltinList a
forall a. BuiltinList a -> BuiltinList a -> BuiltinList a
(++)
{-# INLINEABLE append #-}

-- | Plutus Tx version of 'Data.List.concat' for 'BuiltinList'.
concat :: forall a. (MkNil a) => BuiltinList (BuiltinList a) -> BuiltinList a
concat :: forall a. MkNil a => BuiltinList (BuiltinList a) -> BuiltinList a
concat = (BuiltinList a -> BuiltinList a -> BuiltinList a)
-> BuiltinList a -> BuiltinList (BuiltinList a) -> BuiltinList a
forall a b. (a -> b -> b) -> b -> BuiltinList a -> b
foldr BuiltinList a -> BuiltinList a -> BuiltinList a
forall a. BuiltinList a -> BuiltinList a -> BuiltinList a
(++) BuiltinList a
forall a. MkNil a => BuiltinList a
empty
{-# INLINEABLE concat #-}

-- | Plutus Tx version of 'Data.List.concatMap' for 'BuiltinList'.
concatMap :: forall a b. (MkNil b) => (a -> BuiltinList b) -> BuiltinList a -> BuiltinList b
concatMap :: forall a b.
MkNil b =>
(a -> BuiltinList b) -> BuiltinList a -> BuiltinList b
concatMap a -> BuiltinList b
f = (a -> BuiltinList b -> BuiltinList b)
-> BuiltinList b -> BuiltinList a -> BuiltinList b
forall a b. (a -> b -> b) -> b -> BuiltinList a -> b
foldr (\a
x BuiltinList b
ys -> a -> BuiltinList b
f a
x BuiltinList b -> BuiltinList b -> BuiltinList b
forall a. BuiltinList a -> BuiltinList a -> BuiltinList a
++ BuiltinList b
ys) BuiltinList b
forall a. MkNil a => BuiltinList a
empty
{-# INLINEABLE concatMap #-}

-- | Plutus Tx version of 'Data.List.filter' for 'BuiltinList'.
filter :: forall a. (MkNil a) => (a -> Bool) -> BuiltinList a -> BuiltinList a
filter :: forall a. MkNil a => (a -> Bool) -> BuiltinList a -> BuiltinList a
filter a -> Bool
p = (a -> BuiltinList a -> BuiltinList a)
-> BuiltinList a -> BuiltinList a -> BuiltinList a
forall a b. (a -> b -> b) -> b -> BuiltinList a -> b
foldr (\a
x BuiltinList a
xs -> if a -> Bool
p a
x then a
x a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a
xs else BuiltinList a
xs) BuiltinList a
forall a. MkNil a => BuiltinList a
empty
{-# INLINEABLE filter #-}

-- | Plutus Tx version of 'Data.List.listToMaybe' for 'BuiltinList'.
listToMaybe :: forall a. BuiltinList a -> Maybe a
listToMaybe :: forall a. BuiltinList a -> Maybe a
listToMaybe = Maybe a
-> (a -> BuiltinList a -> Maybe a) -> BuiltinList a -> Maybe a
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' Maybe a
forall a. Maybe a
Nothing (\a
x BuiltinList a
_ -> a -> Maybe a
forall a. a -> Maybe a
Just a
x)
{-# INLINEABLE listToMaybe #-}

-- | Return the element in the list, if there is precisely one.
uniqueElement :: forall a. BuiltinList a -> Maybe a
uniqueElement :: forall a. BuiltinList a -> Maybe a
uniqueElement =
  Maybe a
-> (a -> BuiltinList a -> Maybe a) -> BuiltinList a -> Maybe a
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList'
    Maybe a
forall a. Maybe a
Nothing
    (\a
x -> Maybe a
-> (a -> BuiltinList a -> Maybe a) -> BuiltinList a -> Maybe a
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' (a -> Maybe a
forall a. a -> Maybe a
Just a
x) (\a
_ BuiltinList a
_ -> Maybe a
forall a. Maybe a
Nothing))
{-# INLINEABLE uniqueElement #-}

-- | Plutus Tx version of 'Data.List.findIndices' for 'BuiltinList'.
findIndices :: forall a. (a -> Bool) -> BuiltinList a -> BuiltinList Integer
findIndices :: forall a. (a -> Bool) -> BuiltinList a -> BuiltinList Integer
findIndices a -> Bool
p = Integer -> BuiltinList a -> BuiltinList Integer
go Integer
0
 where
  go :: Integer -> BuiltinList a -> BuiltinList Integer
  go :: Integer -> BuiltinList a -> BuiltinList Integer
go Integer
i =
    BuiltinList Integer
-> (a -> BuiltinList a -> BuiltinList Integer)
-> BuiltinList a
-> BuiltinList Integer
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList'
      BuiltinList Integer
forall a. MkNil a => BuiltinList a
empty
      ( \a
x BuiltinList a
xs ->
          let indices :: BuiltinList Integer
indices = Integer -> BuiltinList a -> BuiltinList Integer
go (Integer -> Integer -> Integer
B.addInteger Integer
i Integer
1) BuiltinList a
xs
           in if a -> Bool
p a
x then Integer
i Integer -> BuiltinList Integer -> BuiltinList Integer
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList Integer
indices else BuiltinList Integer
indices
      )
{-# INLINEABLE findIndices #-}

-- | Plutus Tx version of 'Data.List.findIndex'.
findIndex :: forall a. (a -> Bool) -> BuiltinList a -> Maybe Integer
findIndex :: forall a. (a -> Bool) -> BuiltinList a -> Maybe Integer
findIndex a -> Bool
f = Integer -> BuiltinList a -> Maybe Integer
go Integer
0
 where
  go :: Integer -> BuiltinList a -> Maybe Integer
  go :: Integer -> BuiltinList a -> Maybe Integer
go Integer
i =
    Maybe Integer
-> (a -> BuiltinList a -> Maybe Integer)
-> BuiltinList a
-> Maybe Integer
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList'
      Maybe Integer
forall a. Maybe a
Nothing
      (\a
x BuiltinList a
xs -> if a -> Bool
f a
x then Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
i else Integer -> BuiltinList a -> Maybe Integer
go (Integer -> Integer -> Integer
B.addInteger Integer
i Integer
1) BuiltinList a
xs)
{-# INLINEABLE findIndex #-}

{-| Cons each element of the first list to the second one in reverse order
(i.e. the last element of the first list is the head of the result).

> revAppend xs ys === reverse xs ++ ys
-}
revAppend :: forall a. BuiltinList a -> BuiltinList a -> BuiltinList a
revAppend :: forall a. BuiltinList a -> BuiltinList a -> BuiltinList a
revAppend BuiltinList a
l BuiltinList a
r = BuiltinList a
-> (a -> BuiltinList a -> BuiltinList a)
-> BuiltinList a
-> BuiltinList a
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' BuiltinList a
r (\a
x BuiltinList a
xs -> BuiltinList a -> BuiltinList a -> BuiltinList a
forall a. BuiltinList a -> BuiltinList a -> BuiltinList a
revAppend BuiltinList a
xs (a
x a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a
r)) BuiltinList a
l
{-# INLINEABLE revAppend #-}

-- | Plutus Tx version of 'Data.List.reverse' for 'BuiltinList'.
reverse :: forall a. (MkNil a) => BuiltinList a -> BuiltinList a
reverse :: forall a. MkNil a => BuiltinList a -> BuiltinList a
reverse BuiltinList a
xs = BuiltinList a -> BuiltinList a -> BuiltinList a
forall a. BuiltinList a -> BuiltinList a -> BuiltinList a
revAppend BuiltinList a
xs BuiltinList a
forall a. MkNil a => BuiltinList a
empty
{-# INLINEABLE reverse #-}

-- | Plutus Tx version of 'Data.List.zip' for 'BuiltinList'.
_zip
  :: forall a b
   . (MkNil a, MkNil b)
  => BuiltinList a
  -> BuiltinList b
  -> BuiltinList (BuiltinPair a b)
_zip :: forall a b.
(MkNil a, MkNil b) =>
BuiltinList a -> BuiltinList b -> BuiltinList (BuiltinPair a b)
_zip = (a -> b -> BuiltinPair a b)
-> BuiltinList a -> BuiltinList b -> BuiltinList (BuiltinPair a b)
forall a b c.
MkNil c =>
(a -> b -> c) -> BuiltinList a -> BuiltinList b -> BuiltinList c
zipWith (((a, b) -> BuiltinPair a b) -> a -> b -> BuiltinPair a b
forall a b c. ((a, b) -> c) -> a -> b -> c
curry (a, b) -> BuiltinPair a b
forall a b. (a, b) -> BuiltinPair a b
BI.BuiltinPair)
{-# INLINEABLE _zip #-}

-- | Plutus Tx version of 'Data.List.unzip' for 'BuiltinList'.
_unzip
  :: forall a b
   . (MkNil a, MkNil b)
  => BuiltinList (BuiltinPair a b)
  -> BuiltinPair (BuiltinList a) (BuiltinList b)
_unzip :: forall a b.
(MkNil a, MkNil b) =>
BuiltinList (BuiltinPair a b)
-> BuiltinPair (BuiltinList a) (BuiltinList b)
_unzip =
  BuiltinPair (BuiltinList a) (BuiltinList b)
-> (BuiltinPair a b
    -> BuiltinList (BuiltinPair a b)
    -> BuiltinPair (BuiltinList a) (BuiltinList b))
-> BuiltinList (BuiltinPair a b)
-> BuiltinPair (BuiltinList a) (BuiltinList b)
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList'
    BuiltinPair (BuiltinList a) (BuiltinList b)
emptyPair
    ( \BuiltinPair a b
p BuiltinList (BuiltinPair a b)
l -> do
        let x :: a
x = BuiltinPair a b -> a
forall a b. BuiltinPair a b -> a
BI.fst BuiltinPair a b
p
        let y :: b
y = BuiltinPair a b -> b
forall a b. BuiltinPair a b -> b
BI.snd BuiltinPair a b
p
        let l' :: BuiltinPair (BuiltinList a) (BuiltinList b)
l' = BuiltinList (BuiltinPair a b)
-> BuiltinPair (BuiltinList a) (BuiltinList b)
forall a b.
(MkNil a, MkNil b) =>
BuiltinList (BuiltinPair a b)
-> BuiltinPair (BuiltinList a) (BuiltinList b)
_unzip BuiltinList (BuiltinPair a b)
l
        let xs' :: BuiltinList a
xs' = BuiltinPair (BuiltinList a) (BuiltinList b) -> BuiltinList a
forall a b. BuiltinPair a b -> a
BI.fst BuiltinPair (BuiltinList a) (BuiltinList b)
l'
        let ys' :: BuiltinList b
ys' = BuiltinPair (BuiltinList a) (BuiltinList b) -> BuiltinList b
forall a b. BuiltinPair a b -> b
BI.snd BuiltinPair (BuiltinList a) (BuiltinList b)
l'
        (BuiltinList a, BuiltinList b)
-> BuiltinPair (BuiltinList a) (BuiltinList b)
forall a b. (a, b) -> BuiltinPair a b
BI.BuiltinPair (a
x a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a
xs', b
y b -> BuiltinList b -> BuiltinList b
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList b
ys')
    )
 where
  emptyPair :: BuiltinPair (BuiltinList a) (BuiltinList b)
  emptyPair :: BuiltinPair (BuiltinList a) (BuiltinList b)
emptyPair = (BuiltinList a, BuiltinList b)
-> BuiltinPair (BuiltinList a) (BuiltinList b)
forall a b. (a, b) -> BuiltinPair a b
BI.BuiltinPair (BuiltinList a
forall a. MkNil a => BuiltinList a
empty, BuiltinList b
forall a. MkNil a => BuiltinList a
empty)
{-# INLINEABLE _unzip #-}

-- | Plutus Tx version of 'Data.List.head' for 'BuiltinList'.
head :: forall a. BuiltinList a -> a
head :: forall a. BuiltinList a -> a
head =
  (() -> a) -> (a -> BuiltinList a -> a) -> BuiltinList a -> a
forall a r.
(() -> r) -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList
    (\()
_ -> BuiltinString -> a
forall a. BuiltinString -> a
traceError BuiltinString
headEmptyBuiltinListError)
    (\a
x BuiltinList a
_ -> a
x)
{-# INLINEABLE head #-}

-- | Plutus Tx version of 'Data.List.last' for 'BuiltinList'.
last :: forall a. BuiltinList a -> a
last :: forall a. BuiltinList a -> a
last =
  (() -> a) -> (a -> BuiltinList a -> a) -> BuiltinList a -> a
forall a r.
(() -> r) -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList
    (\()
_ -> BuiltinString -> a
forall a. BuiltinString -> a
traceError BuiltinString
lastEmptyBuiltinListError)
    (\a
x BuiltinList a
xs -> a -> (a -> BuiltinList a -> a) -> BuiltinList a -> a
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' a
x (\a
_ BuiltinList a
_ -> BuiltinList a -> a
forall a. BuiltinList a -> a
last BuiltinList a
xs) BuiltinList a
xs)
{-# INLINEABLE last #-}

-- | Plutus Tx version of 'Data.List.tail' for 'BuiltinList'.
tail :: forall a. BuiltinList a -> BuiltinList a
tail :: forall a. BuiltinList a -> BuiltinList a
tail = (() -> BuiltinList a)
-> (a -> BuiltinList a -> BuiltinList a)
-> BuiltinList a
-> BuiltinList a
forall a r.
(() -> r) -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList (\()
_ -> BuiltinString -> BuiltinList a
forall a. BuiltinString -> a
traceError BuiltinString
lastEmptyBuiltinListError) (\a
_ BuiltinList a
xs -> BuiltinList a
xs)
{-# INLINEABLE tail #-}

-- | Plutus Tx version of 'Data.List.take' for 'BuiltinList'.
take :: forall a. (MkNil a) => Integer -> BuiltinList a -> BuiltinList a
take :: forall a. MkNil a => Integer -> BuiltinList a -> BuiltinList a
take Integer
n BuiltinList a
l
  | Integer
n Integer -> Integer -> Bool
`B.lessThanEqualsInteger` Integer
0 = BuiltinList a
forall a. MkNil a => BuiltinList a
empty
  | Bool
otherwise =
      BuiltinList a
-> (a -> BuiltinList a -> BuiltinList a)
-> BuiltinList a
-> BuiltinList a
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList'
        BuiltinList a
forall a. MkNil a => BuiltinList a
empty
        (\a
x BuiltinList a
xs -> a
x a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| Integer -> BuiltinList a -> BuiltinList a
forall a. MkNil a => Integer -> BuiltinList a -> BuiltinList a
take (Integer -> Integer -> Integer
B.subtractInteger Integer
n Integer
1) BuiltinList a
xs)
        BuiltinList a
l
{-# INLINEABLE take #-}

-- | Plutus Tx version of 'Data.List.drop' for 'BuiltinList'.
drop :: forall a. (MkNil a) => Integer -> BuiltinList a -> BuiltinList a
drop :: forall a. MkNil a => Integer -> BuiltinList a -> BuiltinList a
drop Integer
n BuiltinList a
l
  | Integer
n Integer -> Integer -> Bool
`B.lessThanEqualsInteger` Integer
0 = BuiltinList a
l
  | Bool
otherwise =
      BuiltinList a
-> (a -> BuiltinList a -> BuiltinList a)
-> BuiltinList a
-> BuiltinList a
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList'
        BuiltinList a
forall a. MkNil a => BuiltinList a
empty
        (\a
_ BuiltinList a
xs -> Integer -> BuiltinList a -> BuiltinList a
forall a. MkNil a => Integer -> BuiltinList a -> BuiltinList a
drop (Integer -> Integer -> Integer
B.subtractInteger Integer
n Integer
1) BuiltinList a
xs)
        BuiltinList a
l
{-# INLINEABLE drop #-}

-- | Plutus Tx version of 'Data.List.splitAt' for 'BuiltinList'.
_splitAt
  :: forall a
   . (MkNil a)
  => Integer
  -> BuiltinList a
  -> BuiltinPair (BuiltinList a) (BuiltinList a)
_splitAt :: forall a.
MkNil a =>
Integer
-> BuiltinList a -> BuiltinPair (BuiltinList a) (BuiltinList a)
_splitAt Integer
n BuiltinList a
xs
  | Integer
n Integer -> Integer -> Bool
`B.lessThanEqualsInteger` Integer
0 = (BuiltinList a, BuiltinList a)
-> BuiltinPair (BuiltinList a) (BuiltinList a)
forall a b. (a, b) -> BuiltinPair a b
BI.BuiltinPair (BuiltinList a
forall a. MkNil a => BuiltinList a
empty, BuiltinList a
xs)
  | BuiltinList a -> Bool
forall a. BuiltinList a -> Bool
B.null BuiltinList a
xs = (BuiltinList a, BuiltinList a)
-> BuiltinPair (BuiltinList a) (BuiltinList a)
forall a b. (a, b) -> BuiltinPair a b
BI.BuiltinPair (BuiltinList a
forall a. MkNil a => BuiltinList a
empty, BuiltinList a
forall a. MkNil a => BuiltinList a
empty)
  | Bool
otherwise = do
      let (a
x, BuiltinList a
xs') = BuiltinList a -> (a, BuiltinList a)
forall a. BuiltinList a -> (a, BuiltinList a)
B.unsafeUncons BuiltinList a
xs
      let BI.BuiltinPair (BuiltinList a
xs'', BuiltinList a
xs''') = Integer
-> BuiltinList a -> BuiltinPair (BuiltinList a) (BuiltinList a)
forall a.
MkNil a =>
Integer
-> BuiltinList a -> BuiltinPair (BuiltinList a) (BuiltinList a)
_splitAt (Integer
n Integer -> Integer -> Integer
`B.subtractInteger` Integer
1) BuiltinList a
xs'
      (BuiltinList a, BuiltinList a)
-> BuiltinPair (BuiltinList a) (BuiltinList a)
forall a b. (a, b) -> BuiltinPair a b
BI.BuiltinPair (a
x a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a
xs'', BuiltinList a
xs''')
{-# INLINEABLE _splitAt #-}

-- | Plutus Tx version of 'Data.List.nub' for 'BuiltinList'.
nub :: forall a. (Eq a, MkNil a) => BuiltinList a -> BuiltinList a
nub :: forall a. (Eq a, MkNil a) => BuiltinList a -> BuiltinList a
nub = (a -> a -> Bool) -> BuiltinList a -> BuiltinList a
forall a.
MkNil a =>
(a -> a -> Bool) -> BuiltinList a -> BuiltinList a
nubBy a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==)
{-# INLINEABLE nub #-}

-- | Plutus Tx version of 'Data.List.elemBy' for 'BuiltinList'.
elemBy :: forall a. (a -> a -> Bool) -> a -> BuiltinList a -> Bool
elemBy :: forall a. (a -> a -> Bool) -> a -> BuiltinList a -> Bool
elemBy a -> a -> Bool
eq a
y = BuiltinList a -> Bool
go
 where
  go :: BuiltinList a -> Bool
  go :: BuiltinList a -> Bool
go = Bool -> (a -> BuiltinList a -> Bool) -> BuiltinList a -> Bool
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' Bool
False (\a
x BuiltinList a
xs -> if a -> a -> Bool
eq a
x a
y then Bool
True else BuiltinList a -> Bool
go BuiltinList a
xs)
{-# INLINEABLE elemBy #-}

-- | Plutus Tx version of 'Data.List.nubBy' for 'BuiltinList'.
nubBy :: forall a. (MkNil a) => (a -> a -> Bool) -> BuiltinList a -> BuiltinList a
nubBy :: forall a.
MkNil a =>
(a -> a -> Bool) -> BuiltinList a -> BuiltinList a
nubBy a -> a -> Bool
eq = (BuiltinList a -> BuiltinList a -> BuiltinList a)
-> BuiltinList a -> BuiltinList a -> BuiltinList a
forall a b c. (a -> b -> c) -> b -> a -> c
flip BuiltinList a -> BuiltinList a -> BuiltinList a
go BuiltinList a
forall a. MkNil a => BuiltinList a
empty
 where
  go :: BuiltinList a -> BuiltinList a -> BuiltinList a
  go :: BuiltinList a -> BuiltinList a -> BuiltinList a
go BuiltinList a
l BuiltinList a
xs =
    BuiltinList a
-> (a -> BuiltinList a -> BuiltinList a)
-> BuiltinList a
-> BuiltinList a
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList'
      BuiltinList a
forall a. MkNil a => BuiltinList a
empty
      ( \a
y BuiltinList a
ys ->
          if (a -> a -> Bool) -> a -> BuiltinList a -> Bool
forall a. (a -> a -> Bool) -> a -> BuiltinList a -> Bool
elemBy a -> a -> Bool
eq a
y BuiltinList a
xs
            then BuiltinList a -> BuiltinList a -> BuiltinList a
go BuiltinList a
ys BuiltinList a
xs
            else a
y a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a -> BuiltinList a -> BuiltinList a
go BuiltinList a
ys (a
y a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a
xs)
      )
      BuiltinList a
l
{-# INLINEABLE nubBy #-}

-- | Plutus Tx version of 'Data.List.zipWith' for 'BuiltinList'.
zipWith
  :: forall a b c
   . (MkNil c)
  => (a -> b -> c)
  -> BuiltinList a
  -> BuiltinList b
  -> BuiltinList c
zipWith :: forall a b c.
MkNil c =>
(a -> b -> c) -> BuiltinList a -> BuiltinList b -> BuiltinList c
zipWith a -> b -> c
f = BuiltinList a -> BuiltinList b -> BuiltinList c
go
 where
  go :: BuiltinList a -> BuiltinList b -> BuiltinList c
  go :: BuiltinList a -> BuiltinList b -> BuiltinList c
go BuiltinList a
xs BuiltinList b
ys =
    BuiltinList c
-> (a -> BuiltinList a -> BuiltinList c)
-> BuiltinList a
-> BuiltinList c
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList'
      BuiltinList c
forall a. MkNil a => BuiltinList a
empty
      ( \a
x BuiltinList a
xs' ->
          BuiltinList c
-> (b -> BuiltinList b -> BuiltinList c)
-> BuiltinList b
-> BuiltinList c
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList'
            BuiltinList c
forall a. MkNil a => BuiltinList a
empty
            (\b
y BuiltinList b
ys' -> a -> b -> c
f a
x b
y c -> BuiltinList c -> BuiltinList c
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a -> BuiltinList b -> BuiltinList c
go BuiltinList a
xs' BuiltinList b
ys')
            BuiltinList b
ys
      )
      BuiltinList a
xs
{-# INLINEABLE zipWith #-}

-- | Plutus Tx version of 'Data.List.dropWhile' for 'BuiltinList'.
dropWhile :: forall a. (a -> Bool) -> BuiltinList a -> BuiltinList a
dropWhile :: forall a. (a -> Bool) -> BuiltinList a -> BuiltinList a
dropWhile a -> Bool
p = BuiltinList a -> BuiltinList a
go
 where
  go :: BuiltinList a -> BuiltinList a
  go :: BuiltinList a -> BuiltinList a
go BuiltinList a
xs = BuiltinList a
-> (a -> BuiltinList a -> BuiltinList a)
-> BuiltinList a
-> BuiltinList a
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' BuiltinList a
xs (\a
x BuiltinList a
xs' -> if a -> Bool
p a
x then BuiltinList a -> BuiltinList a
go BuiltinList a
xs' else BuiltinList a
xs) BuiltinList a
xs
{-# INLINEABLE dropWhile #-}

-- | Plutus Tx version of 'Data.List.replicate' for 'BuiltinList'.
replicate :: forall a. (MkNil a) => Integer -> a -> BuiltinList a
replicate :: forall a. MkNil a => Integer -> a -> BuiltinList a
replicate Integer
n0 a
x = Integer -> BuiltinList a
go Integer
n0
 where
  go :: Integer -> BuiltinList a
  go :: Integer -> BuiltinList a
go Integer
n
    | Integer
n Integer -> Integer -> Bool
`B.lessThanEqualsInteger` Integer
0 = BuiltinList a
forall a. MkNil a => BuiltinList a
empty
    | Bool
otherwise = a
x a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| Integer -> BuiltinList a
go (Integer -> Integer -> Integer
B.subtractInteger Integer
n Integer
1)
{-# INLINEABLE replicate #-}

-- | Plutus Tx version of 'Data.List.partition' for 'BuiltinList'.
_partition
  :: forall a
   . (MkNil a)
  => (a -> Bool)
  -> BuiltinList a
  -> BuiltinPair (BuiltinList a) (BuiltinList a)
_partition :: forall a.
MkNil a =>
(a -> Bool)
-> BuiltinList a -> BuiltinPair (BuiltinList a) (BuiltinList a)
_partition a -> Bool
p = (BuiltinList a, BuiltinList a)
-> BuiltinPair (BuiltinList a) (BuiltinList a)
forall a b. (a, b) -> BuiltinPair a b
BI.BuiltinPair ((BuiltinList a, BuiltinList a)
 -> BuiltinPair (BuiltinList a) (BuiltinList a))
-> (BuiltinList a -> (BuiltinList a, BuiltinList a))
-> BuiltinList a
-> BuiltinPair (BuiltinList a) (BuiltinList a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a
 -> (BuiltinList a, BuiltinList a)
 -> (BuiltinList a, BuiltinList a))
-> (BuiltinList a, BuiltinList a)
-> BuiltinList a
-> (BuiltinList a, BuiltinList a)
forall a b. (a -> b -> b) -> b -> BuiltinList a -> b
foldr a
-> (BuiltinList a, BuiltinList a) -> (BuiltinList a, BuiltinList a)
select (BuiltinList a
forall a. MkNil a => BuiltinList a
empty, BuiltinList a
forall a. MkNil a => BuiltinList a
empty)
 where
  select :: a -> (BuiltinList a, BuiltinList a) -> (BuiltinList a, BuiltinList a)
  select :: a
-> (BuiltinList a, BuiltinList a) -> (BuiltinList a, BuiltinList a)
select a
x ~(BuiltinList a
ts, BuiltinList a
fs) = if a -> Bool
p a
x then (a
x a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a
ts, BuiltinList a
fs) else (BuiltinList a
ts, a
x a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a
fs)
{-# INLINEABLE _partition #-}

-- | Plutus Tx version of 'Data.List.sort' for 'BuiltinList'.
_sort :: (MkNil a, Ord a) => BuiltinList a -> BuiltinList a
_sort :: forall a. (MkNil a, Ord a) => BuiltinList a -> BuiltinList a
_sort = (a -> a -> Ordering) -> BuiltinList a -> BuiltinList a
forall a.
MkNil a =>
(a -> a -> Ordering) -> BuiltinList a -> BuiltinList a
_sortBy a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare
{-# INLINEABLE _sort #-}

-- | Plutus Tx version of 'Data.List.sortBy' for 'BuiltinList'.
_sortBy :: (MkNil a) => (a -> a -> Ordering) -> BuiltinList a -> BuiltinList a
_sortBy :: forall a.
MkNil a =>
(a -> a -> Ordering) -> BuiltinList a -> BuiltinList a
_sortBy a -> a -> Ordering
cmp = BuiltinList (BuiltinList a) -> BuiltinList a
mergeAll (BuiltinList (BuiltinList a) -> BuiltinList a)
-> (BuiltinList a -> BuiltinList (BuiltinList a))
-> BuiltinList a
-> BuiltinList a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BuiltinList a -> BuiltinList (BuiltinList a)
sequences
 where
  sequences :: BuiltinList a -> BuiltinList (BuiltinList a)
sequences = BuiltinList (BuiltinList a)
-> (a -> BuiltinList (BuiltinList a))
-> (a -> a -> BuiltinList a -> BuiltinList (BuiltinList a))
-> BuiltinList a
-> BuiltinList (BuiltinList a)
forall a r.
r
-> (a -> r) -> (a -> a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList'' BuiltinList (BuiltinList a)
forall a. MkNil a => BuiltinList a
empty (BuiltinList a -> BuiltinList (BuiltinList a)
forall a. MkNil a => a -> BuiltinList a
singleton (BuiltinList a -> BuiltinList (BuiltinList a))
-> (a -> BuiltinList a) -> a -> BuiltinList (BuiltinList a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> BuiltinList a
forall a. MkNil a => a -> BuiltinList a
singleton) a -> a -> BuiltinList a -> BuiltinList (BuiltinList a)
f
   where
    f :: a -> a -> BuiltinList a -> BuiltinList (BuiltinList a)
f a
a a
b BuiltinList a
xs
      | a
a a -> a -> Ordering
`cmp` a
b Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
GT = a -> BuiltinList a -> BuiltinList a -> BuiltinList (BuiltinList a)
descending a
b (a -> BuiltinList a
forall a. MkNil a => a -> BuiltinList a
singleton a
a) BuiltinList a
xs
      | Bool
otherwise = a
-> (BuiltinList a -> BuiltinList a)
-> BuiltinList a
-> BuiltinList (BuiltinList a)
ascending a
b (a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
cons a
a) BuiltinList a
xs

  descending :: a -> BuiltinList a -> BuiltinList a -> BuiltinList (BuiltinList a)
descending a
a BuiltinList a
as BuiltinList a
l = BuiltinList (BuiltinList a)
-> (a -> BuiltinList a -> BuiltinList (BuiltinList a))
-> BuiltinList a
-> BuiltinList (BuiltinList a)
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' BuiltinList (BuiltinList a)
d a -> BuiltinList a -> BuiltinList (BuiltinList a)
f BuiltinList a
l
   where
    d :: BuiltinList (BuiltinList a)
d = (a
a a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a
as) BuiltinList a
-> BuiltinList (BuiltinList a) -> BuiltinList (BuiltinList a)
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a -> BuiltinList (BuiltinList a)
sequences BuiltinList a
l
    f :: a -> BuiltinList a -> BuiltinList (BuiltinList a)
f a
b BuiltinList a
bs
      | a
a a -> a -> Ordering
`cmp` a
b Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
GT = a -> BuiltinList a -> BuiltinList a -> BuiltinList (BuiltinList a)
descending a
b (a
a a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a
as) BuiltinList a
bs
      | Bool
otherwise = BuiltinList (BuiltinList a)
d

  ascending :: a
-> (BuiltinList a -> BuiltinList a)
-> BuiltinList a
-> BuiltinList (BuiltinList a)
ascending a
a BuiltinList a -> BuiltinList a
as BuiltinList a
l = BuiltinList (BuiltinList a)
-> (a -> BuiltinList a -> BuiltinList (BuiltinList a))
-> BuiltinList a
-> BuiltinList (BuiltinList a)
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' BuiltinList (BuiltinList a)
d a -> BuiltinList a -> BuiltinList (BuiltinList a)
f BuiltinList a
l
   where
    d :: BuiltinList (BuiltinList a)
d = BuiltinList a -> BuiltinList a
as (a -> BuiltinList a
forall a. MkNil a => a -> BuiltinList a
singleton a
a) BuiltinList a
-> BuiltinList (BuiltinList a) -> BuiltinList (BuiltinList a)
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a -> BuiltinList (BuiltinList a)
sequences BuiltinList a
l
    f :: a -> BuiltinList a -> BuiltinList (BuiltinList a)
f a
b BuiltinList a
bs
      | a
a a -> a -> Ordering
`cmp` a
b Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
GT = a
-> (BuiltinList a -> BuiltinList a)
-> BuiltinList a
-> BuiltinList (BuiltinList a)
ascending a
b (BuiltinList a -> BuiltinList a
as (BuiltinList a -> BuiltinList a)
-> (BuiltinList a -> BuiltinList a)
-> BuiltinList a
-> BuiltinList a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
cons a
a) BuiltinList a
bs
      | Bool
otherwise = BuiltinList (BuiltinList a)
d

  mergeAll :: BuiltinList (BuiltinList a) -> BuiltinList a
mergeAll BuiltinList (BuiltinList a)
l =
    case BuiltinList (BuiltinList a) -> Maybe (BuiltinList a)
forall a. BuiltinList a -> Maybe a
uniqueElement BuiltinList (BuiltinList a)
l of
      Maybe (BuiltinList a)
Nothing ->
        BuiltinList (BuiltinList a) -> BuiltinList a
mergeAll (BuiltinList (BuiltinList a) -> BuiltinList (BuiltinList a)
mergePairs BuiltinList (BuiltinList a)
l)
      Just BuiltinList a
x ->
        BuiltinList a
x

  mergePairs :: BuiltinList (BuiltinList a) -> BuiltinList (BuiltinList a)
mergePairs = BuiltinList (BuiltinList a)
-> (BuiltinList a -> BuiltinList (BuiltinList a))
-> (BuiltinList a
    -> BuiltinList a
    -> BuiltinList (BuiltinList a)
    -> BuiltinList (BuiltinList a))
-> BuiltinList (BuiltinList a)
-> BuiltinList (BuiltinList a)
forall a r.
r
-> (a -> r) -> (a -> a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList'' BuiltinList (BuiltinList a)
forall a. MkNil a => BuiltinList a
empty BuiltinList a -> BuiltinList (BuiltinList a)
forall a. MkNil a => a -> BuiltinList a
singleton BuiltinList a
-> BuiltinList a
-> BuiltinList (BuiltinList a)
-> BuiltinList (BuiltinList a)
f
   where
    f :: BuiltinList a
-> BuiltinList a
-> BuiltinList (BuiltinList a)
-> BuiltinList (BuiltinList a)
f BuiltinList a
a BuiltinList a
b BuiltinList (BuiltinList a)
xs = BuiltinList a -> BuiltinList a -> BuiltinList a
merge BuiltinList a
a BuiltinList a
b BuiltinList a
-> BuiltinList (BuiltinList a) -> BuiltinList (BuiltinList a)
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList (BuiltinList a) -> BuiltinList (BuiltinList a)
mergePairs BuiltinList (BuiltinList a)
xs

  merge :: BuiltinList a -> BuiltinList a -> BuiltinList a
merge BuiltinList a
as BuiltinList a
bs
    | BuiltinList a -> Bool
forall a. BuiltinList a -> Bool
null BuiltinList a
as = BuiltinList a
bs
    | BuiltinList a -> Bool
forall a. BuiltinList a -> Bool
null BuiltinList a
bs = BuiltinList a
as
    | Bool
otherwise = do
        let a :: a
a = BuiltinList a -> a
forall a. BuiltinList a -> a
head BuiltinList a
as
        let b :: a
b = BuiltinList a -> a
forall a. BuiltinList a -> a
head BuiltinList a
bs
        let as' :: BuiltinList a
as' = BuiltinList a -> BuiltinList a
forall a. BuiltinList a -> BuiltinList a
tail BuiltinList a
as
        let bs' :: BuiltinList a
bs' = BuiltinList a -> BuiltinList a
forall a. BuiltinList a -> BuiltinList a
tail BuiltinList a
bs
        if a
a a -> a -> Ordering
`cmp` a
b Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
GT
          then
            a
b a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a -> BuiltinList a -> BuiltinList a
merge BuiltinList a
as BuiltinList a
bs'
          else
            a
a a -> BuiltinList a -> BuiltinList a
forall a. a -> BuiltinList a -> BuiltinList a
<| BuiltinList a -> BuiltinList a -> BuiltinList a
merge BuiltinList a
as' BuiltinList a
bs

  caseList'' :: forall a r. r -> (a -> r) -> (a -> a -> BuiltinList a -> r) -> BuiltinList a -> r
  caseList'' :: forall a r.
r
-> (a -> r) -> (a -> a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList'' r
f0 a -> r
f1 a -> a -> BuiltinList a -> r
f2 = r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' r
f0 (\a
x BuiltinList a
xs -> r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
forall a r. r -> (a -> BuiltinList a -> r) -> BuiltinList a -> r
caseList' (a -> r
f1 a
x) (\a
y BuiltinList a
ys -> a -> a -> BuiltinList a -> r
f2 a
x a
y BuiltinList a
ys) BuiltinList a
xs)
{-# INLINEABLE _sortBy #-}