optional-args-1.0.2: Optional function arguments
Safe HaskellSafe-Inferred
LanguageHaskell2010

Data.Optional

Description

Use the Optional type for optional function arguments. For example:

import Data.Optional

greet :: Optional String -> String
greet (Specific name) = "Hello, " ++ name
greet  Default        = "Hello"
>>> greet (Specific "John")
"Hello, John"
>>> greet Default
"Hello"

The Optional type overloads as many Haskell literals as possible so that you do not need to wrap values in Specific. For example, if you enable the OverloadedStrings extension you can use a naked string literal instead:

>>> :set -XOverloadedStrings
>>> greet "John"
"Hello, John"

The Optional type also implements Num and Fractional, so you can use numeric literals in place of Optional values:

birthday :: Optional Int -> String
birthday (Specific age) = "You are " ++ show age ++ " years old!"
birthday  Default       = "You are one year older!"
>>> birthday 20
"You are 20 years old!"
>>> birthday Default
"You are one year older!"

The IsString, Num, and Fractional instances are recursive, so you can wrap your types in a more descriptive newtype and derive IsString, Num or Fractional:

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

import Data.Optional
import Data.String (IsString)

newtype Name = Name { getName :: String } deriving (IsString)

greet :: Optional Name -> String
greet (Specific name) = "Hello, " ++ getName name
greet  Default        = "Hello"

newtype Age = Age { getAge :: Int } deriving (Num)

birthday :: Optional Age -> String
birthday (Specific age) = "You are " ++ show (getAge age) ++ " years old!"
birthday  Default       = "You are one year older!"

... and you would still be able to provide naked numeric or string literals:

>>> :set -XOverloadedStrings
>>> greet "John"
"Hello, John"
>>> birthday 20
"You are 20 years old!"

You can use empty as a short-hand for a Default argument:

>>> greet empty
"Hello"
>>> birthday empty
"You are one year older!"

You can also use pure as a short-hand for a Specific argument:

>>> greet (pure "John")
"Hello, John"
>>> birthday (pure 20)
"You are 20 years old!"
Synopsis

Optional

data Optional a Source #

A function argument that has a Default value

Constructors

Default 
Specific a 

Instances

Instances details
Foldable Optional Source # 
Instance details

Defined in Data.Optional

Methods

fold :: Monoid m => Optional m -> m Source #

foldMap :: Monoid m => (a -> m) -> Optional a -> m Source #

foldMap' :: Monoid m => (a -> m) -> Optional a -> m Source #

foldr :: (a -> b -> b) -> b -> Optional a -> b Source #

foldr' :: (a -> b -> b) -> b -> Optional a -> b Source #

foldl :: (b -> a -> b) -> b -> Optional a -> b Source #

foldl' :: (b -> a -> b) -> b -> Optional a -> b Source #

foldr1 :: (a -> a -> a) -> Optional a -> a Source #

foldl1 :: (a -> a -> a) -> Optional a -> a Source #

toList :: Optional a -> [a] Source #

null :: Optional a -> Bool Source #

length :: Optional a -> Int Source #

elem :: Eq a => a -> Optional a -> Bool Source #

maximum :: Ord a => Optional a -> a Source #

minimum :: Ord a => Optional a -> a Source #

sum :: Num a => Optional a -> a Source #

product :: Num a => Optional a -> a Source #

Traversable Optional Source # 
Instance details

Defined in Data.Optional

Methods

traverse :: Applicative f => (a -> f b) -> Optional a -> f (Optional b) Source #

sequenceA :: Applicative f => Optional (f a) -> f (Optional a) Source #

mapM :: Monad m => (a -> m b) -> Optional a -> m (Optional b) Source #

sequence :: Monad m => Optional (m a) -> m (Optional a) Source #

Alternative Optional Source # 
Instance details

Defined in Data.Optional

Applicative Optional Source # 
Instance details

Defined in Data.Optional

Methods

pure :: a -> Optional a Source #

(<*>) :: Optional (a -> b) -> Optional a -> Optional b Source #

liftA2 :: (a -> b -> c) -> Optional a -> Optional b -> Optional c Source #

(*>) :: Optional a -> Optional b -> Optional b Source #

(<*) :: Optional a -> Optional b -> Optional a Source #

Functor Optional Source # 
Instance details

Defined in Data.Optional

Methods

fmap :: (a -> b) -> Optional a -> Optional b Source #

(<$) :: a -> Optional b -> Optional a Source #

Monad Optional Source # 
Instance details

Defined in Data.Optional

Methods

(>>=) :: Optional a -> (a -> Optional b) -> Optional b Source #

(>>) :: Optional a -> Optional b -> Optional b Source #

return :: a -> Optional a Source #

MonadPlus Optional Source # 
Instance details

Defined in Data.Optional

IsString a => IsString (Optional a) Source # 
Instance details

Defined in Data.Optional

Monoid a => Monoid (Optional a) Source # 
Instance details

Defined in Data.Optional

Semigroup a => Semigroup (Optional a) Source # 
Instance details

Defined in Data.Optional

Num a => Num (Optional a) Source # 
Instance details

Defined in Data.Optional

Fractional a => Fractional (Optional a) Source # 
Instance details

Defined in Data.Optional

Show a => Show (Optional a) Source # 
Instance details

Defined in Data.Optional

Eq a => Eq (Optional a) Source # 
Instance details

Defined in Data.Optional

Methods

(==) :: Optional a -> Optional a -> Bool Source #

(/=) :: Optional a -> Optional a -> Bool Source #

defaultTo :: a -> Optional a -> a Source #

The defaultTo function takes a default value and an Optional value. If the Optional is Default, it returns the default value; otherwise, it returns the value contained in the Optional.

fromOptional :: Alternative f => Optional a -> f a Source #

Convert an Optional value into an instance of Alternative.

optional :: b -> (a -> b) -> Optional a -> b Source #

The optional function takes a default value, a function, and an Optional value. If the Optional value is Default, the function returns the default value. Otherwise, it applies the function to the value inside the Optional and returns the result.

Re-exports

empty :: Alternative f => f a Source #

The identity of <|>

pure :: Applicative f => a -> f a Source #

Lift a value.