Relude.Extra.Newtype

relude-1.2.2.0: Safe, performant, user-friendly and lightweight Haskell Standard Library

Copyright | (c) 2018-2023 Kowainik
License | MIT
Maintainer | Kowainik <xrom.xkov@gmail.com>
Stability | Stable
Portability | Portable
Safe Haskell | Safe
Language | Haskell2010

Relude.Extra.Newtype

Description

Functions to ease work with `newtypes`.

Since: 0.2.0

Synopsis

- un :: Coercible a n => n -> a
- wrap :: forall n a. Coercible a n => a -> n
- under :: forall n a. Coercible a n => (n -> n) -> a -> a
- under2 :: forall n a. Coercible a n => (n -> n -> n) -> a -> a -> a
- underF2 :: forall n a. Coercible a (n a) => (n a -> n a -> n a) -> a -> a -> a
- (#.) :: Coercible b c => (b -> c) -> (a -> b) -> a -> c

# Documentation

un :: Coercible a n => n -> a #

Unwraps value from `newtype`.

    >>> newtype Size = Size Int deriving Show
    >>> un @Int (Size 5)
    5
    >>> un (Size 5) == length ['a', 'x', 'b']
    False

Since: 0.2.0

wrap :: forall n a. Coercible a n => a -> n #

Wraps value to `newtype`. Behaves exactly as `un` but has more meaningful name in case you need to convert some value to `newtype`.

    >>> newtype Flag = Flag Bool deriving (Show, Eq)
    >>> wrap False == Flag True
    False

Since: 0.2.0

under :: forall n a. Coercible a n => (n -> n) -> a -> a #

Applies function to the content of `newtype`. This function is not supposed to be used on `newtype`s that are created with the help of smart constructors.

    >>> newtype Foo = Foo Bool deriving Show
    >>> under not (Foo True)
    Foo False
    >>> newtype Bar = Bar String deriving Show
    >>> under (filter (== 'a')) (Bar "abacaba")
    Bar "aaaa"

Since: 0.2.0

under2 :: forall n a. Coercible a n => (n -> n -> n) -> a -> a -> a #

Lift binary function for `newtype`s to work over underlying `newtype` representation.

    >>> under2 @(Sum Int) (<>) (3 :: Int) 4
    7
    >>> under2 @All (<>) True False
    False

Since: 0.3.0

underF2 :: forall n a. Coercible a (n a) => (n a -> n a -> n a) -> a -> a -> a #

Version of `under2` that works on `newtype`s parametrized by their representation. Provided for convenience.

    >>> underF2 @Sum (<>) (3 :: Int) 4
    7
    >>> underF2 @Max (<>) 'p' 't'
    't'

Since: 0.3.0

(#.) :: Coercible b c => (b -> c) -> (a -> b) -> a -> c #

Coercible composition. This function allows to write more efficient implementations of function compositions over `newtypes`.

Since: 0.3.0