Q4C12.TwoFinger.Internal

This is an internal module and not subject to the PVP. It may receive arbitrary changes at any time and between any two releases. Import from Q4C12.TwoFinger instead, unless you really need the gory details, and, in that case, you must depend on the exact version of this package. (If you do need them, please file a bug so that, hopefully, your use-case can be accomplished through the public interface.)

Documentation

>>> import Data.List (unfoldr)
>>> import Data.Tuple (swap)
>>> import Control.Lens (over, view)
>>> let hush = either (const Nothing) Just

(<.*>) :: Apply f => f (a -> b) -> MaybeApply f a -> f b infixl 4

(<*.>) :: Apply f => MaybeApply f (a -> b) -> f a -> f b infixl 4

traverseDefault :: (Applicative f, Traversable1 t) => (a -> f a') -> t a -> f (t a')

bitraverseDefault :: (Applicative f, Bitraversable1 t) => (a -> f a') -> (b -> f b') -> t a b -> f (t a' b')

Types, EqN?/ShowN?/(Bi)Functor/Foldable1?/Traversable1?

data Digit e a

Constructors

One e

Two e a e

Three e a e a e

Four e a e a e a e

Instances

Bitraversable Digit

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Digit a b -> f (Digit c d)

Bifoldable Digit

Methods

bifold :: Monoid m => Digit m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Digit a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Digit a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Digit a b -> c

Bifunctor Digit

Methods

bimap :: (a -> b) -> (c -> d) -> Digit a c -> Digit b d

first :: (a -> b) -> Digit a c -> Digit b c

second :: (b -> c) -> Digit a b -> Digit a c

Bitraversable1 Digit

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Digit a c -> f (Digit b d)

bisequence1 :: Apply f => Digit (f a) (f b) -> f (Digit a b)

Bifoldable1 Digit

Methods

bifold1 :: Semigroup m => Digit m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Digit a b -> m

Functor (Digit e)

Methods

fmap :: (a -> b) -> Digit e a -> Digit e b

(<$) :: a -> Digit e b -> Digit e a

Foldable (Digit e)

Methods

fold :: Monoid m => Digit e m -> m

foldMap :: Monoid m => (a -> m) -> Digit e a -> m

foldr :: (a -> b -> b) -> b -> Digit e a -> b

foldr' :: (a -> b -> b) -> b -> Digit e a -> b

foldl :: (b -> a -> b) -> b -> Digit e a -> b

foldl' :: (b -> a -> b) -> b -> Digit e a -> b

foldr1 :: (a -> a -> a) -> Digit e a -> a

foldl1 :: (a -> a -> a) -> Digit e a -> a

toList :: Digit e a -> [a]

null :: Digit e a -> Bool

length :: Digit e a -> Int

elem :: Eq a => a -> Digit e a -> Bool

maximum :: Ord a => Digit e a -> a

minimum :: Ord a => Digit e a -> a

sum :: Num a => Digit e a -> a

product :: Num a => Digit e a -> a

Traversable (Digit e)

Methods

traverse :: Applicative f => (a -> f b) -> Digit e a -> f (Digit e b)

sequenceA :: Applicative f => Digit e (f a) -> f (Digit e a)

mapM :: Monad m => (a -> m b) -> Digit e a -> m (Digit e b)

sequence :: Monad m => Digit e (m a) -> m (Digit e a)

Generic (Digit e a)

Associated Types

type Rep (Digit e a) :: * -> *

Methods

from :: Digit e a -> Rep (Digit e a) x

to :: Rep (Digit e a) x -> Digit e a

(NFData e, NFData a) => NFData (Digit e a)

Methods

rnf :: Digit e a -> ()

type Rep (Digit e a)

type Rep (Digit e a) = D1 * (MetaData "Digit" "Q4C12.TwoFinger.Internal" "q4c12-twofinger-0.1-LtmMPcE2VTZ6fQZs4pmxNw" False) ((:+:) * ((:+:) * (C1 * (MetaCons "One" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e))) (C1 * (MetaCons "Two" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)))))) ((:+:) * (C1 * (MetaCons "Three" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)))))) (C1 * (MetaCons "Four" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)))) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e))))))))

data Node e a

Constructors

Node2 e a e

Node3 e a e a e

Instances

Bitraversable Node

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Node a b -> f (Node c d)

Bifoldable Node

Methods

bifold :: Monoid m => Node m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Node a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Node a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Node a b -> c

Bifunctor Node

Methods

bimap :: (a -> b) -> (c -> d) -> Node a c -> Node b d

first :: (a -> b) -> Node a c -> Node b c

second :: (b -> c) -> Node a b -> Node a c

Bitraversable1 Node

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Node a c -> f (Node b d)

bisequence1 :: Apply f => Node (f a) (f b) -> f (Node a b)

Bifoldable1 Node

Methods

bifold1 :: Semigroup m => Node m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Node a b -> m

Functor (Node e)

Methods

fmap :: (a -> b) -> Node e a -> Node e b

(<$) :: a -> Node e b -> Node e a

Foldable (Node e)

Methods

fold :: Monoid m => Node e m -> m

foldMap :: Monoid m => (a -> m) -> Node e a -> m

foldr :: (a -> b -> b) -> b -> Node e a -> b

foldr' :: (a -> b -> b) -> b -> Node e a -> b

foldl :: (b -> a -> b) -> b -> Node e a -> b

foldl' :: (b -> a -> b) -> b -> Node e a -> b

foldr1 :: (a -> a -> a) -> Node e a -> a

foldl1 :: (a -> a -> a) -> Node e a -> a

toList :: Node e a -> [a]

null :: Node e a -> Bool

length :: Node e a -> Int

elem :: Eq a => a -> Node e a -> Bool

maximum :: Ord a => Node e a -> a

minimum :: Ord a => Node e a -> a

sum :: Num a => Node e a -> a

product :: Num a => Node e a -> a

Traversable (Node e)

Methods

traverse :: Applicative f => (a -> f b) -> Node e a -> f (Node e b)

sequenceA :: Applicative f => Node e (f a) -> f (Node e a)

mapM :: Monad m => (a -> m b) -> Node e a -> m (Node e b)

sequence :: Monad m => Node e (m a) -> m (Node e a)

Traversable1 (Node e)

Methods

traverse1 :: Apply f => (a -> f b) -> Node e a -> f (Node e b)

sequence1 :: Apply f => Node e (f b) -> f (Node e b)

Foldable1 (Node e)

