-----------------------------------------------------------------------------
-- |
-- Module      :  Miso.Util
-- Copyright   :  (C) 2016-2025 David M. Johnson
-- License     :  BSD3-style (see the file LICENSE)
-- Maintainer  :  David M. Johnson <code@dmj.io>
-- Stability   :  experimental
-- Portability :  non-portable
----------------------------------------------------------------------------
module Miso.Util
  ( withFoldable
  , conditionalViews
  , oneOf
  , enclosed
  , optionalDefault
  , exists
  , sepBy1
  , sepBy
  , between
  ) where
-----------------------------------------------------------------------------
import           Data.Maybe (isJust, fromMaybe)
import           Control.Applicative (Alternative, many, empty, (<|>), optional)
import           Data.Foldable (toList)
-----------------------------------------------------------------------------
-- | Generic @map@ function, useful for creating @View@s from the elements of
-- some @Foldable@. Particularly handy for @Maybe@, as shown in the example
-- below.
--
-- @
-- view model =
--     div_ [] $
--      withFoldable (model ^. mSomeMaybeVal) $ \\someVal ->
--         p_ [] [ text $ "Hey, look at this value: " <> ms (show someVal) ]
-- @
withFoldable :: Foldable t => t a -> (a -> b) -> [b]
withFoldable :: forall (t :: * -> *) a b. Foldable t => t a -> (a -> b) -> [b]
withFoldable t a
ta a -> b
f = (a -> b) -> [a] -> [b]
forall a b. (a -> b) -> [a] -> [b]
map a -> b
f (t a -> [a]
forall a. t a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList t a
ta)
-----------------------------------------------------------------------------
-- | Hides the @View@s if the condition is False. Shows them when the condition
-- is True.
conditionalViews :: Bool -> [view] -> [view]
conditionalViews :: forall view. Bool -> [view] -> [view]
conditionalViews Bool
condition [view]
views =
    if Bool
condition
    then [view]
views
    else []
-----------------------------------------------------------------------------
oneOf :: Alternative f => [f a] -> f a
oneOf :: forall (f :: * -> *) a. Alternative f => [f a] -> f a
oneOf = (f a -> f a -> f a) -> f a -> [f a] -> f a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr f a -> f a -> f a
forall a. f a -> f a -> f a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
(<|>) f a
forall a. f a
forall (f :: * -> *) a. Alternative f => f a
empty
----------------------------------------------------------------------------
enclosed :: Applicative f => f a -> f b -> f c -> f c
enclosed :: forall (f :: * -> *) a b c.
Applicative f =>
f a -> f b -> f c -> f c
enclosed f a
l f b
r f c
x = f a
l f a -> f c -> f c
forall a b. f a -> f b -> f b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> f c
x f c -> f b -> f c
forall a b. f a -> f b -> f a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* f b
r
----------------------------------------------------------------------------
optionalDefault :: Alternative f => b -> f b -> f b
optionalDefault :: forall (f :: * -> *) b. Alternative f => b -> f b -> f b
optionalDefault b
def f b
p = b -> Maybe b -> b
forall a. a -> Maybe a -> a
fromMaybe b
def (Maybe b -> b) -> f (Maybe b) -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f b -> f (Maybe b)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional f b
p
----------------------------------------------------------------------------
exists :: Alternative f => f a -> f Bool
exists :: forall (f :: * -> *) a. Alternative f => f a -> f Bool
exists f a
p = Maybe a -> Bool
forall a. Maybe a -> Bool
isJust (Maybe a -> Bool) -> f (Maybe a) -> f Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f a -> f (Maybe a)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional f a
p
----------------------------------------------------------------------------
sepBy1 :: Alternative m => m sep -> m a -> m [a]
sepBy1 :: forall (m :: * -> *) sep a. Alternative m => m sep -> m a -> m [a]
sepBy1 m sep
sep m a
p = (:) (a -> [a] -> [a]) -> m a -> m ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m a
p m ([a] -> [a]) -> m [a] -> m [a]
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m a -> m [a]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (m sep
sep m sep -> m a -> m a
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m a
p)
----------------------------------------------------------------------------
sepBy :: Alternative m => m sep -> m a -> m [a]
sepBy :: forall (m :: * -> *) sep a. Alternative m => m sep -> m a -> m [a]
sepBy m sep
sep m a
p = m sep -> m a -> m [a]
forall (m :: * -> *) sep a. Alternative m => m sep -> m a -> m [a]
sepBy1 m sep
sep m a
p m [a] -> m [a] -> m [a]
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [a] -> m [a]
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
----------------------------------------------------------------------------
between :: Applicative f => f a -> f b -> f c -> f (b, c)
between :: forall (f :: * -> *) a b c.
Applicative f =>
f a -> f b -> f c -> f (b, c)
between f a
c f b
l f c
r = (,) (b -> c -> (b, c)) -> f b -> f (c -> (b, c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f b
l f (c -> (b, c)) -> f c -> f (b, c)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (f a
c f a -> f c -> f c
forall a b. f a -> f b -> f b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> f c
r)
----------------------------------------------------------------------------