module Control.Alt
  ( class Alt, alt, (<|>)
  , module Data.Functor
  ) where

import Data.Functor (class Functor, map, void, ($>), (<#>), (<$), (<$>))
import Data.Semigroup (append)

-- | The `Alt` type class identifies an associative operation on a type
-- | constructor.  It is similar to `Semigroup`, except that it applies to
-- | types of kind `* -> *`, like `Array` or `List`, rather than concrete types
-- | `String` or `Number`.
-- |
-- | `Alt` instances are required to satisfy the following laws:
-- |
-- | - Associativity: `(x <|> y) <|> z == x <|> (y <|> z)`
-- | - Distributivity: `f <$> (x <|> y) == (f <$> x) <|> (f <$> y)`
-- |
-- | For example, the `Array` (`[]`) type is an instance of `Alt`, where
-- | `(<|>)` is defined to be concatenation.
-- |
-- | A common use case is to select the first "valid" item, or, if all items
-- | are "invalid", the last "invalid" item.
-- |
-- | For example:
-- |
-- | ```purescript
-- | import Control.Alt ((<|>))
-- | import Data.Maybe (Maybe(..)
-- | import Data.Either (Either(..))
-- |
-- | Nothing <|> Just 1 <|> Just 2 == Just 1
-- | Left "err" <|> Right 1 <|> Right 2 == Right 1
-- | Left "err 1" <|> Left "err 2" <|> Left "err 3" == Left "err 3"
-- | ```
class Functor f <= Alt f where
  alt :: forall a. f a -> f a -> f a

infixr 3 alt as <|>

instance altArray :: Alt Array where
  alt = append