Methods

fold1 :: Semigroup m => Node e m -> m

foldMap1 :: Semigroup m => (a -> m) -> Node e a -> m

toNonEmpty :: Node e a -> NonEmpty a

(Eq a, Eq e) => Eq (Node e a)

Methods

(==) :: Node e a -> Node e a -> Bool

(/=) :: Node e a -> Node e a -> Bool

Generic (Node e a)

Associated Types

type Rep (Node e a) :: * -> *

Methods

from :: Node e a -> Rep (Node e a) x

to :: Rep (Node e a) x -> Node e a

(NFData e, NFData a) => NFData (Node e a)

Methods

rnf :: Node e a -> ()

type Rep (Node e a)

type Rep (Node e a) = D1 * (MetaData "Node" "Q4C12.TwoFinger.Internal" "q4c12-twofinger-0.1-LtmMPcE2VTZ6fQZs4pmxNw" False) ((:+:) * (C1 * (MetaCons "Node2" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e))))) (C1 * (MetaCons "Node3" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)))))))

data TwoFingerOddA e a

Isomorphic to a, (e, a)*

Constructors

EmptyOddA a

SingleOddA a e a

DeepOddA a !(Digit e a) (TwoFingerOddA (Node e a) a) !(Digit e a) a

Instances

Bitraversable TwoFingerOddA

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> TwoFingerOddA a b -> f (TwoFingerOddA c d)

Bifoldable TwoFingerOddA

Methods

bifold :: Monoid m => TwoFingerOddA m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> TwoFingerOddA a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> TwoFingerOddA a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> TwoFingerOddA a b -> c

Bifunctor TwoFingerOddA

Methods

bimap :: (a -> b) -> (c -> d) -> TwoFingerOddA a c -> TwoFingerOddA b d

first :: (a -> b) -> TwoFingerOddA a c -> TwoFingerOddA b c

second :: (b -> c) -> TwoFingerOddA a b -> TwoFingerOddA a c

Eq2 TwoFingerOddA

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> TwoFingerOddA a c -> TwoFingerOddA b d -> Bool

Show2 TwoFingerOddA

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> TwoFingerOddA a b -> ShowS

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [TwoFingerOddA a b] -> ShowS

Bitraversable1 TwoFingerOddA

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> TwoFingerOddA a c -> f (TwoFingerOddA b d)

bisequence1 :: Apply f => TwoFingerOddA (f a) (f b) -> f (TwoFingerOddA a b)

Bifoldable1 TwoFingerOddA

Methods

bifold1 :: Semigroup m => TwoFingerOddA m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> TwoFingerOddA a b -> m

Monad (TwoFingerOddA e)

Methods

(>>=) :: TwoFingerOddA e a -> (a -> TwoFingerOddA e b) -> TwoFingerOddA e b

(>>) :: TwoFingerOddA e a -> TwoFingerOddA e b -> TwoFingerOddA e b

return :: a -> TwoFingerOddA e a

fail :: String -> TwoFingerOddA e a

Functor (TwoFingerOddA e)

Methods

fmap :: (a -> b) -> TwoFingerOddA e a -> TwoFingerOddA e b

(<$) :: a -> TwoFingerOddA e b -> TwoFingerOddA e a

Applicative (TwoFingerOddA e)

A 'producty' instance:

>>> (,) <$> (consOddA 1 "one" $ consOddA 2 "two" $ singletonOddA 3) <*> (consOddA 'a' "foo" $ singletonOddA 'b')
consOddA (1,'a') "foo" (consOddA (1,'b') "one" (consOddA (2,'a') "foo" (consOddA (2,'b') "two" (consOddA (3,'a') "foo" (singletonOddA (3,'b'))))))

Methods

pure :: a -> TwoFingerOddA e a

(<*>) :: TwoFingerOddA e (a -> b) -> TwoFingerOddA e a -> TwoFingerOddA e b

liftA2 :: (a -> b -> c) -> TwoFingerOddA e a -> TwoFingerOddA e b -> TwoFingerOddA e c

(*>) :: TwoFingerOddA e a -> TwoFingerOddA e b -> TwoFingerOddA e b

(<*) :: TwoFingerOddA e a -> TwoFingerOddA e b -> TwoFingerOddA e a

Foldable (TwoFingerOddA e)

Methods

fold :: Monoid m => TwoFingerOddA e m -> m

foldMap :: Monoid m => (a -> m) -> TwoFingerOddA e a -> m

foldr :: (a -> b -> b) -> b -> TwoFingerOddA e a -> b

foldr' :: (a -> b -> b) -> b -> TwoFingerOddA e a -> b

foldl :: (b -> a -> b) -> b -> TwoFingerOddA e a -> b

foldl' :: (b -> a -> b) -> b -> TwoFingerOddA e a -> b

foldr1 :: (a -> a -> a) -> TwoFingerOddA e a -> a

foldl1 :: (a -> a -> a) -> TwoFingerOddA e a -> a

toList :: TwoFingerOddA e a -> [a]

null :: TwoFingerOddA e a -> Bool

length :: TwoFingerOddA e a -> Int

elem :: Eq a => a -> TwoFingerOddA e a -> Bool

maximum :: Ord a => TwoFingerOddA e a -> a

minimum :: Ord a => TwoFingerOddA e a -> a

sum :: Num a => TwoFingerOddA e a -> a

product :: Num a => TwoFingerOddA e a -> a

Traversable (TwoFingerOddA e)

Methods

traverse :: Applicative f => (a -> f b) -> TwoFingerOddA e a -> f (TwoFingerOddA e b)

sequenceA :: Applicative f => TwoFingerOddA e (f a) -> f (TwoFingerOddA e a)

mapM :: Monad m => (a -> m b) -> TwoFingerOddA e a -> m (TwoFingerOddA e b)

sequence :: Monad m => TwoFingerOddA e (m a) -> m (TwoFingerOddA e a)

Eq e => Eq1 (TwoFingerOddA e)

Methods

liftEq :: (a -> b -> Bool) -> TwoFingerOddA e a -> TwoFingerOddA e b -> Bool

Show e => Show1 (TwoFingerOddA e)

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> TwoFingerOddA e a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [TwoFingerOddA e a] -> ShowS

Traversable1 (TwoFingerOddA e)

Methods

traverse1 :: Apply f => (a -> f b) -> TwoFingerOddA e a -> f (TwoFingerOddA e b)

