module Data.Interval.Layers (
  Layers,
  Data.Interval.Layers.fromList,
  Data.Interval.Layers.toList,
  empty,
  singleton,
  insert,
  squash,
  thickness,
  thickest,
  remove,
  baseline,

  -- ** Helper functions
  nestings,
  nestingsAsc,
) where

import Data.Group (Group (..))
import Data.Interval (Adjacency (..), Interval, pattern Whole, pattern (:<>:))
import Data.Interval qualified as I
import Data.Interval.Borel (Borel)
import Data.Interval.Borel qualified as Borel
import Data.Map.Strict qualified as Map
import Prelude hiding (empty)

-- The 'Layers' of an ordered type @x@ are like the 'Borel' sets,
-- but that keeps track of how far each point has been "raised" in @y@.
newtype Layers x y = Layers (Map (Interval x) y)
  deriving
    ( Layers x y -> Layers x y -> Bool
(Layers x y -> Layers x y -> Bool)
-> (Layers x y -> Layers x y -> Bool) -> Eq (Layers x y)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall x y. (Ord x, Eq y) => Layers x y -> Layers x y -> Bool
/= :: Layers x y -> Layers x y -> Bool
$c/= :: forall x y. (Ord x, Eq y) => Layers x y -> Layers x y -> Bool
== :: Layers x y -> Layers x y -> Bool
$c== :: forall x y. (Ord x, Eq y) => Layers x y -> Layers x y -> Bool
Eq
    , Eq (Layers x y)
Eq (Layers x y)
-> (Layers x y -> Layers x y -> Ordering)
-> (Layers x y -> Layers x y -> Bool)
-> (Layers x y -> Layers x y -> Bool)
-> (Layers x y -> Layers x y -> Bool)
-> (Layers x y -> Layers x y -> Bool)
-> (Layers x y -> Layers x y -> Layers x y)
-> (Layers x y -> Layers x y -> Layers x y)
-> Ord (Layers x y)
Layers x y -> Layers x y -> Bool
Layers x y -> Layers x y -> Ordering
Layers x y -> Layers x y -> Layers x y
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 x y. (Ord x, Ord y) => Eq (Layers x y)
forall x y. (Ord x, Ord y) => Layers x y -> Layers x y -> Bool
forall x y. (Ord x, Ord y) => Layers x y -> Layers x y -> Ordering
forall x y.
(Ord x, Ord y) =>
Layers x y -> Layers x y -> Layers x y
min :: Layers x y -> Layers x y -> Layers x y
$cmin :: forall x y.
(Ord x, Ord y) =>
Layers x y -> Layers x y -> Layers x y
max :: Layers x y -> Layers x y -> Layers x y
$cmax :: forall x y.
(Ord x, Ord y) =>
Layers x y -> Layers x y -> Layers x y
>= :: Layers x y -> Layers x y -> Bool
$c>= :: forall x y. (Ord x, Ord y) => Layers x y -> Layers x y -> Bool
> :: Layers x y -> Layers x y -> Bool
$c> :: forall x y. (Ord x, Ord y) => Layers x y -> Layers x y -> Bool
<= :: Layers x y -> Layers x y -> Bool
$c<= :: forall x y. (Ord x, Ord y) => Layers x y -> Layers x y -> Bool
< :: Layers x y -> Layers x y -> Bool
$c< :: forall x y. (Ord x, Ord y) => Layers x y -> Layers x y -> Bool
compare :: Layers x y -> Layers x y -> Ordering
$ccompare :: forall x y. (Ord x, Ord y) => Layers x y -> Layers x y -> Ordering
$cp1Ord :: forall x y. (Ord x, Ord y) => Eq (Layers x y)
Ord
    , Int -> Layers x y -> ShowS
[Layers x y] -> ShowS
Layers x y -> String
(Int -> Layers x y -> ShowS)
-> (Layers x y -> String)
-> ([Layers x y] -> ShowS)
-> Show (Layers x y)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall x y. (Ord x, Show x, Show y) => Int -> Layers x y -> ShowS
forall x y. (Ord x, Show x, Show y) => [Layers x y] -> ShowS
forall x y. (Ord x, Show x, Show y) => Layers x y -> String
showList :: [Layers x y] -> ShowS
$cshowList :: forall x y. (Ord x, Show x, Show y) => [Layers x y] -> ShowS
show :: Layers x y -> String
$cshow :: forall x y. (Ord x, Show x, Show y) => Layers x y -> String
showsPrec :: Int -> Layers x y -> ShowS
$cshowsPrec :: forall x y. (Ord x, Show x, Show y) => Int -> Layers x y -> ShowS
Show
    , a -> Layers x b -> Layers x a
(a -> b) -> Layers x a -> Layers x b
(forall a b. (a -> b) -> Layers x a -> Layers x b)
-> (forall a b. a -> Layers x b -> Layers x a)
-> Functor (Layers x)
forall a b. a -> Layers x b -> Layers x a
forall a b. (a -> b) -> Layers x a -> Layers x b
forall x a b. a -> Layers x b -> Layers x a
forall x a b. (a -> b) -> Layers x a -> Layers x b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Layers x b -> Layers x a
$c<$ :: forall x a b. a -> Layers x b -> Layers x a
fmap :: (a -> b) -> Layers x a -> Layers x b
$cfmap :: forall x a b. (a -> b) -> Layers x a -> Layers x b
Functor
    , (forall x. Layers x y -> Rep (Layers x y) x)
-> (forall x. Rep (Layers x y) x -> Layers x y)
-> Generic (Layers x y)
forall x. Rep (Layers x y) x -> Layers x y
forall x. Layers x y -> Rep (Layers x y) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall x y x. Rep (Layers x y) x -> Layers x y
forall x y x. Layers x y -> Rep (Layers x y) x
$cto :: forall x y x. Rep (Layers x y) x -> Layers x y
$cfrom :: forall x y x. Layers x y -> Rep (Layers x y) x
Generic
    , Typeable
    )

