Generics.Putlenses.Examples.Examples

Collection of put-based programming examples

Lists

mapPut :: Eq a => Putlens st e b a -> Putlens st e [b] [a]

unfoldrPut :: (Eq a, Eq b) => Putlens st e (b, a) a -> a -> Putlens st e [b] a

unfoldrSPut :: (Eq a, Eq b) => Putlens st e (b, a) a -> a -> Putlens st e [b] a

Constructor/destructor putlenses for lists

nilPut :: Putlens st e [a] ()

consPut :: Putlens st e [a] (a, [a])

unnilPut :: Putlens st e () [a]

unconsPut :: Putlens st e (a, [a]) [a]

unheadPut :: Eq a => Putlens st e [a] a

untailPut :: Eq a => Putlens st e [a] [a]

wrapPut :: Eq a => Putlens st e [a] a

unwrapPut :: Eq a => Putlens st e a [a]

example of automatically deriving constructor/destructor putlenses for binary trees

data Tree a

Constructors

Empty

Node a (Tree a) (Tree a)

Instances

Generic (Tree a)

unnodePut :: forall st e a. Putlens st e (a, (Tree a, Tree a)) (Tree a)

nodePut :: forall st e a. Putlens st e (Tree a) (a, (Tree a, Tree a))

unemptyPut :: forall st e a. Putlens st e () (Tree a)

emptyPut :: forall st e a. Putlens st e (Tree a) ()

List concatenation

catPut :: Eq a => Putlens st e ([a], [a]) [a]

List concatenation (positional)

exCatPut1 :: [Integer]

exCatPut2 :: ([Integer], [Integer])

exCatPut3 :: ([Integer], [Integer])

exCatPut4 :: ([Integer], [Integer])

catPutN :: Eq a => (Maybe ([a], [a]) -> [a] -> Int) -> Putlens st e ([a], [a]) [a]

List concatenation (split the view list at position n-1)

catPutN' :: Eq a => Putlens Int e ([a], [a]) [a]

catPut2 :: Putlens st e ([Integer], [Integer]) [Integer]

List concatenation (split the view list in half)

exCatPut21 :: [Integer]

exCatPut22 :: ([Integer], [Integer])

exCatPut23 :: ([Integer], [Integer])

exCatPut24 :: ([Integer], [Integer])

catPutP :: Eq a => (e -> a -> Bool) -> Putlens st e ([a], [a]) [a]

List concatenation (puts elements to the left while satisfying a predicate)

catPutSame :: Eq a => Putlens st e ([a], [a]) [a]

List concatenation (puts elements to the left while being equal)

exCatPutSame1 :: [Integer]

exCatPutSame2 :: ([Integer], [Integer])

exCatPutSame3 :: ([Integer], [Integer])

catPutPred :: Ord a => a -> Putlens st e ([a], [a]) [a]

List concatenation (puts elements to the left while smaller than a particular value)

exCatPutPred1 :: [Integer]

exCatPutPred2 :: ([Integer], [Integer])

exCatPutPred3 :: ([Integer], [Integer])

exCatPutPred4 :: ([Integer], [Integer])

Integers

succPut :: Putlens st e Int Int

predPut :: Putlens st e Int Int

Naturals

data Nat

Constructors

ZeroN

SuccN Nat

Instances

Eq Nat

Show Nat

Generic Nat

unsuccNPut :: forall st e. Putlens st e Nat Nat

succNPut :: forall st e. Putlens st e Nat Nat

unzeroNPut :: forall st e. Putlens st e () Nat

zeroNPut :: forall st e. Putlens st e Nat ()

natPut :: Putlens st e Nat Int

int :: Nat -> Int

nat :: Int -> Nat

List length

lengthNatPut :: Eq a => (Int -> a) -> Putlens st e [a] Nat

Length as a natural number

exLengthNatPut1 :: Nat

exLengthNatPut2 :: [Char]

exLengthNatPut3 :: [Char]

List lookup

embedAtPut :: Eq a => Int -> Putlens st e [a] a

Embeds a value at a fixed position in a list

embedAtPut' :: Eq a => Putlens st e (Int, [a]) a

embedAtPut1 :: Eq a => Int -> Putlens st e [a] a

Embeds a value at a fixed position in a list (supports extending the length original list)

embedAtPut1' :: Eq a => Putlens st e (Int, [a]) a

exEmbedAtPut1 :: Char

exEmbedAtPut2 :: [Char]

exEmbedAtPut3 :: [Char]

exEmbedAtPut4 :: Char

exEmbedAtPut5 :: [Char]

embedAtPut2 :: Eq a => Int -> Putlens st e [a] a

Embeds a value at a fixed position in a list (splitAt approach)

splitAtPut :: Eq a => Putlens st e (Int, [a]) ([a], [a])

exEmbedAtPut21 :: Char

exEmbedAtPut22 :: [Char]

exEmbedAtPut23 :: [Char]

List summation

splitPut :: Integral a => (st -> a -> a -> a) -> Putlens st e (a, a) a

Splits a view number into two summands (by adding an offset to the original first value)

summandsPut1 :: Integral a => Putlens st e [a] a