sequence1 :: Apply f => TwoFingerOddA e (f b) -> f (TwoFingerOddA e b)

Foldable1 (TwoFingerOddA e)

Methods

fold1 :: Semigroup m => TwoFingerOddA e m -> m

foldMap1 :: Semigroup m => (a -> m) -> TwoFingerOddA e a -> m

toNonEmpty :: TwoFingerOddA e a -> NonEmpty a

Apply (TwoFingerOddA e)

Methods

(<.>) :: TwoFingerOddA e (a -> b) -> TwoFingerOddA e a -> TwoFingerOddA e b

(.>) :: TwoFingerOddA e a -> TwoFingerOddA e b -> TwoFingerOddA e b

(<.) :: TwoFingerOddA e a -> TwoFingerOddA e b -> TwoFingerOddA e a

Bind (TwoFingerOddA e)

Methods

(>>-) :: TwoFingerOddA e a -> (a -> TwoFingerOddA e b) -> TwoFingerOddA e b

join :: TwoFingerOddA e (TwoFingerOddA e a) -> TwoFingerOddA e a

(Eq e, Eq a) => Eq (TwoFingerOddA e a)

Methods

(==) :: TwoFingerOddA e a -> TwoFingerOddA e a -> Bool

(/=) :: TwoFingerOddA e a -> TwoFingerOddA e a -> Bool

(Show e, Show a) => Show (TwoFingerOddA e a)

Methods

showsPrec :: Int -> TwoFingerOddA e a -> ShowS

show :: TwoFingerOddA e a -> String

showList :: [TwoFingerOddA e a] -> ShowS

Generic (TwoFingerOddA e a)

Associated Types

type Rep (TwoFingerOddA e a) :: * -> *

Methods

from :: TwoFingerOddA e a -> Rep (TwoFingerOddA e a) x

to :: Rep (TwoFingerOddA e a) x -> TwoFingerOddA e a

Semigroup a => Semigroup (TwoFingerOddA e a)

Methods

(<>) :: TwoFingerOddA e a -> TwoFingerOddA e a -> TwoFingerOddA e a

sconcat :: NonEmpty (TwoFingerOddA e a) -> TwoFingerOddA e a

stimes :: Integral b => b -> TwoFingerOddA e a -> TwoFingerOddA e a

(Monoid a, Semigroup a) => Monoid (TwoFingerOddA e a)

Methods

mempty :: TwoFingerOddA e a

mappend :: TwoFingerOddA e a -> TwoFingerOddA e a -> TwoFingerOddA e a

mconcat :: [TwoFingerOddA e a] -> TwoFingerOddA e a

(NFData e, NFData a) => NFData (TwoFingerOddA e a)

Methods

rnf :: TwoFingerOddA e a -> ()

type Rep (TwoFingerOddA e a)

type Rep (TwoFingerOddA e a) = D1 * (MetaData "TwoFingerOddA" "Q4C12.TwoFinger.Internal" "q4c12-twofinger-0.1-LtmMPcE2VTZ6fQZs4pmxNw" False) ((:+:) * (C1 * (MetaCons "EmptyOddA" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))) ((:+:) * (C1 * (MetaCons "SingleOddA" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))))) (C1 * (MetaCons "DeepOddA" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Digit e a)))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (TwoFingerOddA (Node e a) a))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Digit e a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))))))))

firstOddA :: Functor f => (a -> f a) -> TwoFingerOddA e a -> f (TwoFingerOddA e a)

Access the first a of a TwoFingerOddA e a. \(O(1)\). This type is Lens' (TwoFingerOddA e a) a in disguise.

>>> view firstOddA (consOddA 3 True $ singletonOddA 15)
3

lastOddA :: Functor f => (a -> f a) -> TwoFingerOddA e a -> f (TwoFingerOddA e a)

Access the last a of a TwoFingerOddA e a. \(O(1)\). This type is Lens' (TwoFingerOddA e a) a in disguise.

>>> over lastOddA (+ 5) (consOddA 3 True $ singletonOddA 15)
consOddA 3 True (singletonOddA 20)

data TwoFingerOddE e a

Isomorphic to e, (a, e)*

Constructors

SingleOddE e

DeepOddE !(Digit e a) (TwoFingerOddA (Node e a) a) !(Digit e a)

Instances

Bitraversable TwoFingerOddE

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> TwoFingerOddE a b -> f (TwoFingerOddE c d)

Bifoldable TwoFingerOddE

Methods

bifold :: Monoid m => TwoFingerOddE m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> TwoFingerOddE a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> TwoFingerOddE a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> TwoFingerOddE a b -> c

Bifunctor TwoFingerOddE

Methods

bimap :: (a -> b) -> (c -> d) -> TwoFingerOddE a c -> TwoFingerOddE b d

first :: (a -> b) -> TwoFingerOddE a c -> TwoFingerOddE b c

second :: (b -> c) -> TwoFingerOddE a b -> TwoFingerOddE a c

Eq2 TwoFingerOddE

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> TwoFingerOddE a c -> TwoFingerOddE b d -> Bool

Show2 TwoFingerOddE

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> TwoFingerOddE a b -> ShowS

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [TwoFingerOddE a b] -> ShowS

Functor (TwoFingerOddE e)

Methods

fmap :: (a -> b) -> TwoFingerOddE e a -> TwoFingerOddE e b

(<$) :: a -> TwoFingerOddE e b -> TwoFingerOddE e a

Foldable (TwoFingerOddE e)

Methods

fold :: Monoid m => TwoFingerOddE e m -> m

foldMap :: Monoid m => (a -> m) -> TwoFingerOddE e a -> m

foldr :: (a -> b -> b) -> b -> TwoFingerOddE e a -> b

foldr' :: (a -> b -> b) -> b -> TwoFingerOddE e a -> b

foldl :: (b -> a -> b) -> b -> TwoFingerOddE e a -> b

foldl' :: (b -> a -> b) -> b -> TwoFingerOddE e a -> b

foldr1 :: (a -> a -> a) -> TwoFingerOddE e a -> a

foldl1 :: (a -> a -> a) -> TwoFingerOddE e a -> a

toList :: TwoFingerOddE e a -> [a]

null :: TwoFingerOddE e a -> Bool

length :: TwoFingerOddE e a -> Int

elem :: Eq a => a -> TwoFingerOddE e a -> Bool

maximum :: Ord a => TwoFingerOddE e a -> a

minimum :: Ord a => TwoFingerOddE e a -> a

