-
Notifications
You must be signed in to change notification settings - Fork 272
/
Empty.hs
155 lines (130 loc) · 4.14 KB
/
Empty.hs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
{-# LANGUAGE CPP #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE DefaultSignatures #-}
-------------------------------------------------------------------------------
-- |
-- Module : Control.Lens.Empty
-- Copyright : (C) 2012-13 Edward Kmett
-- License : BSD-style (see the file LICENSE)
-- Maintainer : Edward Kmett <ekmett@gmail.com>
-- Stability : provisional
-- Portability : non-portable
--
-------------------------------------------------------------------------------
module Control.Lens.Empty
(
AsEmpty(..)
) where
import Control.Lens.Iso
import Control.Lens.Prism
import Control.Lens.Review
import Data.ByteString as StrictB
import Data.ByteString.Lazy as LazyB
import Data.HashMap.Lazy as HashMap
import Data.HashSet as HashSet
import Data.IntMap as IntMap
import Data.IntSet as IntSet
import Data.Map as Map
import Data.Maybe
import Data.Monoid
import Data.Profunctor.Unsafe
import Data.Sequence as Seq
import Data.Set as Set
import Data.Text as StrictT
import Data.Text.Lazy as LazyT
import Data.Vector as Vector
import Data.Vector.Unboxed as Unboxed
import Data.Vector.Storable as Storable
import GHC.Event
class AsEmpty a where
-- |
--
-- >>> isn't _Empty [1,2,3]
-- True
_Empty :: Prism' a ()
#ifndef HLINT
default _Empty :: (Monoid a, Eq a) => Prism' a ()
_Empty = only mempty
{-# INLINE _Empty #-}
#endif
{- Default Monoid instances -}
instance AsEmpty Ordering
instance AsEmpty ()
instance AsEmpty Any
instance AsEmpty All
instance AsEmpty Event
instance (Eq a, Num a) => AsEmpty (Product a)
instance (Eq a, Num a) => AsEmpty (Sum a)
instance AsEmpty (Maybe a) where
_Empty = _Nothing
{-# INLINE _Empty #-}
instance AsEmpty (Last a) where
_Empty = nearly (Last Nothing) (isNothing .# getLast)
{-# INLINE _Empty #-}
instance AsEmpty (First a) where
_Empty = nearly (First Nothing) (isNothing .# getFirst)
{-# INLINE _Empty #-}
instance AsEmpty a => AsEmpty (Dual a) where
_Empty = iso getDual Dual . _Empty
{-# INLINE _Empty #-}
instance (AsEmpty a, AsEmpty b) => AsEmpty (a,b) where
_Empty = prism' (\() -> (_Empty # (), _Empty # ())) $ \(s,s') -> case _Empty Left s of
Left () -> case _Empty Left s' of
Left () -> Just ()
_ -> Nothing
_ -> Nothing
{-# INLINE _Empty #-}
instance (AsEmpty a, AsEmpty b, AsEmpty c) => AsEmpty (a,b,c) where
_Empty = prism' (\() -> (_Empty # (), _Empty # (), _Empty # ())) $ \(s,s',s'') -> case _Empty Left s of
Left () -> case _Empty Left s' of
Left () -> case _Empty Left s'' of
Left () -> Just ()
Right _ -> Nothing
Right _ -> Nothing
Right _ -> Nothing
{-# INLINE _Empty #-}
instance AsEmpty [a] where
_Empty = nearly [] Prelude.null
{-# INLINE _Empty #-}
instance AsEmpty (Map k a) where
_Empty = nearly Map.empty Map.null
{-# INLINE _Empty #-}
instance AsEmpty (HashMap k a) where
_Empty = nearly HashMap.empty HashMap.null
{-# INLINE _Empty #-}
instance AsEmpty (IntMap a) where
_Empty = nearly IntMap.empty IntMap.null
{-# INLINE _Empty #-}
instance AsEmpty (Set a) where
_Empty = nearly Set.empty Set.null
{-# INLINE _Empty #-}
instance AsEmpty (HashSet a) where
_Empty = nearly HashSet.empty HashSet.null
{-# INLINE _Empty #-}
instance AsEmpty IntSet where
_Empty = nearly IntSet.empty IntSet.null
{-# INLINE _Empty #-}
instance AsEmpty (Vector.Vector a) where
_Empty = nearly Vector.empty Vector.null
{-# INLINE _Empty #-}
instance Unbox a => AsEmpty (Unboxed.Vector a) where
_Empty = nearly Unboxed.empty Unboxed.null
{-# INLINE _Empty #-}
instance Storable a => AsEmpty (Storable.Vector a) where
_Empty = nearly Storable.empty Storable.null
{-# INLINE _Empty #-}
instance AsEmpty (Seq a) where
_Empty = nearly Seq.empty Seq.null
{-# INLINE _Empty #-}
instance AsEmpty StrictB.ByteString where
_Empty = nearly StrictB.empty StrictB.null
{-# INLINE _Empty #-}
instance AsEmpty LazyB.ByteString where
_Empty = nearly LazyB.empty LazyB.null
{-# INLINE _Empty #-}
instance AsEmpty StrictT.Text where
_Empty = nearly StrictT.empty StrictT.null
{-# INLINE _Empty #-}
instance AsEmpty LazyT.Text where
_Empty = nearly LazyT.empty LazyT.null
{-# INLINE _Empty #-}