{-# LANGUAGE AllowAmbiguousTypes  #-}
{-# LANGUAGE UndecidableInstances #-}
--------------------------------------------------------------------------------
-- |
-- Module      :  HGeometry.Interval.EndPoint
-- Copyright   :  (C) Frank Staals
-- License     :  see the LICENSE file
-- Maintainer  :  Frank Staals
--
-- Endpoints of intervals
--
--------------------------------------------------------------------------------
module HGeometry.Interval.EndPoint
  ( EndPoint_(..)
  , IsEndPoint(..)

  , EndPointType(..)
  , EndPoint(EndPoint, OpenE, ClosedE)
  , AnEndPoint(..,AnOpenE,AnClosedE)
  , asAnEndPoint
  ) where

import Control.Lens
import Data.Foldable1
import GHC.Generics (Generic)
import Control.DeepSeq
import HGeometry.Properties
import Text.Read

--------------------------------------------------------------------------------

-- | Types that have an '_endPoint' field lens.
class IsEndPoint endPoint endPoint' where
  -- | Lens to access the actual data value of the end point
  _endPoint :: Lens endPoint endPoint' (IxValue endPoint) (IxValue endPoint')

-- | An endpoint storing values of some type r
class IsEndPoint endPoint endPoint => EndPoint_ endPoint where
  -- | Report the type of the endpoint
  endPointType :: endPoint -> EndPointType
  -- | constructs a "default" enpoint
  mkEndPoint :: IxValue endPoint -> endPoint

-- | Possible endpoint types; open or closed
data EndPointType = Open | Closed deriving (Int -> EndPointType -> ShowS
[EndPointType] -> ShowS
EndPointType -> String
(Int -> EndPointType -> ShowS)
-> (EndPointType -> String)
-> ([EndPointType] -> ShowS)
-> Show EndPointType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EndPointType -> ShowS
showsPrec :: Int -> EndPointType -> ShowS
$cshow :: EndPointType -> String
show :: EndPointType -> String
$cshowList :: [EndPointType] -> ShowS
showList :: [EndPointType] -> ShowS
Show,ReadPrec [EndPointType]
ReadPrec EndPointType
Int -> ReadS EndPointType
ReadS [EndPointType]
(Int -> ReadS EndPointType)
-> ReadS [EndPointType]
-> ReadPrec EndPointType
-> ReadPrec [EndPointType]
-> Read EndPointType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EndPointType
readsPrec :: Int -> ReadS EndPointType
$creadList :: ReadS [EndPointType]
readList :: ReadS [EndPointType]
$creadPrec :: ReadPrec EndPointType
readPrec :: ReadPrec EndPointType
$creadListPrec :: ReadPrec [EndPointType]
readListPrec :: ReadPrec [EndPointType]
Read,EndPointType -> EndPointType -> Bool
(EndPointType -> EndPointType -> Bool)
-> (EndPointType -> EndPointType -> Bool) -> Eq EndPointType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EndPointType -> EndPointType -> Bool
== :: EndPointType -> EndPointType -> Bool
$c/= :: EndPointType -> EndPointType -> Bool
/= :: EndPointType -> EndPointType -> Bool
Eq,Eq EndPointType
Eq EndPointType =>
(EndPointType -> EndPointType -> Ordering)
-> (EndPointType -> EndPointType -> Bool)
-> (EndPointType -> EndPointType -> Bool)
-> (EndPointType -> EndPointType -> Bool)
-> (EndPointType -> EndPointType -> Bool)
-> (EndPointType -> EndPointType -> EndPointType)
-> (EndPointType -> EndPointType -> EndPointType)
-> Ord EndPointType
EndPointType -> EndPointType -> Bool
EndPointType -> EndPointType -> Ordering
EndPointType -> EndPointType -> EndPointType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EndPointType -> EndPointType -> Ordering
compare :: EndPointType -> EndPointType -> Ordering
$c< :: EndPointType -> EndPointType -> Bool
< :: EndPointType -> EndPointType -> Bool
$c<= :: EndPointType -> EndPointType -> Bool
<= :: EndPointType -> EndPointType -> Bool
$c> :: EndPointType -> EndPointType -> Bool
> :: EndPointType -> EndPointType -> Bool
$c>= :: EndPointType -> EndPointType -> Bool
>= :: EndPointType -> EndPointType -> Bool
$cmax :: EndPointType -> EndPointType -> EndPointType
max :: EndPointType -> EndPointType -> EndPointType
$cmin :: EndPointType -> EndPointType -> EndPointType
min :: EndPointType -> EndPointType -> EndPointType
Ord,Int -> EndPointType
EndPointType -> Int
EndPointType -> [EndPointType]
EndPointType -> EndPointType
EndPointType -> EndPointType -> [EndPointType]
EndPointType -> EndPointType -> EndPointType -> [EndPointType]
(EndPointType -> EndPointType)
-> (EndPointType -> EndPointType)
-> (Int -> EndPointType)
-> (EndPointType -> Int)
-> (EndPointType -> [EndPointType])
-> (EndPointType -> EndPointType -> [EndPointType])
-> (EndPointType -> EndPointType -> [EndPointType])
-> (EndPointType -> EndPointType -> EndPointType -> [EndPointType])
-> Enum EndPointType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: EndPointType -> EndPointType
succ :: EndPointType -> EndPointType
$cpred :: EndPointType -> EndPointType
pred :: EndPointType -> EndPointType
$ctoEnum :: Int -> EndPointType
toEnum :: Int -> EndPointType
$cfromEnum :: EndPointType -> Int
fromEnum :: EndPointType -> Int
$cenumFrom :: EndPointType -> [EndPointType]
enumFrom :: EndPointType -> [EndPointType]
$cenumFromThen :: EndPointType -> EndPointType -> [EndPointType]
enumFromThen :: EndPointType -> EndPointType -> [EndPointType]
$cenumFromTo :: EndPointType -> EndPointType -> [EndPointType]
enumFromTo :: EndPointType -> EndPointType -> [EndPointType]
$cenumFromThenTo :: EndPointType -> EndPointType -> EndPointType -> [EndPointType]
enumFromThenTo :: EndPointType -> EndPointType -> EndPointType -> [EndPointType]
Enum,EndPointType
EndPointType -> EndPointType -> Bounded EndPointType
forall a. a -> a -> Bounded a
$cminBound :: EndPointType
minBound :: EndPointType
$cmaxBound :: EndPointType
maxBound :: EndPointType
Bounded,(forall x. EndPointType -> Rep EndPointType x)
-> (forall x. Rep EndPointType x -> EndPointType)
-> Generic EndPointType
forall x. Rep EndPointType x -> EndPointType
forall x. EndPointType -> Rep EndPointType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EndPointType -> Rep EndPointType x
from :: forall x. EndPointType -> Rep EndPointType x
$cto :: forall x. Rep EndPointType x -> EndPointType
to :: forall x. Rep EndPointType x -> EndPointType
Generic)

instance NFData EndPointType

-- testV :: Vector 2 (Point 2 Double)
-- testV = Vector2 (Point2 5.0 6.0) (Point2 10.0 1.0)

-- testV1 :: Vector 2 (EndPoint Closed (Point 2 Double))
-- testV1 = Vector2 (mkEndPoint$ Point2 5.0 6.0) (mkEndPoint$ Point2 10.0 1.0)

--------------------------------------------------------------------------------

-- | EndPoint with a type safe tag
newtype EndPoint (et :: EndPointType) r = EndPoint r
  deriving stock (EndPoint et r -> EndPoint et r -> Bool
(EndPoint et r -> EndPoint et r -> Bool)
-> (EndPoint et r -> EndPoint et r -> Bool) -> Eq (EndPoint et r)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (et :: EndPointType) r.
Eq r =>
EndPoint et r -> EndPoint et r -> Bool
$c== :: forall (et :: EndPointType) r.
Eq r =>
EndPoint et r -> EndPoint et r -> Bool
== :: EndPoint et r -> EndPoint et r -> Bool
$c/= :: forall (et :: EndPointType) r.
Eq r =>
EndPoint et r -> EndPoint et r -> Bool
/= :: EndPoint et r -> EndPoint et r -> Bool
Eq,Eq (EndPoint et r)
Eq (EndPoint et r) =>
(EndPoint et r -> EndPoint et r -> Ordering)
-> (EndPoint et r -> EndPoint et r -> Bool)
-> (EndPoint et r -> EndPoint et r -> Bool)
-> (EndPoint et r -> EndPoint et r -> Bool)
-> (EndPoint et r -> EndPoint et r -> Bool)
-> (EndPoint et r -> EndPoint et r -> EndPoint et r)
-> (EndPoint et r -> EndPoint et r -> EndPoint et r)
-> Ord (EndPoint et r)
EndPoint et r -> EndPoint et r -> Bool
EndPoint et r -> EndPoint et r -> Ordering
EndPoint et r -> EndPoint et r -> EndPoint et r
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (et :: EndPointType) r. Ord r => Eq (EndPoint et r)
forall (et :: EndPointType) r.
Ord r =>
EndPoint et r -> EndPoint et r -> Bool
forall (et :: EndPointType) r.
Ord r =>
EndPoint et r -> EndPoint et r -> Ordering
forall (et :: EndPointType) r.
Ord r =>
EndPoint et r -> EndPoint et r -> EndPoint et r
$ccompare :: forall (et :: EndPointType) r.
Ord r =>
EndPoint et r -> EndPoint et r -> Ordering
compare :: EndPoint et r -> EndPoint et r -> Ordering
$c< :: forall (et :: EndPointType) r.
Ord r =>
EndPoint et r -> EndPoint et r -> Bool
< :: EndPoint et r -> EndPoint et r -> Bool
$c<= :: forall (et :: EndPointType) r.
Ord r =>
EndPoint et r -> EndPoint et r -> Bool
<= :: EndPoint et r -> EndPoint et r -> Bool
$c> :: forall (et :: EndPointType) r.
Ord r =>
EndPoint et r -> EndPoint et r -> Bool
> :: EndPoint et r -> EndPoint et r -> Bool
$c>= :: forall (et :: EndPointType) r.
Ord r =>
EndPoint et r -> EndPoint et r -> Bool
>= :: EndPoint et r -> EndPoint et r -> Bool
$cmax :: forall (et :: EndPointType) r.
Ord r =>
EndPoint et r -> EndPoint et r -> EndPoint et r
max :: EndPoint et r -> EndPoint et r -> EndPoint et r
$cmin :: forall (et :: EndPointType) r.
Ord r =>
EndPoint et r -> EndPoint et r -> EndPoint et r
min :: EndPoint et r -> EndPoint et r -> EndPoint et r
Ord,(forall a b. (a -> b) -> EndPoint et a -> EndPoint et b)
-> (forall a b. a -> EndPoint et b -> EndPoint et a)
-> Functor (EndPoint et)
forall a b. a -> EndPoint et b -> EndPoint et a
forall a b. (a -> b) -> EndPoint et a -> EndPoint et b
forall (et :: EndPointType) a b.
a -> EndPoint et b -> EndPoint et a
forall (et :: EndPointType) a b.
(a -> b) -> EndPoint et a -> EndPoint et b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (et :: EndPointType) a b.
(a -> b) -> EndPoint et a -> EndPoint et b
fmap :: forall a b. (a -> b) -> EndPoint et a -> EndPoint et b
$c<$ :: forall (et :: EndPointType) a b.
a -> EndPoint et b -> EndPoint et a
<$ :: forall a b. a -> EndPoint et b -> EndPoint et a
Functor,(forall m. Monoid m => EndPoint et m -> m)
-> (forall m a. Monoid m => (a -> m) -> EndPoint et a -> m)
-> (forall m a. Monoid m => (a -> m) -> EndPoint et a -> m)
-> (forall a b. (a -> b -> b) -> b -> EndPoint et a -> b)
-> (forall a b. (a -> b -> b) -> b -> EndPoint et a -> b)
-> (forall b a. (b -> a -> b) -> b -> EndPoint et a -> b)
-> (forall b a. (b -> a -> b) -> b -> EndPoint et a -> b)
-> (forall a. (a -> a -> a) -> EndPoint et a -> a)
-> (forall a. (a -> a -> a) -> EndPoint et a -> a)
-> (forall a. EndPoint et a -> [a])
-> (forall a. EndPoint et a -> Bool)
-> (forall a. EndPoint et a -> Int)
-> (forall a. Eq a => a -> EndPoint et a -> Bool)
-> (forall a. Ord a => EndPoint et a -> a)
-> (forall a. Ord a => EndPoint et a -> a)
-> (forall a. Num a => EndPoint et a -> a)
-> (forall a. Num a => EndPoint et a -> a)
-> Foldable (EndPoint et)
forall a. Eq a => a -> EndPoint et a -> Bool
forall a. Num a => EndPoint et a -> a
forall a. Ord a => EndPoint et a -> a
forall m. Monoid m => EndPoint et m -> m
forall a. EndPoint et a -> Bool
forall a. EndPoint et a -> Int
forall a. EndPoint et a -> [a]
forall a. (a -> a -> a) -> EndPoint et a -> a
forall m a. Monoid m => (a -> m) -> EndPoint et a -> m
forall b a. (b -> a -> b) -> b -> EndPoint et a -> b
forall a b. (a -> b -> b) -> b -> EndPoint et a -> b
forall (et :: EndPointType) a. Eq a => a -> EndPoint et a -> Bool
forall (et :: EndPointType) a. Num a => EndPoint et a -> a
forall (et :: EndPointType) a. Ord a => EndPoint et a -> a
forall (et :: EndPointType) m. Monoid m => EndPoint et m -> m
forall (et :: EndPointType) a. EndPoint et a -> Bool
forall (et :: EndPointType) a. EndPoint et a -> Int
forall (et :: EndPointType) a. EndPoint et a -> [a]
forall (et :: EndPointType) a. (a -> a -> a) -> EndPoint et a -> a
forall (et :: EndPointType) m a.
Monoid m =>
(a -> m) -> EndPoint et a -> m
forall (et :: EndPointType) b a.
(b -> a -> b) -> b -> EndPoint et a -> b
forall (et :: EndPointType) a b.
(a -> b -> b) -> b -> EndPoint et a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall (et :: EndPointType) m. Monoid m => EndPoint et m -> m
fold :: forall m. Monoid m => EndPoint et m -> m
$cfoldMap :: forall (et :: EndPointType) m a.
Monoid m =>
(a -> m) -> EndPoint et a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> EndPoint et a -> m
$cfoldMap' :: forall (et :: EndPointType) m a.
Monoid m =>
(a -> m) -> EndPoint et a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> EndPoint et a -> m
$cfoldr :: forall (et :: EndPointType) a b.
(a -> b -> b) -> b -> EndPoint et a -> b
foldr :: forall a b. (a -> b -> b) -> b -> EndPoint et a -> b
$cfoldr' :: forall (et :: EndPointType) a b.
(a -> b -> b) -> b -> EndPoint et a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> EndPoint et a -> b
$cfoldl :: forall (et :: EndPointType) b a.
(b -> a -> b) -> b -> EndPoint et a -> b
foldl :: forall b a. (b -> a -> b) -> b -> EndPoint et a -> b
$cfoldl' :: forall (et :: EndPointType) b a.
(b -> a -> b) -> b -> EndPoint et a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> EndPoint et a -> b
$cfoldr1 :: forall (et :: EndPointType) a. (a -> a -> a) -> EndPoint et a -> a
foldr1 :: forall a. (a -> a -> a) -> EndPoint et a -> a
$cfoldl1 :: forall (et :: EndPointType) a. (a -> a -> a) -> EndPoint et a -> a
foldl1 :: forall a. (a -> a -> a) -> EndPoint et a -> a
$ctoList :: forall (et :: EndPointType) a. EndPoint et a -> [a]
toList :: forall a. EndPoint et a -> [a]
$cnull :: forall (et :: EndPointType) a. EndPoint et a -> Bool
null :: forall a. EndPoint et a -> Bool
$clength :: forall (et :: EndPointType) a. EndPoint et a -> Int
length :: forall a. EndPoint et a -> Int
$celem :: forall (et :: EndPointType) a. Eq a => a -> EndPoint et a -> Bool
elem :: forall a. Eq a => a -> EndPoint et a -> Bool
$cmaximum :: forall (et :: EndPointType) a. Ord a => EndPoint et a -> a
maximum :: forall a. Ord a => EndPoint et a -> a
$cminimum :: forall (et :: EndPointType) a. Ord a => EndPoint et a -> a
minimum :: forall a. Ord a => EndPoint et a -> a
$csum :: forall (et :: EndPointType) a. Num a => EndPoint et a -> a
sum :: forall a. Num a => EndPoint et a -> a
$cproduct :: forall (et :: EndPointType) a. Num a => EndPoint et a -> a
product :: forall a. Num a => EndPoint et a -> a
Foldable,Functor (EndPoint et)
Foldable (EndPoint et)
(Functor (EndPoint et), Foldable (EndPoint et)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> EndPoint et a -> f (EndPoint et b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    EndPoint et (f a) -> f (EndPoint et a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> EndPoint et a -> m (EndPoint et b))
-> (forall (m :: * -> *) a.
    Monad m =>
    EndPoint et (m a) -> m (EndPoint et a))
-> Traversable (EndPoint et)
forall (et :: EndPointType). Functor (EndPoint et)
forall (et :: EndPointType). Foldable (EndPoint et)
forall (et :: EndPointType) (m :: * -> *) a.
Monad m =>
EndPoint et (m a) -> m (EndPoint et a)
forall (et :: EndPointType) (f :: * -> *) a.
Applicative f =>
EndPoint et (f a) -> f (EndPoint et a)
forall (et :: EndPointType) (m :: * -> *) a b.
Monad m =>
(a -> m b) -> EndPoint et a -> m (EndPoint et b)
forall (et :: EndPointType) (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> EndPoint et a -> f (EndPoint et b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
EndPoint et (m a) -> m (EndPoint et a)
forall (f :: * -> *) a.
Applicative f =>
EndPoint et (f a) -> f (EndPoint et a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> EndPoint et a -> m (EndPoint et b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> EndPoint et a -> f (EndPoint et b)
$ctraverse :: forall (et :: EndPointType) (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> EndPoint et a -> f (EndPoint et b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> EndPoint et a -> f (EndPoint et b)
$csequenceA :: forall (et :: EndPointType) (f :: * -> *) a.
Applicative f =>
EndPoint et (f a) -> f (EndPoint et a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
EndPoint et (f a) -> f (EndPoint et a)
$cmapM :: forall (et :: EndPointType) (m :: * -> *) a b.
Monad m =>
(a -> m b) -> EndPoint et a -> m (EndPoint et b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> EndPoint et a -> m (EndPoint et b)
$csequence :: forall (et :: EndPointType) (m :: * -> *) a.
Monad m =>
EndPoint et (m a) -> m (EndPoint et a)
sequence :: forall (m :: * -> *) a.
Monad m =>
EndPoint et (m a) -> m (EndPoint et a)
Traversable,(forall x. EndPoint et r -> Rep (EndPoint et r) x)
-> (forall x. Rep (EndPoint et r) x -> EndPoint et r)
-> Generic (EndPoint et r)
forall x. Rep (EndPoint et r) x -> EndPoint et r
forall x. EndPoint et r -> Rep (EndPoint et r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (et :: EndPointType) r x.
Rep (EndPoint et r) x -> EndPoint et r
forall (et :: EndPointType) r x.
EndPoint et r -> Rep (EndPoint et r) x
$cfrom :: forall (et :: EndPointType) r x.
EndPoint et r -> Rep (EndPoint et r) x
from :: forall x. EndPoint et r -> Rep (EndPoint et r) x
$cto :: forall (et :: EndPointType) r x.
Rep (EndPoint et r) x -> EndPoint et r
to :: forall x. Rep (EndPoint et r) x -> EndPoint et r
Generic)
  deriving newtype (EndPoint et r -> ()
(EndPoint et r -> ()) -> NFData (EndPoint et r)
forall a. (a -> ()) -> NFData a
forall (et :: EndPointType) r. NFData r => EndPoint et r -> ()
$crnf :: forall (et :: EndPointType) r. NFData r => EndPoint et r -> ()
rnf :: EndPoint et r -> ()
NFData)

instance Show r => Show (EndPoint Closed r) where
  showsPrec :: Int -> EndPoint 'Closed r -> ShowS
showsPrec = String -> Int -> EndPoint 'Closed r -> ShowS
forall r (et :: EndPointType).
Show r =>
String -> Int -> EndPoint et r -> ShowS
showsPrecImpl String
"ClosedE"
instance Show r => Show (EndPoint Open r) where
  showsPrec :: Int -> EndPoint 'Open r -> ShowS
showsPrec = String -> Int -> EndPoint 'Open r -> ShowS
forall r (et :: EndPointType).
Show r =>
String -> Int -> EndPoint et r -> ShowS
showsPrecImpl String
"OpenE"

-- | Implementation for Show
showsPrecImpl                        :: Show r => String -> Int -> EndPoint et r -> ShowS
showsPrecImpl :: forall r (et :: EndPointType).
Show r =>
String -> Int -> EndPoint et r -> ShowS
showsPrecImpl String
ctrName Int
k (EndPoint r
x) = Bool -> ShowS -> ShowS
showParen (Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
app_prec) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
                                           String -> ShowS
showString String
ctrName
                                         ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
                                         ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> r -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec (Int
app_precInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) r
x

-- | application precedence
app_prec :: Int
app_prec :: Int
app_prec = Int
10

instance Read r => Read (EndPoint Closed r) where
  readPrec :: ReadPrec (EndPoint 'Closed r)
readPrec = ReadPrec (EndPoint 'Closed r) -> ReadPrec (EndPoint 'Closed r)
forall a. ReadPrec a -> ReadPrec a
parens (ReadPrec (EndPoint 'Closed r) -> ReadPrec (EndPoint 'Closed r))
-> ReadPrec (EndPoint 'Closed r) -> ReadPrec (EndPoint 'Closed r)
forall a b. (a -> b) -> a -> b
$ (Int
-> ReadPrec (EndPoint 'Closed r) -> ReadPrec (EndPoint 'Closed r)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
app_prec (ReadPrec (EndPoint 'Closed r) -> ReadPrec (EndPoint 'Closed r))
-> ReadPrec (EndPoint 'Closed r) -> ReadPrec (EndPoint 'Closed r)
forall a b. (a -> b) -> a -> b
$ do
                          Ident "ClosedE" <- ReadPrec Lexeme
lexP
                          p <- step readPrec
                          return (ClosedE p))

instance Read r => Read (EndPoint Open r) where
  readPrec :: ReadPrec (EndPoint 'Open r)
readPrec = ReadPrec (EndPoint 'Open r) -> ReadPrec (EndPoint 'Open r)
forall a. ReadPrec a -> ReadPrec a
parens (ReadPrec (EndPoint 'Open r) -> ReadPrec (EndPoint 'Open r))
-> ReadPrec (EndPoint 'Open r) -> ReadPrec (EndPoint 'Open r)
forall a b. (a -> b) -> a -> b
$ (Int -> ReadPrec (EndPoint 'Open r) -> ReadPrec (EndPoint 'Open r)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
app_prec (ReadPrec (EndPoint 'Open r) -> ReadPrec (EndPoint 'Open r))
-> ReadPrec (EndPoint 'Open r) -> ReadPrec (EndPoint 'Open r)
forall a b. (a -> b) -> a -> b
$ do
                          Ident "OpenE" <- ReadPrec Lexeme
lexP
                          p <- step readPrec
                          return (OpenE p))

instance Foldable1 (EndPoint et) where
  foldMap1 :: forall m a. Semigroup m => (a -> m) -> EndPoint et a -> m
foldMap1 a -> m
f (EndPoint a
x) = a -> m
f a
x
instance Traversable1 (EndPoint et) where
  traverse1 :: forall (f :: * -> *) a b.
Apply f =>
(a -> f b) -> EndPoint et a -> f (EndPoint et b)
traverse1 a -> f b
f (EndPoint a
x) = b -> EndPoint et b
forall (et :: EndPointType) r. r -> EndPoint et r
EndPoint (b -> EndPoint et b) -> f b -> f (EndPoint et b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
x


type instance NumType   (EndPoint et r) = r
type instance IxValue   (EndPoint et r) = r


-- | Class for types that have '_endPoint' field.
instance IsEndPoint (EndPoint et r) (EndPoint et r') where
  _endPoint :: Lens
  (EndPoint et r)
  (EndPoint et r')
  (IxValue (EndPoint et r))
  (IxValue (EndPoint et r'))
_endPoint = (EndPoint et r -> r)
-> (EndPoint et r -> r' -> EndPoint et r')
-> Lens (EndPoint et r) (EndPoint et r') r r'
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (\(EndPoint r
x) -> r
x) (\EndPoint et r
_ r'
x -> r' -> EndPoint et r'
forall (et :: EndPointType) r. r -> EndPoint et r
EndPoint r'
x)

instance EndPoint_ (EndPoint Closed r) where
  endPointType :: EndPoint 'Closed r -> EndPointType
endPointType EndPoint 'Closed r
_ = EndPointType
Closed
  mkEndPoint :: IxValue (EndPoint 'Closed r) -> EndPoint 'Closed r
mkEndPoint = r -> EndPoint 'Closed r
IxValue (EndPoint 'Closed r) -> EndPoint 'Closed r
forall (et :: EndPointType) r. r -> EndPoint et r
EndPoint

instance EndPoint_ (EndPoint Open r) where
  endPointType :: EndPoint 'Open r -> EndPointType
endPointType EndPoint 'Open r
_ = EndPointType
Open
  mkEndPoint :: IxValue (EndPoint 'Open r) -> EndPoint 'Open r
mkEndPoint = r -> EndPoint 'Open r
IxValue (EndPoint 'Open r) -> EndPoint 'Open r
forall (et :: EndPointType) r. r -> EndPoint et r
EndPoint

-- | Constructs a closed endpoint
pattern ClosedE   :: r -> EndPoint Closed r
pattern $bClosedE :: forall r. r -> EndPoint 'Closed r
$mClosedE :: forall {r} {r}. EndPoint 'Closed r -> (r -> r) -> ((# #) -> r) -> r
ClosedE x = EndPoint x
{-# COMPLETE ClosedE #-}

-- | Constructs an Open endpoint
pattern OpenE   :: r -> EndPoint Open r
pattern $bOpenE :: forall r. r -> EndPoint 'Open r
$mOpenE :: forall {r} {r}. EndPoint 'Open r -> (r -> r) -> ((# #) -> r) -> r
OpenE x = EndPoint x
{-# COMPLETE OpenE #-}

-- | Data type modelling an endpoint that can both be open and closed.
data AnEndPoint r = AnEndPoint {-# UNPACK #-} !EndPointType !r
                  deriving (Int -> AnEndPoint r -> ShowS
[AnEndPoint r] -> ShowS
AnEndPoint r -> String
(Int -> AnEndPoint r -> ShowS)
-> (AnEndPoint r -> String)
-> ([AnEndPoint r] -> ShowS)
-> Show (AnEndPoint r)
forall r. Show r => Int -> AnEndPoint r -> ShowS
forall r. Show r => [AnEndPoint r] -> ShowS
forall r. Show r => AnEndPoint r -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall r. Show r => Int -> AnEndPoint r -> ShowS
showsPrec :: Int -> AnEndPoint r -> ShowS
$cshow :: forall r. Show r => AnEndPoint r -> String
show :: AnEndPoint r -> String
$cshowList :: forall r. Show r => [AnEndPoint r] -> ShowS
showList :: [AnEndPoint r] -> ShowS
Show,ReadPrec [AnEndPoint r]
ReadPrec (AnEndPoint r)
Int -> ReadS (AnEndPoint r)
ReadS [AnEndPoint r]
(Int -> ReadS (AnEndPoint r))
-> ReadS [AnEndPoint r]
-> ReadPrec (AnEndPoint r)
-> ReadPrec [AnEndPoint r]
-> Read (AnEndPoint r)
forall r. Read r => ReadPrec [AnEndPoint r]
forall r. Read r => ReadPrec (AnEndPoint r)
forall r. Read r => Int -> ReadS (AnEndPoint r)
forall r. Read r => ReadS [AnEndPoint r]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall r. Read r => Int -> ReadS (AnEndPoint r)
readsPrec :: Int -> ReadS (AnEndPoint r)
$creadList :: forall r. Read r => ReadS [AnEndPoint r]
readList :: ReadS [AnEndPoint r]
$creadPrec :: forall r. Read r => ReadPrec (AnEndPoint r)
readPrec :: ReadPrec (AnEndPoint r)
$creadListPrec :: forall r. Read r => ReadPrec [AnEndPoint r]
readListPrec :: ReadPrec [AnEndPoint r]
Read,AnEndPoint r -> AnEndPoint r -> Bool
(AnEndPoint r -> AnEndPoint r -> Bool)
-> (AnEndPoint r -> AnEndPoint r -> Bool) -> Eq (AnEndPoint r)
forall r. Eq r => AnEndPoint r -> AnEndPoint r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall r. Eq r => AnEndPoint r -> AnEndPoint r -> Bool
== :: AnEndPoint r -> AnEndPoint r -> Bool
$c/= :: forall r. Eq r => AnEndPoint r -> AnEndPoint r -> Bool
/= :: AnEndPoint r -> AnEndPoint r -> Bool
Eq,Eq (AnEndPoint r)
Eq (AnEndPoint r) =>
(AnEndPoint r -> AnEndPoint r -> Ordering)
-> (AnEndPoint r -> AnEndPoint r -> Bool)
-> (AnEndPoint r -> AnEndPoint r -> Bool)
-> (AnEndPoint r -> AnEndPoint r -> Bool)
-> (AnEndPoint r -> AnEndPoint r -> Bool)
-> (AnEndPoint r -> AnEndPoint r -> AnEndPoint r)
-> (AnEndPoint r -> AnEndPoint r -> AnEndPoint r)
-> Ord (AnEndPoint r)
AnEndPoint r -> AnEndPoint r -> Bool
AnEndPoint r -> AnEndPoint r -> Ordering
AnEndPoint r -> AnEndPoint r -> AnEndPoint r
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall r. Ord r => Eq (AnEndPoint r)
forall r. Ord r => AnEndPoint r -> AnEndPoint r -> Bool
forall r. Ord r => AnEndPoint r -> AnEndPoint r -> Ordering
forall r. Ord r => AnEndPoint r -> AnEndPoint r -> AnEndPoint r
$ccompare :: forall r. Ord r => AnEndPoint r -> AnEndPoint r -> Ordering
compare :: AnEndPoint r -> AnEndPoint r -> Ordering
$c< :: forall r. Ord r => AnEndPoint r -> AnEndPoint r -> Bool
< :: AnEndPoint r -> AnEndPoint r -> Bool
$c<= :: forall r. Ord r => AnEndPoint r -> AnEndPoint r -> Bool
<= :: AnEndPoint r -> AnEndPoint r -> Bool
$c> :: forall r. Ord r => AnEndPoint r -> AnEndPoint r -> Bool
> :: AnEndPoint r -> AnEndPoint r -> Bool
$c>= :: forall r. Ord r => AnEndPoint r -> AnEndPoint r -> Bool
>= :: AnEndPoint r -> AnEndPoint r -> Bool
$cmax :: forall r. Ord r => AnEndPoint r -> AnEndPoint r -> AnEndPoint r
max :: AnEndPoint r -> AnEndPoint r -> AnEndPoint r
$cmin :: forall r. Ord r => AnEndPoint r -> AnEndPoint r -> AnEndPoint r
min :: AnEndPoint r -> AnEndPoint r -> AnEndPoint r
Ord,(forall a b. (a -> b) -> AnEndPoint a -> AnEndPoint b)
-> (forall a b. a -> AnEndPoint b -> AnEndPoint a)
-> Functor AnEndPoint
forall a b. a -> AnEndPoint b -> AnEndPoint a
forall a b. (a -> b) -> AnEndPoint a -> AnEndPoint b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> AnEndPoint a -> AnEndPoint b
fmap :: forall a b. (a -> b) -> AnEndPoint a -> AnEndPoint b
$c<$ :: forall a b. a -> AnEndPoint b -> AnEndPoint a
<$ :: forall a b. a -> AnEndPoint b -> AnEndPoint a
Functor,(forall m. Monoid m => AnEndPoint m -> m)
-> (forall m a. Monoid m => (a -> m) -> AnEndPoint a -> m)
-> (forall m a. Monoid m => (a -> m) -> AnEndPoint a -> m)
-> (forall a b. (a -> b -> b) -> b -> AnEndPoint a -> b)
-> (forall a b. (a -> b -> b) -> b -> AnEndPoint a -> b)
-> (forall b a. (b -> a -> b) -> b -> AnEndPoint a -> b)
-> (forall b a. (b -> a -> b) -> b -> AnEndPoint a -> b)
-> (forall a. (a -> a -> a) -> AnEndPoint a -> a)
-> (forall a. (a -> a -> a) -> AnEndPoint a -> a)
-> (forall a. AnEndPoint a -> [a])
-> (forall a. AnEndPoint a -> Bool)
-> (forall a. AnEndPoint a -> Int)
-> (forall a. Eq a => a -> AnEndPoint a -> Bool)
-> (forall a. Ord a => AnEndPoint a -> a)
-> (forall a. Ord a => AnEndPoint a -> a)
-> (forall a. Num a => AnEndPoint a -> a)
-> (forall a. Num a => AnEndPoint a -> a)
-> Foldable AnEndPoint
forall a. Eq a => a -> AnEndPoint a -> Bool
forall a. Num a => AnEndPoint a -> a
forall a. Ord a => AnEndPoint a -> a
forall m. Monoid m => AnEndPoint m -> m
forall a. AnEndPoint a -> Bool
forall a. AnEndPoint a -> Int
forall a. AnEndPoint a -> [a]
forall a. (a -> a -> a) -> AnEndPoint a -> a
forall m a. Monoid m => (a -> m) -> AnEndPoint a -> m
forall b a. (b -> a -> b) -> b -> AnEndPoint a -> b
forall a b. (a -> b -> b) -> b -> AnEndPoint a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => AnEndPoint m -> m
fold :: forall m. Monoid m => AnEndPoint m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> AnEndPoint a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> AnEndPoint a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> AnEndPoint a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> AnEndPoint a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> AnEndPoint a -> b
foldr :: forall a b. (a -> b -> b) -> b -> AnEndPoint a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> AnEndPoint a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> AnEndPoint a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> AnEndPoint a -> b
foldl :: forall b a. (b -> a -> b) -> b -> AnEndPoint a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> AnEndPoint a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> AnEndPoint a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> AnEndPoint a -> a
foldr1 :: forall a. (a -> a -> a) -> AnEndPoint a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> AnEndPoint a -> a
foldl1 :: forall a. (a -> a -> a) -> AnEndPoint a -> a
$ctoList :: forall a. AnEndPoint a -> [a]
toList :: forall a. AnEndPoint a -> [a]
$cnull :: forall a. AnEndPoint a -> Bool
null :: forall a. AnEndPoint a -> Bool
$clength :: forall a. AnEndPoint a -> Int
length :: forall a. AnEndPoint a -> Int
$celem :: forall a. Eq a => a -> AnEndPoint a -> Bool
elem :: forall a. Eq a => a -> AnEndPoint a -> Bool
$cmaximum :: forall a. Ord a => AnEndPoint a -> a
maximum :: forall a. Ord a => AnEndPoint a -> a
$cminimum :: forall a. Ord a => AnEndPoint a -> a
minimum :: forall a. Ord a => AnEndPoint a -> a
$csum :: forall a. Num a => AnEndPoint a -> a
sum :: forall a. Num a => AnEndPoint a -> a
$cproduct :: forall a. Num a => AnEndPoint a -> a
product :: forall a. Num a => AnEndPoint a -> a
Foldable,Functor AnEndPoint
Foldable AnEndPoint
(Functor AnEndPoint, Foldable AnEndPoint) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> AnEndPoint a -> f (AnEndPoint b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    AnEndPoint (f a) -> f (AnEndPoint a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> AnEndPoint a -> m (AnEndPoint b))
-> (forall (m :: * -> *) a.
    Monad m =>
    AnEndPoint (m a) -> m (AnEndPoint a))
-> Traversable AnEndPoint
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
AnEndPoint (m a) -> m (AnEndPoint a)
forall (f :: * -> *) a.
Applicative f =>
AnEndPoint (f a) -> f (AnEndPoint a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AnEndPoint a -> m (AnEndPoint b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AnEndPoint a -> f (AnEndPoint b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AnEndPoint a -> f (AnEndPoint b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AnEndPoint a -> f (AnEndPoint b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
AnEndPoint (f a) -> f (AnEndPoint a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
AnEndPoint (f a) -> f (AnEndPoint a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AnEndPoint a -> m (AnEndPoint b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AnEndPoint a -> m (AnEndPoint b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
AnEndPoint (m a) -> m (AnEndPoint a)
sequence :: forall (m :: * -> *) a.
Monad m =>
AnEndPoint (m a) -> m (AnEndPoint a)
Traversable,(forall x. AnEndPoint r -> Rep (AnEndPoint r) x)
-> (forall x. Rep (AnEndPoint r) x -> AnEndPoint r)
-> Generic (AnEndPoint r)
forall x. Rep (AnEndPoint r) x -> AnEndPoint r
forall x. AnEndPoint r -> Rep (AnEndPoint r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (AnEndPoint r) x -> AnEndPoint r
forall r x. AnEndPoint r -> Rep (AnEndPoint r) x
$cfrom :: forall r x. AnEndPoint r -> Rep (AnEndPoint r) x
from :: forall x. AnEndPoint r -> Rep (AnEndPoint r) x
$cto :: forall r x. Rep (AnEndPoint r) x -> AnEndPoint r
to :: forall x. Rep (AnEndPoint r) x -> AnEndPoint r
Generic)

type instance NumType (AnEndPoint r) = r
type instance IxValue (AnEndPoint r) = r


-- | Constructs a closed endpoint
pattern AnClosedE   :: r -> AnEndPoint r
pattern $bAnClosedE :: forall r. r -> AnEndPoint r
$mAnClosedE :: forall {r} {r}. AnEndPoint r -> (r -> r) -> ((# #) -> r) -> r
AnClosedE x = AnEndPoint Closed x

-- | Constructs an Open endpoint
pattern AnOpenE   :: r -> AnEndPoint r
pattern $bAnOpenE :: forall r. r -> AnEndPoint r
$mAnOpenE :: forall {r} {r}. AnEndPoint r -> (r -> r) -> ((# #) -> r) -> r
AnOpenE x = AnEndPoint Open x

-- type instance VectorFamily d (AnEndPoint r) = Boxed.Vector d (AnEndPoint r)

instance Foldable1 AnEndPoint where
  foldMap1 :: forall m a. Semigroup m => (a -> m) -> AnEndPoint a -> m
foldMap1 a -> m
f (AnEndPoint EndPointType
_ a
x) = a -> m
f a
x
instance Traversable1 AnEndPoint where
  traverse1 :: forall (f :: * -> *) a b.
Apply f =>
(a -> f b) -> AnEndPoint a -> f (AnEndPoint b)
traverse1 a -> f b
f (AnEndPoint EndPointType
et a
x) = EndPointType -> b -> AnEndPoint b
forall r. EndPointType -> r -> AnEndPoint r
AnEndPoint EndPointType
et (b -> AnEndPoint b) -> f b -> f (AnEndPoint b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
x


instance IsEndPoint (AnEndPoint r) (AnEndPoint r') where
  _endPoint :: Lens
  (AnEndPoint r)
  (AnEndPoint r')
  (IxValue (AnEndPoint r))
  (IxValue (AnEndPoint r'))
_endPoint = (AnEndPoint r -> r)
-> (AnEndPoint r -> r' -> AnEndPoint r')
-> Lens (AnEndPoint r) (AnEndPoint r') r r'
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (\(AnEndPoint EndPointType
_ r
p) -> r
p) (\(AnEndPoint EndPointType
t r
_) r'
p -> EndPointType -> r' -> AnEndPoint r'
forall r. EndPointType -> r -> AnEndPoint r
AnEndPoint EndPointType
t r'
p)

instance EndPoint_ (AnEndPoint r) where
  endPointType :: AnEndPoint r -> EndPointType
endPointType (AnEndPoint EndPointType
t r
_) = EndPointType
t
  -- | By default we consider endpoints closed
  mkEndPoint :: IxValue (AnEndPoint r) -> AnEndPoint r
mkEndPoint = EndPointType -> r -> AnEndPoint r
forall r. EndPointType -> r -> AnEndPoint r
AnEndPoint EndPointType
Closed

-- | Convert the endpoint into a, AnEndPoint
asAnEndPoint   :: EndPoint_ endPoint => endPoint -> AnEndPoint (IxValue endPoint)
asAnEndPoint :: forall endPoint.
EndPoint_ endPoint =>
endPoint -> AnEndPoint (IxValue endPoint)
asAnEndPoint endPoint
p = case endPoint -> EndPointType
forall endPoint. EndPoint_ endPoint => endPoint -> EndPointType
endPointType endPoint
p of
                   EndPointType
Closed -> IxValue endPoint -> AnEndPoint (IxValue endPoint)
forall r. r -> AnEndPoint r
AnClosedE (endPoint
pendPoint
-> Getting (IxValue endPoint) endPoint (IxValue endPoint)
-> IxValue endPoint
forall s a. s -> Getting a s a -> a
^.Getting (IxValue endPoint) endPoint (IxValue endPoint)
forall endPoint endPoint'.
IsEndPoint endPoint endPoint' =>
Lens endPoint endPoint' (IxValue endPoint) (IxValue endPoint')
Lens endPoint endPoint (IxValue endPoint) (IxValue endPoint)
_endPoint)
                   EndPointType
Open   -> IxValue endPoint -> AnEndPoint (IxValue endPoint)
forall r. r -> AnEndPoint r
AnOpenE   (endPoint
pendPoint
-> Getting (IxValue endPoint) endPoint (IxValue endPoint)
-> IxValue endPoint
forall s a. s -> Getting a s a -> a
^.Getting (IxValue endPoint) endPoint (IxValue endPoint)
forall endPoint endPoint'.
IsEndPoint endPoint endPoint' =>
Lens endPoint endPoint' (IxValue endPoint) (IxValue endPoint')
Lens endPoint endPoint (IxValue endPoint) (IxValue endPoint)
_endPoint)

--------------------------------------------------------------------------------