sum :: Num a => TwoFingerOddE e a -> a

product :: Num a => TwoFingerOddE e a -> a

Traversable (TwoFingerOddE e)

Methods

traverse :: Applicative f => (a -> f b) -> TwoFingerOddE e a -> f (TwoFingerOddE e b)

sequenceA :: Applicative f => TwoFingerOddE e (f a) -> f (TwoFingerOddE e a)

mapM :: Monad m => (a -> m b) -> TwoFingerOddE e a -> m (TwoFingerOddE e b)

sequence :: Monad m => TwoFingerOddE e (m a) -> m (TwoFingerOddE e a)

Eq e => Eq1 (TwoFingerOddE e)

Methods

liftEq :: (a -> b -> Bool) -> TwoFingerOddE e a -> TwoFingerOddE e b -> Bool

Show e => Show1 (TwoFingerOddE e)

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> TwoFingerOddE e a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [TwoFingerOddE e a] -> ShowS

(Eq e, Eq a) => Eq (TwoFingerOddE e a)

Methods

(==) :: TwoFingerOddE e a -> TwoFingerOddE e a -> Bool

(/=) :: TwoFingerOddE e a -> TwoFingerOddE e a -> Bool

(Show e, Show a) => Show (TwoFingerOddE e a)

Methods

showsPrec :: Int -> TwoFingerOddE e a -> ShowS

show :: TwoFingerOddE e a -> String

showList :: [TwoFingerOddE e a] -> ShowS

Generic (TwoFingerOddE e a)

Associated Types

type Rep (TwoFingerOddE e a) :: * -> *

Methods

from :: TwoFingerOddE e a -> Rep (TwoFingerOddE e a) x

to :: Rep (TwoFingerOddE e a) x -> TwoFingerOddE e a

(NFData e, NFData a) => NFData (TwoFingerOddE e a)

Methods

rnf :: TwoFingerOddE e a -> ()

type Rep (TwoFingerOddE e a)

type Rep (TwoFingerOddE e a) = D1 * (MetaData "TwoFingerOddE" "Q4C12.TwoFinger.Internal" "q4c12-twofinger-0.1-LtmMPcE2VTZ6fQZs4pmxNw" False) ((:+:) * (C1 * (MetaCons "SingleOddE" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e))) (C1 * (MetaCons "DeepOddE" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Digit e a))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (TwoFingerOddA (Node e a) a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Digit e a)))))))

data TwoFingerEvenE e a

Isomorphic to (e, a)*

Constructors

EmptyEvenE

SingleEvenE e a

DeepEvenE !(Digit e a) (TwoFingerOddA (Node e a) a) !(Digit e a) a

Instances

Bitraversable TwoFingerEvenE

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> TwoFingerEvenE a b -> f (TwoFingerEvenE c d)

Bifoldable TwoFingerEvenE

Methods

bifold :: Monoid m => TwoFingerEvenE m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> TwoFingerEvenE a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> TwoFingerEvenE a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> TwoFingerEvenE a b -> c

Bifunctor TwoFingerEvenE

Methods

bimap :: (a -> b) -> (c -> d) -> TwoFingerEvenE a c -> TwoFingerEvenE b d

first :: (a -> b) -> TwoFingerEvenE a c -> TwoFingerEvenE b c

second :: (b -> c) -> TwoFingerEvenE a b -> TwoFingerEvenE a c

Eq2 TwoFingerEvenE

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> TwoFingerEvenE a c -> TwoFingerEvenE b d -> Bool

Show2 TwoFingerEvenE

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> TwoFingerEvenE a b -> ShowS

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [TwoFingerEvenE a b] -> ShowS

Functor (TwoFingerEvenE e)

Methods

fmap :: (a -> b) -> TwoFingerEvenE e a -> TwoFingerEvenE e b

(<$) :: a -> TwoFingerEvenE e b -> TwoFingerEvenE e a

Foldable (TwoFingerEvenE e)

Methods

fold :: Monoid m => TwoFingerEvenE e m -> m

foldMap :: Monoid m => (a -> m) -> TwoFingerEvenE e a -> m

foldr :: (a -> b -> b) -> b -> TwoFingerEvenE e a -> b

foldr' :: (a -> b -> b) -> b -> TwoFingerEvenE e a -> b

foldl :: (b -> a -> b) -> b -> TwoFingerEvenE e a -> b

foldl' :: (b -> a -> b) -> b -> TwoFingerEvenE e a -> b

foldr1 :: (a -> a -> a) -> TwoFingerEvenE e a -> a

foldl1 :: (a -> a -> a) -> TwoFingerEvenE e a -> a

toList :: TwoFingerEvenE e a -> [a]

null :: TwoFingerEvenE e a -> Bool

length :: TwoFingerEvenE e a -> Int

elem :: Eq a => a -> TwoFingerEvenE e a -> Bool

maximum :: Ord a => TwoFingerEvenE e a -> a

minimum :: Ord a => TwoFingerEvenE e a -> a

sum :: Num a => TwoFingerEvenE e a -> a

product :: Num a => TwoFingerEvenE e a -> a

Traversable (TwoFingerEvenE e)

Methods

traverse :: Applicative f => (a -> f b) -> TwoFingerEvenE e a -> f (TwoFingerEvenE e b)

sequenceA :: Applicative f => TwoFingerEvenE e (f a) -> f (TwoFingerEvenE e a)

mapM :: Monad m => (a -> m b) -> TwoFingerEvenE e a -> m (TwoFingerEvenE e b)

sequence :: Monad m => TwoFingerEvenE e (m a) -> m (TwoFingerEvenE e a)

Eq e => Eq1 (TwoFingerEvenE e)

Methods

liftEq :: (a -> b -> Bool) -> TwoFingerEvenE e a -> TwoFingerEvenE e b -> Bool

Show e => Show1 (TwoFingerEvenE e)

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> TwoFingerEvenE e a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [TwoFingerEvenE e a] -> ShowS

Plus (TwoFingerEvenE e)

Methods

zero :: TwoFingerEvenE e a

Alt (TwoFingerEvenE e)

Methods

(<!>) :: TwoFingerEvenE e a -> TwoFingerEvenE e a -> TwoFingerEvenE e a

some :: Applicative (TwoFingerEvenE e) => TwoFingerEvenE e a -> TwoFingerEvenE e [a]

many :: Applicative (TwoFingerEvenE e) => TwoFingerEvenE e a -> TwoFingerEvenE e [a]