instance (Ord x, Semigroup y) => Semigroup (Layers x y) where
  Layers Map (Interval x) y
s1 <> :: Layers x y -> Layers x y -> Layers x y
<> Layers Map (Interval x) y
s2 =
    let s :: [(Interval x, y)]
s = Map (Interval x) y -> [(Interval x, y)]
forall k a. Map k a -> [(k, a)]
Map.toAscList (Map (Interval x) y -> [(Interval x, y)])
-> Map (Interval x) y -> [(Interval x, y)]
forall a b. (a -> b) -> a -> b
$ (y -> y -> y)
-> Map (Interval x) y -> Map (Interval x) y -> Map (Interval x) y
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith y -> y -> y
forall a. Semigroup a => a -> a -> a
(<>) Map (Interval x) y
s1 Map (Interval x) y
s2
     in Map (Interval x) y -> Layers x y
forall x y. Map (Interval x) y -> Layers x y
Layers (Map (Interval x) y -> Layers x y)
-> Map (Interval x) y -> Layers x y
forall a b. (a -> b) -> a -> b
$ [(Interval x, y)] -> Map (Interval x) y
forall k a. Eq k => [(k, a)] -> Map k a
Map.fromAscList ([(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc [(Interval x, y)]
s)

instance (Ord x, Semigroup y) => Monoid (Layers x y) where
  mempty :: Layers x y
mempty = Map (Interval x) y -> Layers x y
forall x y. Map (Interval x) y -> Layers x y
Layers Map (Interval x) y
forall a. Monoid a => a
mempty

instance (Ord x, Group y) => Group (Layers x y) where
  invert :: Layers x y -> Layers x y
invert (Layers Map (Interval x) y
s) = Map (Interval x) y -> Layers x y
forall x y. Map (Interval x) y -> Layers x y
Layers ((y -> y) -> Map (Interval x) y -> Map (Interval x) y
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap y -> y
forall m. Group m => m -> m
invert Map (Interval x) y
s)

-- | A blank canvas.
empty :: Layers x y
empty :: Layers x y
empty = Map (Interval x) y -> Layers x y
forall x y. Map (Interval x) y -> Layers x y
Layers Map (Interval x) y
forall k a. Map k a
Map.empty

-- | @singleton ix y@ is the rectangle with base @ix@ of thickness @y@.
singleton :: (Ord x) => Interval x -> y -> Layers x y
singleton :: Interval x -> y -> Layers x y
singleton Interval x
ix y
y = Map (Interval x) y -> Layers x y
forall x y. Map (Interval x) y -> Layers x y
Layers (Interval x -> y -> Map (Interval x) y
forall k a. k -> a -> Map k a
Map.singleton Interval x
ix y
y)

-- | Draw the 'Layers' of specified bases and thicknesses.
fromList :: (Ord x, Semigroup y) => [(Interval x, y)] -> Layers x y
fromList :: [(Interval x, y)] -> Layers x y
fromList = ((Interval x, y) -> Layers x y) -> [(Interval x, y)] -> Layers x y
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((Interval x -> y -> Layers x y) -> (Interval x, y) -> Layers x y
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Interval x -> y -> Layers x y
forall x y. Ord x => Interval x -> y -> Layers x y
singleton)

-- | Get all of the bases and thicknesses in the 'Layers'.
toList :: (Ord x) => Layers x y -> [(Interval x, y)]
toList :: Layers x y -> [(Interval x, y)]
toList (Layers Map (Interval x) y
s) = Map (Interval x) y -> [(Interval x, y)]
forall k a. Map k a -> [(k, a)]
Map.toList Map (Interval x) y
s

-- | Ignore the 'Layers' and focus only on whether points are 'within'
-- any contained 'Interval' or not.
squash :: (Ord x) => Layers x y -> Borel x
squash :: Layers x y -> Borel x
squash (Layers Map (Interval x) y
s) = (Interval x -> Borel x) -> [Interval x] -> Borel x
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Interval x -> Borel x
forall x. Ord x => Interval x -> Borel x
Borel.singleton (Map (Interval x) y -> [Interval x]
forall k a. Map k a -> [k]
Map.keys Map (Interval x) y
s)

-- | Get the thickness of the 'Layers' at a point.
thickness :: (Ord x, Monoid y) => x -> Layers x y -> y
thickness :: x -> Layers x y -> y
thickness x
x (Layers Map (Interval x) y
s) = case Interval x -> Map (Interval x) y -> Maybe (Interval x, y)
forall k v. Ord k => k -> Map k v -> Maybe (k, v)
Map.lookupLE (x
x x -> x -> Interval x
forall x. Ord x => x -> x -> Interval x
:<>: x
x) Map (Interval x) y
s of
  Just (Interval x
ix, y
y) | x
x x -> Interval x -> Bool
forall x. Ord x => x -> Interval x -> Bool
`I.within` Interval x
ix -> y
y
  Maybe (Interval x, y)
_ -> y
forall a. Monoid a => a
mempty

-- | Where and how thick is the thickest 'Interval'?
thickest :: (Ord x, Ord y) => Layers x y -> Maybe (Interval x, y)
thickest :: Layers x y -> Maybe (Interval x, y)
thickest (Layers Map (Interval x) y
s) =
  (Maybe (Interval x, y) -> Interval x -> y -> Maybe (Interval x, y))
-> Maybe (Interval x, y)
-> Map (Interval x) y
-> Maybe (Interval x, y)
forall a k b. (a -> k -> b -> a) -> a -> Map k b -> a
Map.foldlWithKey'
    ( \Maybe (Interval x, y)
acc Interval x
ix y
y -> (Interval x, y) -> Maybe (Interval x, y)
forall a. a -> Maybe a
Just ((Interval x, y) -> Maybe (Interval x, y))
-> (Interval x, y) -> Maybe (Interval x, y)
forall a b. (a -> b) -> a -> b
$ case Maybe (Interval x, y)
acc of
        Maybe (Interval x, y)
Nothing -> (Interval x
ix, y
y)
        Just (Interval x
ix', y
y') -> if y
y y -> y -> Bool
forall a. Ord a => a -> a -> Bool
> y
y' then (Interval x
ix, y
y) else (Interval x
ix', y
y')
    )
    Maybe (Interval x, y)
forall a. Maybe a
Nothing
    Map (Interval x) y
s

-- | @insert ix y l@ draws over @l@ a rectangle with base @ix@ of thickness @y@.
insert ::
  (Ord x, Semigroup y) =>
  Interval x ->
  y ->
  Layers x y ->
  Layers x y
insert :: Interval x -> y -> Layers x y -> Layers x y
insert Interval x
ix y
y = Layers x y -> Layers x y -> Layers x y
forall a. Monoid a => a -> a -> a
mappend (Interval x -> y -> Layers x y
forall x y. Ord x => Interval x -> y -> Layers x y
singleton Interval x
ix y
y)

nestings ::
  (Ord x, Semigroup y) =>
  [(Interval x, y)] ->
  [(Interval x, y)]
nestings :: [(Interval x, y)] -> [(Interval x, y)]
nestings = [(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc ([(Interval x, y)] -> [(Interval x, y)])
-> ([(Interval x, y)] -> [(Interval x, y)])
-> [(Interval x, y)]
-> [(Interval x, y)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Interval x, y) -> Interval x)
-> [(Interval x, y)] -> [(Interval x, y)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn (Interval x, y) -> Interval x
forall a b. (a, b) -> a
fst

nestingsAsc ::
  (Ord x, Semigroup y) =>
  [(Interval x, y)] ->
  [(Interval x, y)]
nestingsAsc :: [(Interval x, y)] -> [(Interval x, y)]
nestingsAsc = \case
  (Interval x
i', y
iy) : (Interval x
j', y
jy) : [(Interval x, y)]
js -> case Interval x -> Interval x -> Adjacency x
forall x. Ord x => Interval x -> Interval x -> Adjacency x
I.adjacency Interval x
i' Interval x
j' of
    Before Interval x
i Interval x
j -> (Interval x
i, y
iy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc ((Interval x
j, y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)]
js)
    Meets Interval x
i Interval x
j Interval x
k -> (Interval x
i, y
iy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc ((Interval x
j, y
iy y -> y -> y
forall a. Semigroup a => a -> a -> a
<> y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: (Interval x
k, y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)]
js)
    Overlaps Interval x
i Interval x
j Interval x
k ->
      [(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc ([(Interval x, y)] -> [(Interval x, y)])
-> [(Interval x, y)] -> [(Interval x, y)]
forall a b. (a -> b) -> a -> b
$
        (Interval x
i, y
iy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
:
        (Interval x
j, y
iy y -> y -> y
forall a. Semigroup a => a -> a -> a
<> y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
:
        (Interval x
k, y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)]
js
    Starts Interval x
i Interval x
j ->
      [(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc ([(Interval x, y)] -> [(Interval x, y)])
-> [(Interval x, y)] -> [(Interval x, y)]
forall a b. (a -> b) -> a -> b
$
        (Interval x
i, y
iy y -> y -> y
forall a. Semigroup a => a -> a -> a
<> y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
:
        (Interval x
j, y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)]
js
    During Interval x
i Interval x
j Interval x
k ->
      [(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc ([(Interval x, y)] -> [(Interval x, y)])
-> [(Interval x, y)] -> [(Interval x, y)]
forall a b. (a -> b) -> a -> b
$
        (Interval x
i, y
iy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
:
        (Interval x
j, y
iy y -> y -> y
forall a. Semigroup a => a -> a -> a
<> y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
:
        (Interval x
k, y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)]
js
    Finishes Interval x
i Interval x
j ->
      [(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc ([(Interval x, y)] -> [(Interval x, y)])
-> [(Interval x, y)] -> [(Interval x, y)]
forall a b. (a -> b) -> a -> b
$
        (Interval x
i, y
iy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
:
        (Interval x
j, y
iy y -> y -> y
forall a. Semigroup a => a -> a -> a
<> y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)]
js
    Identical Interval x
i -> (Interval x
i, y
iy y -> y -> y
forall a. Semigroup a => a -> a -> a
<> y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc [(Interval x, y)]
js
    FinishedBy Interval x
i Interval x
j ->
      [(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc ([(Interval x, y)] -> [(Interval x, y)])
-> [(Interval x, y)] -> [(Interval x, y)]
forall a b. (a -> b) -> a -> b
$
        (Interval x
i, y
iy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
:
        (Interval x
j, y
iy y -> y -> y
forall a. Semigroup a => a -> a -> a
<> y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)]
js
    Contains Interval x
i Interval x
j Interval x
k ->
      [(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc ([(Interval x, y)] -> [(Interval x, y)])
-> [(Interval x, y)] -> [(Interval x, y)]
forall a b. (a -> b) -> a -> b
$
        (Interval x
i, y
iy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
:
        (Interval x
j, y
iy y -> y -> y
forall a. Semigroup a => a -> a -> a
<> y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
:
        (Interval x
k, y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)]
js
    StartedBy Interval x
i Interval x
j ->
      [(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc ([(Interval x, y)] -> [(Interval x, y)])
-> [(Interval x, y)] -> [(Interval x, y)]
forall a b. (a -> b) -> a -> b
$
        (Interval x
i, y
iy y -> y -> y
forall a. Semigroup a => a -> a -> a
<> y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
:
        (Interval x
j, y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)]
js
    OverlappedBy Interval x
i Interval x
j Interval x
k ->
      [(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc ([(Interval x, y)] -> [(Interval x, y)])
-> [(Interval x, y)] -> [(Interval x, y)]
forall a b. (a -> b) -> a -> b
$
        (Interval x
i, y
iy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
:
        (Interval x
j, y
iy y -> y -> y
forall a. Semigroup a => a -> a -> a
<> y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
:
        (Interval x
k, y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)]
js
    MetBy Interval x
i Interval x
j Interval x
k -> (Interval x
i, y
iy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc ((Interval x
j, y
iy y -> y -> y
forall a. Semigroup a => a -> a -> a
<> y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: (Interval x
k, y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)]
js)
    After Interval x
i Interval x
j -> (Interval x
i, y
iy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)] -> [(Interval x, y)]
forall x y.
(Ord x, Semigroup y) =>
[(Interval x, y)] -> [(Interval x, y)]
nestingsAsc ((Interval x
j, y
jy) (Interval x, y) -> [(Interval x, y)] -> [(Interval x, y)]
forall a. a -> [a] -> [a]
: [(Interval x, y)]
js)
  [(Interval x, y)]
x -> [(Interval x, y)]
x

-- | Take away a thickness over a given base from the 'Layers'.
remove :: (Ord x, Group y) => y -> Interval x -> Layers x y -> Layers x y
remove :: y -> Interval x -> Layers x y -> Layers x y
remove y
y Interval x
ix = Interval x -> y -> Layers x y -> Layers x y
forall x y.
(Ord x, Semigroup y) =>
Interval x -> y -> Layers x y -> Layers x y
insert Interval x
ix (y -> y
forall m. Group m => m -> m
invert y
y)

-- | Add the given thickness to every point.
baseline :: (Ord x, Semigroup y) => y -> Layers x y -> Layers x y
baseline :: y -> Layers x y -> Layers x y
baseline = Interval x -> y -> Layers x y -> Layers x y
forall x y.
(Ord x, Semigroup y) =>
Interval x -> y -> Layers x y -> Layers x y
insert Interval x
forall x. Ord x => Interval x
Whole