module Data.NonEmptyTest where

import qualified Data.NonEmpty.Mixed as NonEmptyMixed
import qualified Data.NonEmptyPrivate as NonEmpty

import Control.Monad (guard, )

import qualified Data.List.HT as ListHT
import Data.Tuple.HT (mapFst, )


foldBalanced :: NonEmpty.T [] Integer -> Bool
foldBalanced :: T [] Integer -> Bool
foldBalanced T [] Integer
xs =
   (Integer -> Integer -> Integer) -> T [] Integer -> Integer
forall a. (a -> a -> a) -> T [] a -> a
NonEmpty.foldBalanced Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
(+) T [] Integer
xs Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== T [] Integer -> Integer
forall a (f :: * -> *). (Num a, Foldable f) => T f a -> a
NonEmpty.sum T [] Integer
xs



filterToInfixesAlt :: (a -> Bool) -> [a] -> [NonEmpty.T [] a]
filterToInfixesAlt :: (a -> Bool) -> [a] -> [T [] a]
filterToInfixesAlt a -> Bool
p =
   (Bool, [T [] a]) -> [T [] a]
forall a b. (a, b) -> b
snd ((Bool, [T [] a]) -> [T [] a])
-> ([a] -> (Bool, [T [] a])) -> [a] -> [T [] a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   (a -> (Bool, [T [] a]) -> (Bool, [T [] a]))
-> (Bool, [T [] a]) -> [a] -> (Bool, [T [] a])
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr
      (\a
x ~(Bool
b1, [T [] a]
yt) ->
         let b0 :: Bool
b0 = a -> Bool
p a
x
         in  (Bool
b0,
              if Bool
b0
                then (T [] a -> [T [] a] -> [T [] a]) -> (T [] a, [T [] a]) -> [T [] a]
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (:) ((T [] a, [T [] a]) -> [T [] a]) -> (T [] a, [T [] a]) -> [T [] a]
forall a b. (a -> b) -> a -> b
$
                     ([a] -> T [] a) -> ([a], [T [] a]) -> (T [] a, [T [] a])
forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst (a -> [a] -> T [] a
forall a (f :: * -> *). a -> f a -> T f a
NonEmpty.cons a
x) (([a], [T [] a]) -> (T [] a, [T [] a]))
-> ([a], [T [] a]) -> (T [] a, [T [] a])
forall a b. (a -> b) -> a -> b
$
                     case Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard Bool
b1 Maybe () -> Maybe (T [] a, [T [] a]) -> Maybe (T [] a, [T [] a])
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [T [] a] -> Maybe (T [] a, [T [] a])
forall a. [a] -> Maybe (a, [a])
ListHT.viewL [T [] a]
yt of
                        Just (T [] a
y,[T [] a]
ys) -> (T [] a -> [a]
forall (f :: * -> *) a. Cons f => T f a -> f a
NonEmpty.flatten T [] a
y, [T [] a]
ys)
                        Maybe (T [] a, [T [] a])
Nothing -> ([], [T [] a]
yt)
                else [T [] a]
yt))
      (Bool
True, [])

filterToInfixes :: [Int] -> Bool
filterToInfixes :: [Int] -> Bool
filterToInfixes [Int]
xs =
   (Int -> Bool) -> [Int] -> [T [] Int]
forall (f :: * -> *) a.
Foldable f =>
(a -> Bool) -> f a -> [T [] a]
NonEmptyMixed.filterToInfixes (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
0) [Int]
xs [T [] Int] -> [T [] Int] -> Bool
forall a. Eq a => a -> a -> Bool
== (Int -> Bool) -> [Int] -> [T [] Int]
forall a. (a -> Bool) -> [a] -> [T [] a]
filterToInfixesAlt (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
0) [Int]
xs