(Eq e, Eq a) => Eq (TwoFingerEvenE e a)

Methods

(==) :: TwoFingerEvenE e a -> TwoFingerEvenE e a -> Bool

(/=) :: TwoFingerEvenE e a -> TwoFingerEvenE e a -> Bool

(Show e, Show a) => Show (TwoFingerEvenE e a)

Methods

showsPrec :: Int -> TwoFingerEvenE e a -> ShowS

show :: TwoFingerEvenE e a -> String

showList :: [TwoFingerEvenE e a] -> ShowS

Generic (TwoFingerEvenE e a)

Associated Types

type Rep (TwoFingerEvenE e a) :: * -> *

Methods

from :: TwoFingerEvenE e a -> Rep (TwoFingerEvenE e a) x

to :: Rep (TwoFingerEvenE e a) x -> TwoFingerEvenE e a

Semigroup (TwoFingerEvenE e a)

Methods

(<>) :: TwoFingerEvenE e a -> TwoFingerEvenE e a -> TwoFingerEvenE e a

sconcat :: NonEmpty (TwoFingerEvenE e a) -> TwoFingerEvenE e a

stimes :: Integral b => b -> TwoFingerEvenE e a -> TwoFingerEvenE e a

Monoid (TwoFingerEvenE e a)

Methods

mempty :: TwoFingerEvenE e a

mappend :: TwoFingerEvenE e a -> TwoFingerEvenE e a -> TwoFingerEvenE e a

mconcat :: [TwoFingerEvenE e a] -> TwoFingerEvenE e a

(NFData e, NFData a) => NFData (TwoFingerEvenE e a)

Methods

rnf :: TwoFingerEvenE e a -> ()

type Rep (TwoFingerEvenE e a)

type Rep (TwoFingerEvenE e a) = D1 * (MetaData "TwoFingerEvenE" "Q4C12.TwoFinger.Internal" "q4c12-twofinger-0.1-LtmMPcE2VTZ6fQZs4pmxNw" False) ((:+:) * (C1 * (MetaCons "EmptyEvenE" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "SingleEvenE" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)))) (C1 * (MetaCons "DeepEvenE" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Digit e a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (TwoFingerOddA (Node e a) a)))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Digit e a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)))))))

data TwoFingerEvenA e a

Isomorphic to (a, e)*

Constructors

EmptyEvenA

SingleEvenA a e

DeepEvenA a !(Digit e a) (TwoFingerOddA (Node e a) a) !(Digit e a)

Instances

Bitraversable TwoFingerEvenA

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> TwoFingerEvenA a b -> f (TwoFingerEvenA c d)

Bifoldable TwoFingerEvenA

Methods

bifold :: Monoid m => TwoFingerEvenA m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> TwoFingerEvenA a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> TwoFingerEvenA a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> TwoFingerEvenA a b -> c

Bifunctor TwoFingerEvenA

Methods

bimap :: (a -> b) -> (c -> d) -> TwoFingerEvenA a c -> TwoFingerEvenA b d

first :: (a -> b) -> TwoFingerEvenA a c -> TwoFingerEvenA b c

second :: (b -> c) -> TwoFingerEvenA a b -> TwoFingerEvenA a c

Eq2 TwoFingerEvenA

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> TwoFingerEvenA a c -> TwoFingerEvenA b d -> Bool

Show2 TwoFingerEvenA

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> TwoFingerEvenA a b -> ShowS

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [TwoFingerEvenA a b] -> ShowS

Functor (TwoFingerEvenA e)

Methods

fmap :: (a -> b) -> TwoFingerEvenA e a -> TwoFingerEvenA e b

(<$) :: a -> TwoFingerEvenA e b -> TwoFingerEvenA e a

Foldable (TwoFingerEvenA e)

Methods

fold :: Monoid m => TwoFingerEvenA e m -> m

foldMap :: Monoid m => (a -> m) -> TwoFingerEvenA e a -> m

foldr :: (a -> b -> b) -> b -> TwoFingerEvenA e a -> b

foldr' :: (a -> b -> b) -> b -> TwoFingerEvenA e a -> b

foldl :: (b -> a -> b) -> b -> TwoFingerEvenA e a -> b

foldl' :: (b -> a -> b) -> b -> TwoFingerEvenA e a -> b

foldr1 :: (a -> a -> a) -> TwoFingerEvenA e a -> a

foldl1 :: (a -> a -> a) -> TwoFingerEvenA e a -> a

toList :: TwoFingerEvenA e a -> [a]

null :: TwoFingerEvenA e a -> Bool

length :: TwoFingerEvenA e a -> Int

elem :: Eq a => a -> TwoFingerEvenA e a -> Bool

maximum :: Ord a => TwoFingerEvenA e a -> a

minimum :: Ord a => TwoFingerEvenA e a -> a

sum :: Num a => TwoFingerEvenA e a -> a

product :: Num a => TwoFingerEvenA e a -> a

Traversable (TwoFingerEvenA e)

Methods

traverse :: Applicative f => (a -> f b) -> TwoFingerEvenA e a -> f (TwoFingerEvenA e b)

sequenceA :: Applicative f => TwoFingerEvenA e (f a) -> f (TwoFingerEvenA e a)

mapM :: Monad m => (a -> m b) -> TwoFingerEvenA e a -> m (TwoFingerEvenA e b)

sequence :: Monad m => TwoFingerEvenA e (m a) -> m (TwoFingerEvenA e a)

Eq e => Eq1 (TwoFingerEvenA e)

Methods

liftEq :: (a -> b -> Bool) -> TwoFingerEvenA e a -> TwoFingerEvenA e b -> Bool

Show e => Show1 (TwoFingerEvenA e)

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> TwoFingerEvenA e a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [TwoFingerEvenA e a] -> ShowS

Plus (TwoFingerEvenA e)

Methods

zero :: TwoFingerEvenA e a

Alt (TwoFingerEvenA e)

Methods

(<!>) :: TwoFingerEvenA e a -> TwoFingerEvenA e a -> TwoFingerEvenA e a

some :: Applicative (TwoFingerEvenA e) => TwoFingerEvenA e a -> TwoFingerEvenA e [a]

many :: Applicative (TwoFingerEvenA e) => TwoFingerEvenA e a -> TwoFingerEvenA e [a]

(Eq e, Eq a) => Eq (TwoFingerEvenA e a)

Methods

(==) :: TwoFingerEvenA e a -> TwoFingerEvenA e a -> Bool