Updates the sum of a list (preserves the original source and appends the difference to the end)

summandsPut2 :: Integral a => Putlens st e [a] a

Updates the sum of a list (distributes the difference by dividing it by two at each recursive step) half of the difference is added to the first element of the source, a quarter to the second, and so on until the remainder is 0

summandsPut3 :: Integral a => Putlens st e [a] a

Updates the sum of a list (distributes the difference by dividing it by the length of the original list) distributes the difference evenly among original list numbers

summandsPut3' :: Integral a => Putlens a e [a] a

summandsPut4 :: Integral a => Putlens st e [a] a

Updates the sum of a list (distributes the difference by dividing it by the length of the original list, always preserving the size f the original list even when the view is zero)

summandsPut4' :: Integral a => Putlens a e [a] a

exSummandsPut1 :: Integer

exSummandsPut2 :: [Integer]

exSummandsPut3 :: [Integer]

exSummandsPut4 :: [Integer]

exSummandsPut5 :: [Integer]

exSummandsPut6 :: [Integer]

exSummandsPut7 :: [Integer]

Replicate

replicatePut :: Eq a => Putlens st e (a, Int) [a]

Replicate

exReplicatePut1 :: (Char, Int)

exReplicatePut2 :: (Char, Int)

replicateListPut :: Eq a => Putlens st e [(a, Int)] [a]

Replicates a list of elements into a sequence of replicated elements

recoverzerosPut :: Eq a => Putlens st e [(a, Int)] [(a, Int)]

splitListPut :: Eq a => Putlens st e [[a]] [a]

exReplicateListPut1 :: [Char]

exReplicateListPut2 :: [(Char, Int)]

Halve

halvePut :: Eq a => a -> Putlens st e [a] [a]

Takes the first half of a list (with a default empty element)

exHalvePut1 :: [Char]

exHalvePut2 :: [Char]

halvePut2 :: Eq a => a -> Putlens st e [a] [a]

Takes the first half of a list (using an increasing counter with each consumed element in the forward direction)

halvePut2' :: Eq a => a -> Putlens st e ([a], Int) ([a], Int)

exHalvePut21 :: [Char]

exHalvePut22 :: [Char]

exHalvePut23 :: [Char]

halvePut3 :: Eq a => a -> Putlens st e [a] [a]

Takes the first half of a list (using a decreasing counter with the size of the input list, decreased 2 by 2, in the forward direction)

halvePut3' :: Eq a => a -> Putlens Int e ([a], Int) [a]

exHalvePut31 :: [Char]

exHalvePut32 :: [Char]

exHalvePut33 :: [Char]

isumPut :: Putlens st e [Int] [Int]

Incremental summation

subtractPut :: Int -> Putlens st e Int Int

exIsumPut1 :: [Int]

exIsumPut2 :: [Int]

Sorting

iunsortPut1 :: Ord a => Putlens st e [a] [a]

Insertion sort (put according to the original relative source order)

delPut1 :: Ord a => Putlens st e (a, [a]) [a]

iunsortPut2 :: Ord a => Putlens st e [a] [a]

Insertion sort (identity backward transformation)

delPut2 :: Ord a => Putlens st e (a, [a]) [a]

exIunsortPut1 :: [Integer]

exIunsortPut2 :: [Integer]

exIunsortPut3 :: [Integer]

qsortPut :: Ord a => Putlens st e [a] [a]

Quicksort (put according to the original relative source order)

partitionPut :: Ord a => Putlens st e (a, [a]) (a, ([a], [a]))

Partition a list into smaller and bigger elements than a given element

catPutNonEmptyRight :: Eq a => Putlens st e ([a], [a]) [a]

exQsortPut1 :: [Integer]

exQsortPut2 :: [Integer]

exQsortPut3 :: [Integer]

Maximum segment sum

type Pos = Int

segments :: [a] -> [[a]]

mssPut :: Putlens st e [Int] Int

Updating maximum segment sum when the sum increases, update only the largest segment when the sum decreases, update all segments that surpass the new maximum, from smallest to largest

mssPut' :: Bool -> Putlens st e [Int] Int

positionsPut :: Eq a => Putlens st e [a] [(Pos, a)]

positionsPut' :: Eq a => Putlens st [(Pos, a)] (Int, [a]) [(Pos, a)]

maxSumSegsPut :: Putlens st e (Map Pos Int, [[Pos]]) Int

maxSumSegsPut' :: Putlens Bool e (Map Int Int, [[Pos]]) Int

lookupSegPut :: Eq a => Putlens st e (Map Int a, [Int]) [a]

lookupIntMapPut :: Eq a => Putlens st e (Int, Map Int a) a

maxPut :: (Num a, Ord a) => Putlens Bool e (a, a) a

fromListPut :: (Eq a, Ord k) => Putlens st e [(k, a)] (Map k a)

toListPut :: (Eq a, Ord k) => Putlens st e (Map k a) [(k, a)]

exMssPut1 :: Int

exMssPut2 :: [Int]

exMssPut3 :: [Int]

exMssPut4 :: [Int]

exMssPut5 :: [Int]