duplicate a value into a tuple

>>> pl @Dup 4
Present (4,4) ('(4,4))
Val (4,4)

>>> pl @(Dup >> Id) 4
Present (4,4) ((>>) (4,4) | {Id (4,4)})
Val (4,4)

>>> pl @(Dup << Fst * Snd) (4,5)
Present (20,20) ((>>) (20,20) | {'(20,20)})
Val (20,20)

>>> pl @(Fst * Snd >> Dup) (4,5)
Present (20,20) ((>>) (20,20) | {'(20,20)})
Val (20,20)

applies a function against the first part of a tuple: similar to first

>>> pz @(First Succ) (12,True)
Val (13,True)

applies a function against the second part of a tuple: similar to second

>>> pz @(Second Succ) (12,False)
Val (12,True)

similar to &&&

>>> pl @(Min &&& Max >> Id >> Fst < Snd) [10,4,2,12,14]
True ((>>) True | {2 < 14})
Val True

>>> pl @((123 &&& Id) >> Fst + Snd) 4
Present 127 ((>>) 127 | {123 + 4 = 127})
Val 127

>>> pl @(4 &&& "sadf" &&& 'LT) ()
Present (4,("sadf",LT)) ('(4,("sadf",LT)))
Val (4,("sadf",LT))

>>> pl @(Id &&& '() &&& ()) (Just 10)
Present (Just 10,((),())) ('(Just 10,((),())))
Val (Just 10,((),()))

>>> pl @(Fst &&& Snd &&& Thd &&& ()) (1,'x',True)
Present (1,('x',(True,()))) ('(1,('x',(True,()))))
Val (1,('x',(True,())))

>>> pl @(Fst &&& Snd &&& Thd &&& ()) (1,'x',True)
Present (1,('x',(True,()))) ('(1,('x',(True,()))))
Val (1,('x',(True,())))

>>> pl @(Fst &&& Snd &&& Thd &&& ()) (1,1.4,"aaa")
Present (1,(1.4,("aaa",()))) ('(1,(1.4,("aaa",()))))
Val (1,(1.4,("aaa",())))

similar to ***

>>> pz @(Pred *** ShowP Id) (13, True)
Val (12,"True")

>>> pl @(Flip (***) Len (Id * 12)) (99,"cdef")
Present (1188,4) ((***) (1188,4) | (99,"cdef"))
Val (1188,4)

>>> pl @(4 *** "sadf" *** 'LT) ('x',("abv",[1]))
Present (4,("sadf",LT)) ((***) (4,("sadf",LT)) | ('x',("abv",[1])))
Val (4,("sadf",LT))

applies p to the first and second slot of an n-tuple (similar to ***)

>>> pl @(Fst >> Both Len) (("abc",[10..17]),True)
Present (3,8) ((>>) (3,8) | {Both})
Val (3,8)

>>> pl @(Lift (Both Pred) Fst) ((12,'z'),True)
Present (11,'y') ((>>) (11,'y') | {Both})
Val (11,'y')

>>> pl @(Both Succ) (4,'a')
Present (5,'b') (Both)
Val (5,'b')

>>> import Data.Time
>>> pl @(Both (ReadP Day Id)) ("1999-01-01","2001-02-12")
Present (1999-01-01,2001-02-12) (Both)
Val (1999-01-01,2001-02-12)

>>> pz @(Both (Id * Id) >> ((Fst + Snd) ** (DivI Double 1 2))) (3,4)
Val 5.0

similar to on for tuples

>>> pz @(On (==!) Len) ("1ss","x2") -- or use Comparing or Both+Compare
Val GT

>>> pz @('(4,2) >> On (**) (FromIntegral _)) ()
Val 16.0

>>> pz @('(4,2) >> Both (FromIntegral _) >> Fst ** Snd) () -- equivalent to the above
Val 16.0

>>> pz @(On (+) (Id * Id) >> Id ** (1 % 2 >> FromRational _)) (3,4)
Val 5.0

>>> pz @(Both (Id * Id) >> ((Fst + Snd) ** (1 % 2 >> FromRational _))) (3,4) -- equivalent to the above
Val 5.0

>>> pz @(On (<>) (Pure [] Id)) ('x','y')
Val "xy"

>>> pz @(On (Flip (<>)) (Pure [] Id)) ('x','y')
Val "yx"

>>> pz @(On (Flip (<>)) (Pure _ Id) >> '(Len,Head,Last)) ('x','y')
Val (2,'y','x')

similar to on

>>> pz @(On' (==!) Len Fst (Reverse << Snd)) ("1ss","x2")
Val GT

similar to uncurry

>>> pl @(Uncurry (==)) ('x','x')
True (On')
Val True

>>> pz @(Uncurry (.&.)) (7,15)
Val 7

>>> pz @(Uncurry (+)) (7,15)
Val 22

>>> pz @(Uncurry (*)) (7,15)
Val 105

>>> pz @(Uncurry '(,)) (7,15)
Val (7,15)

>>> pz @(Uncurry ('(,,) 4)) ('x',True)
Val (4,'x',True)

>>> pz @(Uncurry (Flip '(,))) (1,'x')
Val ('x',1)

>>> pz @(Uncurry (<>)) ("ab","def")
Val "abdef"

>>> pz @(Uncurry (<>)) (SG.Sum 12,SG.Sum 99)
Val (Sum {getSum = 111})

create a n tuple from a list or fail

>>> pz @(Tuple 4) "abcdefg"
Val ('a','b','c','d')

>>> pz @(Tuple 4) "abc"
Fail "Tuple(4) not enough elements(3)"

>>> pz @(Fst >> Tuple 3) ([1..5],True)
Val (1,2,3)

>>> pz @(Lift (Tuple 3) Fst) ([1..5],True)
Val (1,2,3)

create a n tuple from a list and return as an Either

>>> pz @(Tuple' 4) "abcdefg"
Val (Right ('a','b','c','d'))

>>> pz @(Tuple' 4) []
Val (Left [])

>>> pl @(Tuple' 4) "abc"
Present Left "abc" (Tuple'(4) not enough elements(3))
Val (Left "abc")

>>> :set -XPolyKinds
>>> type F n i = ChunksOf' n i Id >> Map (Tuple' n) >> PartitionEithers
>>> pz @(F 3 1) [1..7]
Val ([[6,7],[7]],[(1,2,3),(2,3,4),(3,4,5),(4,5,6),(5,6,7)])

creates a list of overlapping pairs of elements. requires two or more elements

>>> pz @Pairs [1,2,3,4]
Val [(1,2),(2,3),(3,4)]

>>> pz @Pairs []
Val []

>>> pz @Pairs [1]
Val []

>>> pl @Pairs [1,2]
Present [(1,2)] (Pairs [(1,2)] | [1,2])
Val [(1,2)]

>>> pl @Pairs [1,2,3]
Present [(1,2),(2,3)] (Pairs [(1,2),(2,3)] | [1,2,3])
Val [(1,2),(2,3)]

>>> pl @Pairs [1,2,3,4]
Present [(1,2),(2,3),(3,4)] (Pairs [(1,2),(2,3),(3,4)] | [1,2,3,4])
Val [(1,2),(2,3),(3,4)]

>>> pan @(Pairs >> Len >> 'True >> 'False >> FailT _ "xyzzy") "abcde"
[Error xyzzy] False
|
+- P Pairs [('a','b'),('b','c'),('c','d'),('d','e')]
|
+- P Len 4
|
+- True 'True
|
+- False 'False
|
`- [Error xyzzy]
Fail "xyzzy"

applies p to lhs of the tuple and q to the rhs and then ands them together: see &*

>>> pl @(AndA (Gt 3) (Lt 10) Id) (1,2)
False (False (&*) True | (1 > 3))
Val False

applies p to lhs of the tuple and q to the rhs and then Ands them together

>>> pl @(SplitAt 4 "abcdefg" >> Len > 4 &* Len < 5) ()
False ((>>) False | {False (&*) True | (4 > 4)})
Val False

applies p to lhs of the tuple and q to the rhs and then ors them together: see |+

>>> pl @(OrA (Gt 3) (Lt 10) Id) (1,2)
True (False (|+) True)
Val True

applies p to lhs of the tuple and q to the rhs and then Ors them together

>>> pl @(Sum > 44 |+ Id < 2) ([5,6,7,8,14,44],9)
True (True (|+) False)
Val True

>>> pl @(Sum > 44 |+ Id < 2) ([5,6,7,14],9)
False (False (|+) False | (32 > 44) (|+) (9 < 2))
Val False

>>> pl @(Sum > 44 |+ Id < 2) ([5,6,7,14],1)
True (False (|+) True)
Val True

run p with inductive tuples

>>> pz @(EachITuple Succ) (False,(2,(LT,('c',()))))
Val (True,(3,(EQ,('d',()))))

>>> pz @(EachITuple (Id + (4 >> FromIntegral _))) (1,(1/4,(5%6,())))
Val (5 % 1,(17 % 4,(29 % 6,())))

>>> pz @(ToITuple >> EachITuple (Id + (4 >> FromIntegral _))) (1000,1/4,5%6)
Val (1004 % 1,(17 % 4,(29 % 6,())))

>>> pz @(ToITuple >> EachITuple ((Id >> FromIntegral _) + (4 >> FromIntegral _))) (1000::Integer,17::Int)
Val (1004,(21,()))

>>> pz @(ToITuple >> EachITuple (Dup >> Fst<>Snd)) (SG.Min 1,SG.First 'x',"abcd")
Val (Min {getMin = 1},(First {getFirst = 'x'},("abcdabcd",())))

create inductive tuples from flat tuples

>>> pz @(ToITuple >> EachITuple Succ) (1,2,False,'x')
Val (2,(3,(True,('y',()))))

create flat tuples from inductive tuples

>>> pz @FromITuple (2,(3,(True,('y',()))))
Val (2,3,True,'y')

>>> pz @FromITuple ()
Val ()

>>> pz @FromITuple (1,())
Val 1

reverse an inductive tuple

>>> pz @ReverseITuple (1.4,(1,(2,(False,('x',())))))
Val ('x',(False,(2,(1,(1.4,())))))

create inductive tuples from a list of the exact size n

>>> pz @(ToITupleList 4 >> EachITuple Succ) ['a','c','y','B']
Val ('b',('d',('z',('C',()))))

>>> pz @(ToITupleList 4) ['a','c','y','B']
Val ('a',('c',('y',('B',()))))

>>> pz @(Take 10 Id >> ToITupleList 10) ['a'..'z']
Val ('a',('b',('c',('d',('e',('f',('g',('h',('i',('j',()))))))))))

assoc using AssocC

>>> pz @Assoc (This (These 123 'x'))
Val (These 123 (This 'x'))

>>> pz @Assoc ((99,'a'),True)
Val (99,('a',True))

>>> pz @Assoc ((99,'a'),True)
Val (99,('a',True))

>>> pz @Assoc (Right "Abc" :: Either (Either () ()) String)
Val (Right (Right "Abc"))

>>> pz @Assoc (Left (Left 'x'))
Val (Left 'x')

>>> pl @Assoc ((10,'c'),True)
Present (10,('c',True)) (Assoc (10,('c',True)) | ((10,'c'),True))
Val (10,('c',True))

>>> pl @(Assoc >> Unassoc) ((10,'c'),True)
Present ((10,'c'),True) ((>>) ((10,'c'),True) | {Unassoc ((10,'c'),True) | (10,('c',True))})
Val ((10,'c'),True)

unassoc using AssocC

>>> pz @Unassoc (These 123 (This 'x'))
Val (This (These 123 'x'))

>>> pz @Unassoc (99,('a',True))
Val ((99,'a'),True)

>>> pz @Unassoc (This 10 :: These Int (These Bool ()))
Val (This (This 10))

>>> pz @Unassoc (Right (Right 123))
Val (Right 123)

>>> pz @Unassoc (Left 'x' :: Either Char (Either Bool Double))
Val (Left (Left 'x'))

>>> pl @Unassoc (10,('c',True))
Present ((10,'c'),True) (Unassoc ((10,'c'),True) | (10,('c',True)))
Val ((10,'c'),True)