(/=) :: TwoFingerEvenA e a -> TwoFingerEvenA e a -> Bool

(Show e, Show a) => Show (TwoFingerEvenA e a)

Methods

showsPrec :: Int -> TwoFingerEvenA e a -> ShowS

show :: TwoFingerEvenA e a -> String

showList :: [TwoFingerEvenA e a] -> ShowS

Generic (TwoFingerEvenA e a)

Associated Types

type Rep (TwoFingerEvenA e a) :: * -> *

Methods

from :: TwoFingerEvenA e a -> Rep (TwoFingerEvenA e a) x

to :: Rep (TwoFingerEvenA e a) x -> TwoFingerEvenA e a

Semigroup (TwoFingerEvenA e a)

Methods

(<>) :: TwoFingerEvenA e a -> TwoFingerEvenA e a -> TwoFingerEvenA e a

sconcat :: NonEmpty (TwoFingerEvenA e a) -> TwoFingerEvenA e a

stimes :: Integral b => b -> TwoFingerEvenA e a -> TwoFingerEvenA e a

Monoid (TwoFingerEvenA e a)

Methods

mempty :: TwoFingerEvenA e a

mappend :: TwoFingerEvenA e a -> TwoFingerEvenA e a -> TwoFingerEvenA e a

mconcat :: [TwoFingerEvenA e a] -> TwoFingerEvenA e a

(NFData e, NFData a) => NFData (TwoFingerEvenA e a)

Methods

rnf :: TwoFingerEvenA e a -> ()

type Rep (TwoFingerEvenA e a)

type Rep (TwoFingerEvenA e a) = D1 * (MetaData "TwoFingerEvenA" "Q4C12.TwoFinger.Internal" "q4c12-twofinger-0.1-LtmMPcE2VTZ6fQZs4pmxNw" False) ((:+:) * (C1 * (MetaCons "EmptyEvenA" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "SingleEvenA" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)))) (C1 * (MetaCons "DeepEvenA" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Digit e a)))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (TwoFingerOddA (Node e a) a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Digit e a))))))))

Digit operations.

digitToTree :: Digit e a -> TwoFingerOddE e a

digitCons :: e -> a -> Digit e a -> Either (Digit e a, a, Node e a) (Digit e a)

digitSnoc :: Digit e a -> a -> e -> Either (Node e a, a, Digit e a) (Digit e a)

digitUncons :: Digit e a -> (e, Maybe (a, Digit e a))

digitUnsnoc :: Digit e a -> (Maybe (Digit e a, a), e)

Node operations.

nodeToDigit :: Node e a -> Digit e a

Tree rotations

rotl :: TwoFingerOddA (Node e a) a -> Digit e a -> TwoFingerEvenA e a

rotr :: Digit e a -> TwoFingerOddA (Node e a) a -> TwoFingerEvenE e a

(Un)conses/snocs for TwoFingerOddA.

consOddA :: a -> e -> TwoFingerOddA e a -> TwoFingerOddA e a

snocOddA :: TwoFingerOddA e a -> e -> a -> TwoFingerOddA e a

unconsOddA :: TwoFingerOddA e a -> Either a ((a, e), TwoFingerOddA e a)

unsnocOddA :: TwoFingerOddA e a -> Either a (TwoFingerOddA e a, (e, a))

halfconsOddA :: e -> TwoFingerOddA e a -> TwoFingerEvenE e a

\(O(\log n)\) worst case. Inverse: halfunconsEvenE

halfsnocOddA :: TwoFingerOddA e a -> e -> TwoFingerEvenA e a

\(O(\log n)\) worst case. Inverse: halfunsnocEvenA

halfunconsOddA :: TwoFingerOddA e a -> (a, TwoFingerEvenE e a)

\(O(1)\) worst case. Inverse: halfconsEvenE

halfunsnocOddA :: TwoFingerOddA e a -> (TwoFingerEvenA e a, a)

\(O(1)\) worst case. Inverse: halfsnocOddA

(Un)conses/snocs for TwoFingerOddE.

consOddE :: e -> a -> TwoFingerOddE e a -> TwoFingerOddE e a

snocOddE :: TwoFingerOddE e a -> a -> e -> TwoFingerOddE e a

unconsOddE :: TwoFingerOddE e a -> Either e ((e, a), TwoFingerOddE e a)

unsnocOddE :: TwoFingerOddE e a -> Either e (TwoFingerOddE e a, (a, e))

halfconsOddE :: a -> TwoFingerOddE e a -> TwoFingerEvenA e a

\(O(1)\) worst case. Inverse: halfunconsEvenA

halfsnocOddE :: TwoFingerOddE e a -> a -> TwoFingerEvenE e a

\(O(1)\) worst case. Inverse: halfunsnocEvenE

halfunconsOddE :: TwoFingerOddE e a -> (e, TwoFingerEvenA e a)

\(O(\log n)\) worst case. Inverse: halfconsEvenA

halfunsnocOddE :: TwoFingerOddE e a -> (TwoFingerEvenE e a, e)

\(O(\log n)\) worst case. Inverse: halfsnocEvenE

(Un)conses/snocs for TwoFingerEvenE.

consEvenE :: e -> a -> TwoFingerEvenE e a -> TwoFingerEvenE e a

snocEvenE :: TwoFingerEvenE e a -> e -> a -> TwoFingerEvenE e a

unconsEvenE :: TwoFingerEvenE e a -> Maybe ((e, a), TwoFingerEvenE e a)

unsnocEvenE :: TwoFingerEvenE e a -> Maybe (TwoFingerEvenE e a, (e, a))

halfconsEvenE :: a -> TwoFingerEvenE e a -> TwoFingerOddA e a

\(O(1)\) worst case. Inverse: halfunconsOddA

halfsnocEvenE :: TwoFingerEvenE e a -> e -> TwoFingerOddE e a

\(O(\log n)\) worst case. Inverse: halfunsnocOddE.

halfunconsEvenE :: TwoFingerEvenE e a -> Maybe (e, TwoFingerOddA e a)

\(O(\log n)\) worst case. Inverse: halfconsOddA.

halfunsnocEvenE :: TwoFingerEvenE e a -> Maybe (TwoFingerOddE e a, a)

\(O(1)\) worst case. Inverse: halfsnocOddE.

(Un)conses/snocs for TwoFingerEvenA.

consEvenA :: a -> e -> TwoFingerEvenA e a -> TwoFingerEvenA e a

