| Safe Haskell | Safe-Inferred |
|---|---|
| Language | GHC2021 |
Plutarch.List
Description
Scott-encoded lists and ListLike typeclass
Synopsis
- data PList (a :: S -> Type) (s :: S)
- ptryUncons :: PIsListLike list a => Term s (list a :--> PPair a (list a))
- puncons :: PIsListLike list a => Term s (list a :--> PMaybe (PPair a (list a)))
- pzip :: (PListLike list, PElemConstraint list a, PElemConstraint list b, PElemConstraint list (PPair a b)) => Term s (list a :--> (list b :--> list (PPair a b)))
- pfind :: PIsListLike l a => Term s ((a :--> PBool) :--> (l a :--> PMaybe a))
- preverse :: forall (l :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S). PIsListLike l a => Term s (l a :--> l a)
- pcheckSorted :: forall (l :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S). (PIsListLike l a, POrd a) => Term s (l a :--> PBool)
- pelem :: (PIsListLike list a, PEq a) => Term s (a :--> (list a :--> PBool))
- (#!!) :: PIsListLike l a => Term s (l a) -> Term s PInteger -> Term s a
- pelemAt :: PIsListLike l a => Term s (PInteger :--> (l a :--> a))
- pelemAt' :: PIsListLike l a => Term s (PInteger :--> (l a :--> a))
- plistEquals :: (PIsListLike list a, PEq a) => Term s (list a :--> (list a :--> PBool))
- pmatchListN :: forall b li a s. PIsListLike li a => Integer -> Term s (li a) -> ([Term s a] -> Term s (li a) -> Term s b) -> Term s b
- pmatchList :: forall n r li a s. (PIsListLike li a, KnownNat (Length (Replicate n a)), UnsafeConstrNP (Replicate n a)) => Term s (li a) -> (NP (Term s) (Replicate n a) -> Term s (li a) -> Term s r) -> Term s r
- pmatchListUnsafe :: forall (struct :: [S -> Type]) r li a s. (PIsListLike li a, KnownNat (Length struct), UnsafeConstrNP struct) => Term s (li a) -> (NP (Term s) struct -> Term s (li a) -> Term s r) -> Term s r
Documentation
data PList (a :: S -> Type) (s :: S) Source #
SOP-encoded list.
Since: 1.10.0
Instances
ptryUncons :: PIsListLike list a => Term s (list a :--> PPair a (list a)) Source #
Extract head and tail of the list, throws error if list is empty.
puncons :: PIsListLike list a => Term s (list a :--> PMaybe (PPair a (list a))) Source #
Extract head and tail of the list, if list is not empty.
pzip :: (PListLike list, PElemConstraint list a, PElemConstraint list b, PElemConstraint list (PPair a b)) => Term s (list a :--> (list b :--> list (PPair a b))) Source #
O(min(n, m)) . Zip two lists together, creating pairs of the elements.
If the lists are of differing lengths, cut to the shortest.
pfind :: PIsListLike l a => Term s ((a :--> PBool) :--> (l a :--> PMaybe a)) Source #
O(n) . like haskell level find but on plutarch level
preverse :: forall (l :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S). PIsListLike l a => Term s (l a :--> l a) Source #
O(n) . Reverse a list-like structure.
Since: 1.10.0
pcheckSorted :: forall (l :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S). (PIsListLike l a, POrd a) => Term s (l a :--> PBool) Source #
O(n) . Checks if a list-list structure is sorted.
Since: 1.10.0
pelem :: (PIsListLike list a, PEq a) => Term s (a :--> (list a :--> PBool)) Source #
O(n) . Check if element is in the list
(#!!) :: PIsListLike l a => Term s (l a) -> Term s PInteger -> Term s a Source #
O(n) . Like Haskell level (!!) but on the plutarch level
pelemAt :: PIsListLike l a => Term s (PInteger :--> (l a :--> a)) Source #
O(n) . Like Haskell level (!!) but on the Plutarch level, not infix and
with arguments reversed, errors if the specified index is greater than or equal
to the lists length
pelemAt' :: PIsListLike l a => Term s (PInteger :--> (l a :--> a)) Source #
O(n) . like pelemAt but doesn't fail on negative indexes
plistEquals :: (PIsListLike list a, PEq a) => Term s (list a :--> (list a :--> PBool)) Source #
O(min(n, m)) . Check if two lists are equal.
pmatchListN :: forall b li a s. PIsListLike li a => Integer -> Term s (li a) -> ([Term s a] -> Term s (li a) -> Term s b) -> Term s b Source #
Match first N elements from the list. It's is better to use pmatchList if number of elements that needs to be
match does not need to be dynamically determined. It is important to understand each element given in Haskell
list is "computation" to get nth element. If those need to be referenced multiple times, it needs to be pletted to
prevent duplication of computation.
@since WIP
pmatchList :: forall n r li a s. (PIsListLike li a, KnownNat (Length (Replicate n a)), UnsafeConstrNP (Replicate n a)) => Term s (li a) -> (NP (Term s) (Replicate n a) -> Term s (li a) -> Term s r) -> Term s r Source #
Same functionality to pmatchListN but each matched value will be given in NP for better typing. Same performance
implications as pmatchListN.
@since WIP
pmatchListUnsafe :: forall (struct :: [S -> Type]) r li a s. (PIsListLike li a, KnownNat (Length struct), UnsafeConstrNP struct) => Term s (li a) -> (NP (Term s) struct -> Term s (li a) -> Term s r) -> Term s r Source #
Same as pmatchList but allows matching each element to arbitrary type. Essentially, this is pmatchList combined
with punsafeCoerce; therefore, this is unsafe and will require careful attention when using this.
This function is especially helpful when matching on PBuiltinList (PData) when user knows the type of each elements.
If first two elements are Data Integers, one can use pmatchListUnsafe '[PAsData PInteger, PAsData PInteger] li@ and
have everything already coerced when it's being matched.
@since WIP