{-# OPTIONS -fallow-overlapping-instances -fglasgow-exts -fallow-undecidable-instances -fallow-incoherent-instances -fno-monomorphism-restriction #-}

{-# language DeriveDataTypeable #-}
{-# language CPP #-}

module Autolib.Set

( Set
, module Autolib.Set 
, module Autolib.Xml
)

where


import Data.Set 
import Data.Typeable
import Autolib.ToDoc
import Autolib.Reader

import Autolib.Xml

import Data.Hashable


#if (!MIN_VERSION_hashable(1,3,4))
instance (Hashable a) => Hashable (Set a) where
  hashWithSalt s = hashWithSalt s . toList
#endif

instance Ord a => Container (Set a) [a] where
    label :: Set a -> String
label Set a
_ = String
"Set"
    pack :: Set a -> [a]
pack = Set a -> [a]
forall a. Set a -> [a]
toList
    unpack :: [a] -> Set a
unpack = [a] -> Set a
forall a. Ord a => [a] -> Set a
fromList

instance ( Ord a, Reader a ) => Reader ( Set a ) where
    reader :: Parser (Set a)
reader = Int -> Parser (Set a)
forall a. Reader a => Int -> Parser a
atomic_readerPrec Int
0
    atomic_readerPrec :: Int -> Parser (Set a)
atomic_readerPrec Int
d = do
        Bool -> ParsecT String () Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> ParsecT String () Identity ())
-> Bool -> ParsecT String () Identity ()
forall a b. (a -> b) -> a -> b
$ Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
9
        String -> ParsecT String () Identity ()
my_reserved String
"mkSet"
        xs <- Parser [a]
forall a. Reader a => Parser [a]
readerList
        return $ fromList xs

instance ToDoc [a] => ToDoc (Set a) where
  toDocPrec :: Int -> Set a -> Doc
toDocPrec Int
p Set a
s = Bool -> Doc -> Doc
docParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
fcp) 
                        (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ String -> Doc
text String
"mkSet" Doc -> Doc -> Doc
</> Int -> [a] -> Doc
forall a. ToDoc a => Int -> a -> Doc
toDocPrec Int
fcp (Set a -> [a]
forall a. Set a -> [a]
setToList Set a
s)


instance Nice [a] => Nice (Set a) where
  nicePrec :: Int -> Set a -> Doc
nicePrec Int
p Set a
s = Bool -> Doc -> Doc
docParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
fcp) 
                        (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ String -> Doc
text String
"mkSet" Doc -> Doc -> Doc
</> Int -> [a] -> Doc
forall a. Nice a => Int -> a -> Doc
nicePrec Int
fcp (Set a -> [a]
forall a. Set a -> [a]
setToList Set a
s)


{-

--  http://www.haskell.org//pipermail/haskell/2005-January/015164.html

instance ( Typeable a ) =>  Typeable ( Set a ) where
    typeOf s = 
        mkTyConApp
                ( mkTyCon "Autolib.Set.Set" )
                [ typeOf ((undefined :: Set a -> a) s) ]


-}

isEmptySet :: Set a -> Bool
isEmptySet = Set a -> Bool
forall a. Set a -> Bool
Data.Set.null

emptySet :: Set a
emptySet = Set a
forall a. Set a
Data.Set.empty
unitSet :: a -> Set a
unitSet = a -> Set a
forall a. a -> Set a
Data.Set.singleton

delFromSet :: Set a -> a -> Set a
delFromSet = (a -> Set a -> Set a) -> Set a -> a -> Set a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> Set a -> Set a
forall a. Ord a => a -> Set a -> Set a
Data.Set.delete
addToSet :: Set a -> a -> Set a
addToSet = (a -> Set a -> Set a) -> Set a -> a -> Set a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> Set a -> Set a
forall a. Ord a => a -> Set a -> Set a
Data.Set.insert
elementOf :: a -> Set a -> Bool
elementOf = a -> Set a -> Bool
forall a. Ord a => a -> Set a -> Bool
Data.Set.member

cardinality :: Set a -> Int
cardinality = Set a -> Int
forall a. Set a -> Int
Data.Set.size

union :: Set a -> Set a -> Set a
union = Set a -> Set a -> Set a
forall a. Ord a => Set a -> Set a -> Set a
Data.Set.union
unionManySets :: f (Set a) -> Set a
unionManySets = f (Set a) -> Set a
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Data.Set.unions

intersect :: Set a -> Set a -> Set a
intersect = Set a -> Set a -> Set a
forall a. Ord a => Set a -> Set a -> Set a
Data.Set.intersection

minusSet :: Set a -> Set a -> Set a
minusSet = Set a -> Set a -> Set a
forall a. Ord a => Set a -> Set a -> Set a
Data.Set.difference

mkSet :: Ord a => [a] -> Set a
mkSet :: forall a. Ord a => [a] -> Set a
mkSet = [a] -> Set a
forall a. Ord a => [a] -> Set a
fromList

setToList :: Set a -> [a]
setToList :: forall a. Set a -> [a]
setToList = Set a -> [a]
forall a. Set a -> [a]
toAscList

subseteq :: Ord a => Set a -> Set a -> Bool
subseteq :: forall a. Ord a => Set a -> Set a -> Bool
subseteq Set a
xs Set a
ys = Set a -> Bool
forall a. Set a -> Bool
Data.Set.null (Set a -> Bool) -> Set a -> Bool
forall a b. (a -> b) -> a -> b
$ Set a
xs Set a -> Set a -> Set a
forall a. Ord a => Set a -> Set a -> Set a
`difference` Set a
ys

smap :: (Ord a, Ord b) => (a -> b) -> (Set a -> Set b)
smap :: forall a b. (Ord a, Ord b) => (a -> b) -> Set a -> Set b
smap = (a -> b) -> Set a -> Set b
forall b a. Ord b => (a -> b) -> Set a -> Set b
Data.Set.map

sfilter :: Ord a => (a -> Bool) -> (Set a -> Set a)
sfilter :: forall a. Ord a => (a -> Bool) -> Set a -> Set a
sfilter = (a -> Bool) -> Set a -> Set a
forall a. (a -> Bool) -> Set a -> Set a
Data.Set.filter

nonempty :: Ord a => Set a -> Bool
nonempty :: forall a. Ord a => Set a -> Bool
nonempty = Bool -> Bool
not (Bool -> Bool) -> (Set a -> Bool) -> Set a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set a -> Bool
forall a. Set a -> Bool
Data.Set.null 

cross :: (Ord a, Ord b) => Set a -> Set b -> Set (a, b)
cross :: forall a b. (Ord a, Ord b) => Set a -> Set b -> Set (a, b)
cross Set a
xs Set b
ys = [(a, b)] -> Set (a, b)
forall a. Ord a => [a] -> Set a
fromList ([(a, b)] -> Set (a, b)) -> [(a, b)] -> Set (a, b)
forall a b. (a -> b) -> a -> b
$ do 
    x <- Set a -> [a]
forall a. Set a -> [a]
toList Set a
xs; y <- toList ys; return (x, y)

teilmengen :: Ord a => Int -> Set a -> [ Set a ]
teilmengen :: forall a. Ord a => Int -> Set a -> [Set a]
teilmengen Int
n = ([a] -> Set a) -> [[a]] -> [Set a]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map [a] -> Set a
forall a. Ord a => [a] -> Set a
fromList ([[a]] -> [Set a]) -> (Set a -> [[a]]) -> Set a -> [Set a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [a] -> [[a]]
forall a. Int -> [a] -> [[a]]
teilfolgen Int
n ([a] -> [[a]]) -> (Set a -> [a]) -> Set a -> [[a]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set a -> [a]
forall a. Set a -> [a]
toList
    
subsets ::  Ord a => Set a -> [ Set a ]
subsets :: forall a. Ord a => Set a -> [Set a]
subsets Set a
s = do n <- [ Int
0 .. Set a -> Int
forall a. Set a -> Int
cardinality Set a
s ] ; teilmengen n s
 
teilfolgen :: Int -> [a] -> [[a]]
teilfolgen :: forall a. Int -> [a] -> [[a]]
teilfolgen Int
k [a]
xs | Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
xs = []
teilfolgen Int
0 [a]
xs = [[]]
teilfolgen Int
k (a
x : [a]
xs)
    =  Int -> [a] -> [[a]]
forall a. Int -> [a] -> [[a]]
teilfolgen Int
k [a]
xs
    [[a]] -> [[a]] -> [[a]]
forall a. [a] -> [a] -> [a]
++ do ys <- Int -> [a] -> [[a]]
forall a. Int -> [a] -> [[a]]
teilfolgen (Int
kInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) [a]
xs ; return $ x : ys