snocEvenA :: TwoFingerEvenA e a -> a -> e -> TwoFingerEvenA e a

unconsEvenA :: TwoFingerEvenA e a -> Maybe ((a, e), TwoFingerEvenA e a)

unsnocEvenA :: TwoFingerEvenA e a -> Maybe (TwoFingerEvenA e a, (a, e))

halfconsEvenA :: e -> TwoFingerEvenA e a -> TwoFingerOddE e a

\(O(\log n)\) worst case. Inverse: halfunconsOddE.

halfsnocEvenA :: TwoFingerEvenA e a -> a -> TwoFingerOddA e a

\(O(1)\) worst case. Inverse: halfunsnocOddA.

halfunconsEvenA :: TwoFingerEvenA e a -> Maybe (a, TwoFingerOddE e a)

\(O(1)\) worst case. Inverse: halfconsOddE.

halfunsnocEvenA :: TwoFingerEvenA e a -> Maybe (TwoFingerOddA e a, e)

\(O(\log n)\) worst case. Inverse: halfsnocOddA.

Monad and Applicative instances, and related operations

joinOddA :: TwoFingerOddA (TwoFingerOddE e a) (TwoFingerOddA e a) -> TwoFingerOddA e a

joinOddE :: TwoFingerOddE (TwoFingerOddE e a) (TwoFingerOddA e a) -> TwoFingerOddE e a

joinEvenA :: TwoFingerEvenA (TwoFingerOddE e a) (TwoFingerOddA e a) -> TwoFingerEvenA e a

joinEvenE :: TwoFingerEvenE (TwoFingerOddE e a) (TwoFingerOddA e a) -> TwoFingerEvenE e a

Construction and deconstruction of TwoFingerOddA.

singletonOddA :: a -> TwoFingerOddA e a

unitOddA :: (Monoid a, Semigroup a) => e -> TwoFingerOddA e a

Surrounds the argument with mempty.

>>> unitOddA 3 :: TwoFingerOddA Int String
consOddA "" 3 (singletonOddA "")

onlyOddA :: TwoFingerOddA e a -> Maybe a

>>> onlyOddA (singletonOddA "Hello!")
Just "Hello!"
>>> onlyOddA (consOddA True 3 $ singletonOddA False)
Nothing

interleavingOddA :: e -> NonEmpty a -> TwoFingerOddA e a

>>> interleavingOddA "sep" (3 :| [4, 5])
consOddA 3 "sep" (consOddA 4 "sep" (singletonOddA 5))

Construction of TwoFingerOddE

singletonOddE :: e -> TwoFingerOddE e a

Concatenation of TwoFingerOddA.

appendOddA0 :: Semigroup a => TwoFingerOddA e a -> TwoFingerOddA e a -> TwoFingerOddA e a

addDigits0 :: TwoFingerOddA (Node e a) a -> Digit e a -> a -> Digit e a -> TwoFingerOddA (Node e a) a -> TwoFingerOddA (Node e a) a

appendOddA1 :: TwoFingerOddA e a -> e -> TwoFingerOddA e a -> TwoFingerOddA e a

addDigits1 :: TwoFingerOddA (Node e a) a -> Digit e a -> a -> e -> a -> Digit e a -> TwoFingerOddA (Node e a) a -> TwoFingerOddA (Node e a) a

appendOddA2 :: TwoFingerOddA e a -> e -> a -> e -> TwoFingerOddA e a -> TwoFingerOddA e a

addDigits2 :: TwoFingerOddA (Node e a) a -> Digit e a -> a -> e -> a -> e -> a -> Digit e a -> TwoFingerOddA (Node e a) a -> TwoFingerOddA (Node e a) a

appendOddA3 :: TwoFingerOddA e a -> e -> a -> e -> a -> e -> TwoFingerOddA e a -> TwoFingerOddA e a

addDigits3 :: TwoFingerOddA (Node e a) a -> Digit e a -> a -> e -> a -> e -> a -> e -> a -> Digit e a -> TwoFingerOddA (Node e a) a -> TwoFingerOddA (Node e a) a

appendOddA4 :: TwoFingerOddA e a -> e -> a -> e -> a -> e -> a -> e -> TwoFingerOddA e a -> TwoFingerOddA e a

addDigits4 :: TwoFingerOddA (Node e a) a -> Digit e a -> a -> e -> a -> e -> a -> e -> a -> e -> a -> Digit e a -> TwoFingerOddA (Node e a) a -> TwoFingerOddA (Node e a) a

Concatenation of TwoFingerEvenE.

appendEvenE :: TwoFingerEvenE e a -> TwoFingerEvenE e a -> TwoFingerEvenE e a

Concatenation of TwoFingerEvenA.

appendEvenA :: TwoFingerEvenA e a -> TwoFingerEvenA e a -> TwoFingerEvenA e a

Monoid actions

appendOddAEvenE :: TwoFingerOddA e a -> TwoFingerEvenE e a -> TwoFingerOddA e a

appendEvenAOddA :: TwoFingerEvenA e a -> TwoFingerOddA e a -> TwoFingerOddA e a

appendOddAOddE :: TwoFingerOddA e a -> TwoFingerOddE e a -> TwoFingerEvenA e a

appendOddEOddA :: TwoFingerOddE e a -> TwoFingerOddA e a -> TwoFingerEvenE e a

appendOddEEvenA :: TwoFingerOddE e a -> TwoFingerEvenA e a -> TwoFingerOddE e a

appendEvenEOddE :: TwoFingerEvenE e a -> TwoFingerOddE e a -> TwoFingerOddE e a

Aligning/zipping.

alignLeftOddAOddA :: TwoFingerOddA e a -> TwoFingerOddA e' a' -> (TwoFingerOddA (e, e') (a, a'), Either (TwoFingerEvenE e a) (TwoFingerEvenE e' a'))

Align two TwoFingerOddA sequences elementwise, and return the excess remainder.

>>> alignLeftOddAOddA (consOddA 'a' 1 $ consOddA 'b' 2 $ singletonOddA 'c') (consOddA "foo" 10 $ singletonOddA "bar")
(consOddA ('a',"foo") (1,10) (singletonOddA ('b',"bar")),Left (consEvenE 2 'c' mempty))

>>> alignLeftOddAOddA (consOddA 'a' 1 $ singletonOddA 'b') (consOddA "foo" 10 $ consOddA "bar" 20 $ singletonOddA "baz")
(consOddA ('a',"foo") (1,10) (singletonOddA ('b',"bar")),Right (consEvenE 20 "baz" mempty))

