Safe Haskell | Safe |
---|---|
Language | Haskell2010 |
The Newtype
typeclass and related functions: op
, ala
, ala'
, under
.
Primarly pulled from Conor McBride's Epigram work. Some examples:
ala Sum foldMap [1,2,3,4] -- foldMaps the list ala the Sum newtype. This results in 10.
ala Product foldMap [1,2,3,4] -- foldMaps the list ala the Product newtype. This results in 24.
ala Endo foldMap [(+1), (+2), (subtract 1), (*2)] 3 -- foldMaps the list ala the Endo newtype. This results in 8.
NB: foldMap
is a generalized mconcatMap
which is a generalized concatMap
.
This package includes Newtype
instances for all the (non-GHC/foreign)
newtypes in base (as seen in the examples).
However, there are neat things you can do with this with
any newtype and you should definitely define your own Newtype
instances for the power of this library.
For example, see ala Cont traverse
, with the proper Newtype
instance for Cont.
You can easily define new instances for your newtypes with the help of GHC.Generics
import GHC.Generics (...) newtype Example = Example Int deriving (Generic) instance Newtype Example
This avoids the use of Template Haskell (TH) to get new instances.
- class Newtype n where
- op :: (Newtype n, o ~ O n) => (o -> n) -> n -> o
- ala :: (Newtype n, Newtype n', o' ~ O n', o ~ O n) => (o -> n) -> ((o -> n) -> b -> n') -> b -> o'
- ala' :: (Newtype n, Newtype n', o' ~ O n', o ~ O n) => (o -> n) -> ((a -> n) -> b -> n') -> (a -> o) -> b -> o'
- under :: (Newtype n, Newtype n', o' ~ O n', o ~ O n) => (o -> n) -> (n -> n') -> o -> o'
- over :: (Newtype n, Newtype n', o' ~ O n', o ~ O n) => (o -> n) -> (o -> o') -> n -> n'
- underF :: (Newtype n, Newtype n', o' ~ O n', o ~ O n, Functor f, Functor g) => (o -> n) -> (f n -> g n') -> f o -> g o'
- overF :: (Newtype n, Newtype n', o' ~ O n', o ~ O n, Functor f, Functor g) => (o -> n) -> (f o -> g o') -> f n -> g n'
Documentation
As long as the type n
is an instance of Generic, you can create an instance
with just instance Newtype n
pack :: (Generic n, GNewtype (Rep n), O n ~ GO (Rep n)) => O n -> n #
unpack :: (Generic n, GNewtype (Rep n), O n ~ GO (Rep n)) => n -> O n #
Newtype All # | |
Newtype Any # | |
Newtype (Identity a) # | Since: 0.5.1 |
Newtype (Min a) # | Since: 0.5.1 |
Newtype (Max a) # | Since: 0.5.1 |
Newtype (First a) # | Since: 0.5.1 |
Newtype (Last a) # | Since: 0.5.1 |
Newtype (WrappedMonoid m) # | Since: 0.5.1 |
Newtype (Option a) # | Since: 0.5.1 |
Newtype (Fixed a) # | Since: 0.5.1 |
Newtype (ZipList a) # | |
Newtype (Dual a) # | Since: 0.5.1 |
Newtype (Endo a) # | |
Newtype (Sum a) # | |
Newtype (Product a) # | |
Newtype (First a) # | |
Newtype (Last a) # | |
Newtype (Down a) # | Since: 0.5.1 |
Newtype (WrappedMonad m a) # | |
Newtype (ArrowMonad a b) # | |
Newtype (WrappedArrow a b c) # | |
Newtype (Kleisli m a b) # | |
Newtype (Const * a x) # | |
Newtype (Alt * f a) # | Since: 0.5.1 |
Newtype (Compose * * f g a) # | Since: 0.5.1 |
op :: (Newtype n, o ~ O n) => (o -> n) -> n -> o #
This function serves two purposes:
- Giving you the unpack of a newtype without you needing to remember the name.
- Showing that the first parameter is completely ignored on the value level, meaning the only reason you pass in the constructor is to provide type information. Typeclasses sure are neat.
ala :: (Newtype n, Newtype n', o' ~ O n', o ~ O n) => (o -> n) -> ((o -> n) -> b -> n') -> b -> o' #
The workhorse of the package. Given a pack and a "higher order function", it handles the packing and unpacking, and just sends you back a regular old function, with the type varying based on the hof you passed.
The reason for the signature of the hof is due to ala
not caring about structure.
To illustrate why this is important, another function in this package is under
.
It is not extremely useful; under2
might be more useful (with e.g., mappend
),
but then we already digging the trench of
"What about under3
? under4
?".
The solution utilized here is to just hand off the "packer" to the hof.
That way your structure can be imposed in the hof,
whatever you may want it to be (e.g., List, Traversable).
ala' :: (Newtype n, Newtype n', o' ~ O n', o ~ O n) => (o -> n) -> ((a -> n) -> b -> n') -> (a -> o) -> b -> o' #
This is the original function seen in Conor McBride's work.
The way it differs from the ala
function in this package,
is that it provides an extra hook into the "packer" passed to the hof.
However, this normally ends up being id
, so ala
wraps this function and
passes id
as the final parameter by default.
If you want the convenience of being able to hook right into the hof,
you may use this function.
under :: (Newtype n, Newtype n', o' ~ O n', o ~ O n) => (o -> n) -> (n -> n') -> o -> o' #
A very simple operation involving running the function 'under' the newtype.
Suffers from the problems mentioned in the ala
function's documentation.
over :: (Newtype n, Newtype n', o' ~ O n', o ~ O n) => (o -> n) -> (o -> o') -> n -> n' #
The opposite of under
. I.e., take a function which works on the
underlying types, and switch it to a function that works on the newtypes.