Const Functor Instance.

// Haskell instance
instance Functor (Const c) where
    fmap :: (a -> b) -> Const c a -> Const c b
    fmap _ (Const v) = Const v  

Examples

const_functor().fmap(int.to_string)(Const(True))
// -> Const(True)

Either Functor.

Examples

either_functor().fmap(bool.negate)(Left(27))
// -> Left(27)
either_functor().fmap(bool.negate)(Right(False))
// -> Right(True)

(->) Functor Instance.

// Haskell instance
instance Functor ((->) r) where
    fmap :: (a -> b) -> (r -> a) -> (r -> b)
    fmap f g = f ∘ g

Examples

let f = fn(x) { x % 2 == 0 }
let g = bool.to_string

function_functor().fmap(g)(f)(19)
// -> "False"

Identity Functor Instance.

// Haskell implementation
instance Functor Maybe where
    fmap :: (a -> b) -> Identity a -> Identity b
    fmap f (Identity x) = Identity(f x)

Examples

let f = fn(x: Int) -> Bool { x % 2 == 0 }
identity_functor().fmap(f)(Identity(5))
// -> Identity(False)

List Functor Instance.

// Haskell instance
instance Functor [] where
    fmap :: (a -> b) -> [a] -> [b]
    fmap _ [] = []
    fmap f (x:xs) = (f x):(fmap f xs)

Examples

list_functor().fmap(int.to_string)([1, 3, 4])
// -> ["1", "3", "4"]

Option Functor Instance (generic over a and b).

// Haskell instance
instance Functor Maybe where
    fmap :: (a -> b) -> Maybe a -> Maybe b
    fmap _ Nothing = Nothing
    fmap f (Just x) = Just (f x)

Examples

let double = fn(x) { x * 2 }
option_functor().fmap(double)(None)
// -> None
Some(2)
|> option_functor().fmap(double)
// -> Some(4)

Pair Functor.

Examples

pair_functor().fmap(bool.negate)(Pair(9, False))
// -> Pair(9, True)

Reader Functor Instance.

// Haskell implementation
instance Functor (Reader r) where
  fmap :: (a -> b) -> Reader r a -> Reader r b
  fmap f g = f ∘ g

Examples

let ra = Reader(fn(x) { x % 2 == 0 })
let f = bool.to_string

reader_functor().fmap(f)(ra).apply(19)
// -> "False"

Result Functor Instance.

Examples

result_functor().fmap(int.to_string)(Ok(72))
// -> Ok("72")
result_functor().fmap(int.to_string)(Error("Not a number"))
// -> Error("Not a number")

Triple Functor.

Examples

triple_functor().fmap(bool.negate)(#("abc", 9, False))
// -> #("abc", 9, True)

Tuple Functor.

Examples

tuple_functor().fmap(bool.negate)(#(9, False))
// -> #(9, True)

Writer Functor Instance.

// Haskell Instance
fmap :: (a -> b) -> Writer a -> Writer b
fmap f = id >=> (\x -> return (f x))

Examples

monad.Writer(16, "message")
|> writer_functor().fmap(fn(x) { x % 4 == 0 })
// -> monad.Writer(True, "message")