alignLeftOddAEvenA :: TwoFingerOddA e a -> TwoFingerEvenA e' a' -> Either (TwoFingerEvenA (e, e') (a, a'), TwoFingerOddA e a) (TwoFingerOddA (e, e') (a, a'), TwoFingerOddE e' a')

>>> alignLeftOddAEvenA (consOddA 'a' 1 $ consOddA 'b' 2 $ singletonOddA 'c') (consEvenA "foo" 10 mempty)
Left (consEvenA ('a',"foo") (1,10) mempty,consOddA 'b' 2 (singletonOddA 'c'))

>>> alignLeftOddAEvenA (consOddA 'a' 1 $ singletonOddA 'b') (consEvenA "foo" 10 $ consEvenA "bar" 20 $ consEvenA "baz" 30 mempty)
Right (consOddA ('a',"foo") (1,10) (singletonOddA ('b',"bar")),consOddE 20 "baz" (singletonOddE 30))

alignLeftEvenAEvenA :: TwoFingerEvenA e a -> TwoFingerEvenA e' a' -> (TwoFingerEvenA (e, e') (a, a'), Either (TwoFingerEvenA e a) (TwoFingerEvenA e' a'))

alignLeftOddEOddE :: TwoFingerOddE e a -> TwoFingerOddE e' a' -> (TwoFingerOddE (e, e') (a, a'), Either (TwoFingerEvenA e a) (TwoFingerEvenA e' a'))

>>> alignLeftOddEOddE (consOddE 'a' 1 $ consOddE 'b' 2 $ singletonOddE 'c') (consOddE "foo" 10 $ singletonOddE "bar")
(consOddE ('a',"foo") (1,10) (singletonOddE ('b',"bar")),Left (consEvenA 2 'c' mempty))

>>> alignLeftOddEOddE (consOddE 'a' 1 $ singletonOddE 'b') (consOddE "foo" 10 $ consOddE "bar" 20 $ singletonOddE "baz")
(consOddE ('a',"foo") (1,10) (singletonOddE ('b',"bar")),Right (consEvenA 20 "baz" mempty))

alignLeftOddEEvenE :: TwoFingerOddE e a -> TwoFingerEvenE e' a' -> Either (TwoFingerEvenE (e, e') (a, a'), TwoFingerOddE e a) (TwoFingerOddE (e, e') (a, a'), TwoFingerOddA e' a')

alignLeftEvenEEvenE :: TwoFingerEvenE e a -> TwoFingerEvenE e' a' -> (TwoFingerEvenE (e, e') (a, a'), Either (TwoFingerEvenE e a) (TwoFingerEvenE e' a'))

Creating infinite sequences.

takeNodeLeft :: (Stream a -> es -> (e, Stream a, es)) -> Stream a -> es -> (Node e a, Stream a, es)

takeNodeRight :: (es -> Stream a -> (e, es, Stream a)) -> es -> Stream a -> (Node e a, es, Stream a)

takeSingleNodeLeft :: Stream a -> Stream e -> (Node e a, Stream a, Stream e)

takeSingleNodeRight :: Stream e -> Stream a -> (Node e a, Stream e, Stream a)

infiniteOddA' :: (Stream a -> Stream e -> (Node e' a, Stream a, Stream e)) -> (Stream e -> Stream a -> (Node e' a, Stream e, Stream a)) -> Stream a -> Stream e -> Stream e -> Stream a -> TwoFingerOddA e' a

repeatOddA :: a -> e -> TwoFingerOddA e a

Infinitely repeat the given a and e.

infiniteOddA :: Stream a -> Stream e -> Stream e -> Stream a -> TwoFingerOddA e a

From streams of leftward a, leftward e, rightward e and rightward a, build an infinite TwoFingerOddA.

>>> let infinite = infiniteOddA (Stream.iterate (+ 1) 0) (Stream.iterate (+ 1) 10) (Stream.iterate (+ 1) 20) (Stream.iterate (+ 1) 30)
>>> take 5 $ unfoldr (hush . unconsOddA) infinite
[(0,10),(1,11),(2,12),(3,13),(4,14)]
>>> take 5 $ unfoldr (fmap swap . hush . unsnocOddA) infinite
[(20,30),(21,31),(22,32),(23,33),(24,34)]

repeatOddE :: e -> a -> TwoFingerOddE e a

Infinitely repeat the given a and e.

infiniteOddE :: Stream e -> Stream a -> Stream a -> Stream e -> TwoFingerOddE e a

>>> let infinite = infiniteOddE (Stream.iterate (+ 1) 0) (Stream.iterate (+ 1) 10) (Stream.iterate (+ 1) 20) (Stream.iterate (+ 1) 30)
>>> take 5 $ unfoldr (hush . unconsOddE) infinite
[(0,10),(1,11),(2,12),(3,13),(4,14)]
>>> take 5 $ unfoldr (fmap swap . hush . unsnocOddE) infinite
[(20,30),(21,31),(22,32),(23,33),(24,34)]

repeatEvenA :: a -> e -> TwoFingerEvenA e a

Infinitely repeat the given a and e.

infiniteEvenA :: Stream a -> Stream e -> Stream a -> Stream e -> TwoFingerEvenA e a

>>> let infinite = infiniteEvenA (Stream.iterate (+ 1) 0) (Stream.iterate (+ 1) 10) (Stream.iterate (+ 1) 20) (Stream.iterate (+ 1) 30)
>>> take 5 $ unfoldr unconsEvenA infinite
[(0,10),(1,11),(2,12),(3,13),(4,14)]
>>> take 5 $ unfoldr (fmap swap . unsnocEvenA) infinite
[(20,30),(21,31),(22,32),(23,33),(24,34)]

repeatEvenE :: e -> a -> TwoFingerEvenE e a

infiniteEvenE :: Stream e -> Stream a -> Stream e -> Stream a -> TwoFingerEvenE e a

>>> let infinite = infiniteEvenE (Stream.iterate (+ 1) 0) (Stream.iterate (+ 1) 10) (Stream.iterate (+ 1) 20) (Stream.iterate (+ 1) 30)
>>> take 5 $ unfoldr unconsEvenE infinite
[(0,10),(1,11),(2,12),(3,13),(4,14)]
>>> take 5 $ unfoldr (fmap swap . unsnocEvenE) infinite
[(20,30),(21,31),(22,32),(23,33),(24,34)]