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



filterToInfixesAlt :: (a -> Bool) -> [a] -> [NonEmpty.T [] a]
filterToInfixesAlt :: forall a. (a -> Bool) -> [a] -> [T [] a]
filterToInfixesAlt a -> Bool
p =
   forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   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 forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (:) forall a b. (a -> b) -> a -> b
$
                     forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst (forall a (f :: * -> *). a -> f a -> T f a
NonEmpty.cons a
x) forall a b. (a -> b) -> a -> b
$
                     case forall (f :: * -> *). Alternative f => Bool -> f ()
guard Bool
b1 forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall a. [a] -> Maybe (a, [a])
ListHT.viewL [T [] a]
yt of
                        Just (T [] a
y,[T [] a]
ys) -> (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 =
   forall (f :: * -> *) a.
Foldable f =>
(a -> Bool) -> f a -> [T [] a]
NonEmptyMixed.filterToInfixes (forall a. Ord a => a -> a -> Bool
>Int
0) [Int]
xs forall a. Eq a => a -> a -> Bool
== forall a. (a -> Bool) -> [a] -> [T [] a]
filterToInfixesAlt (forall a. Ord a => a -> a -> Bool
>Int
0) [Int]
xs