Anatomy of Maybe — Part II — Functor: Understanding Functional Programming Thru Optionality

-- conceptually this is just like a Maybe
type Hand a = Holding a | Empty

Hand.map eat (Holding Apple)
--=> Holding EatenApple

map : (a -> b) -> Maybe a -> Maybe b
map f maybe =
    case maybe of
        Just value ->
            Just (f value)
        Nothing ->
            Nothing

m : Maybe Int
m = Maybe.map ((*) 2) <| Just 4
--=> Just 8

n : Maybe Int
n = Maybe.map ((*) 2) <| Nothing
--=> Nothing

o : Maybe String
o = Maybe.map toString <| Just 10
--=> Just "10"

p : Maybe String
p = Maybe.map toString <| Nothing
--=> Nothing

q : Maybe (List Int)
q = Maybe.map (List.map ((*) 2)) <| Just [ 0, 2, 4 ]
--=> Just [ 0, 4, 8 ]

r : Maybe (List Int)
r = Maybe.map (List.map ((*) 2) <| Nothing
--=> Nothing

const m = Maybe.Just(4).map((x) => x * 2)
//=> Object { value: 8 }

const n = Maybe.Nothing().map((x) => x * 2)
//=> Object {  }

const o = Maybe.Just(10).map((x) => x.toString())
//=> Object { value: "10" }

const p = Maybe.Nothing().map((x) => x.toString())
//=> Object {  }

const q = Maybe.Just([0, 2, 4]).map((xs) => xs.map((x) => x * 2))
//=> Object { value: [0, 4, 8] }

const r = Maybe.Nothing().map((xs) => xs.map((x) => x * 2))
//=> Object {  }

const s = R.map(R.multiply(2), Maybe.Just(4))
//=> Object { value: 8 }

const t = R.map(R.multiply(2), Maybe.Nothing())
//=> Object {  }

const u = R.map(R.toString, Maybe.Just(10))
//=> Object { value: "10" }

const v = R.map(R.toString, Maybe.Nothing())
//=> Object {  }

const w = R.map(R.map(R.multiply(2)), Maybe.Just([0, 2, 4]))
//=> Object { value: [0, 4, 8] }

const x = R.map(R.map(R.multiply(2)), Maybe.Nothing())
//=> Object {  }

-- Identity
id :: a -> a

-- Functor map
fmap :: Functor f => (a -> b) -> f a -> f b

-- Identity
identity ∷ ∀ α t. Category α ⇒ α t t

-- Functor map
map ∷ ∀ f α β. Functor f ⇒ (α → β) → f α → f β

map : (a -> b) -> List a -> List b
map f xs =
    case xs of
        [] ->
            []
        head :: tail ->
            f head :: map f tail

map ((+) 1) [ 1, 2, 3 ]
--=> [ 2, 3, 4 ]

((+) 1 1) :: map ((+) 1) [ 2, 3 ]
2 :: map ((+) 1) [ 2, 3 ]
2 :: ((+) 1 2) :: map ((+) 1) [ 3 ]
2 :: 3 :: map ((+) 1) [ 3 ]
2 :: 3 :: ((+) 1 3) :: map ((+) 1) []
2 :: 3 :: 4 :: map ((+) 1) []
2 :: 3 :: 4 :: []
-- Which is already the same as [ 2, 3, 4 ] since
-- that is the underlying structure of a cons list
2 :: 3 :: [ 4 ]
2 :: [ 3, 4 ]
[ 2, 3, 4 ]

//∷ ∀ α β. (α → β) → [α] → [β]
const map = (f, [ head, ...tail ]) =>
  head === void 0 ? [] : [ f(head), ...map(f, tail) ]

map((x) => x + 1, [ 1, 2, 3 ])
//=> [ 2, 3, 4 ]

[ 1 + 1, ...map((x) => x + 1, [ 2, 3 ]) ]
[ 2, ...map((x) => x + 1, [ 2, 3 ]) ]
[ 2, ...[ 2 + 1, ...map((x) => x + 1, [ 3 ]) ] ]
[ 2, ...[ 3, ...map((x) => x + 1, [ 3 ]) ] ]
[ 2, ...[ 3, ...[ 3 + 1, ...map((x) => x + 1, []) ] ] ]
[ 2, ...[ 3, ...[ 4, ...map((x) => x + 1, []) ] ] ]
[ 2, ...[ 3, ...[ 4, ...[] ] ] ]
[ 2, ...[ 3, ...[ 4 ] ] ]
[ 2, ...[ 3, 4 ] ]
[ 2, 3, 4 ]

//∷ [ℤ]
ints = [ 1, 2, 3, 4 ]

// is it odd?
ints.map((x) => x % 2)
//=> [ 1, 0, 1, 0 ]

// Now imagine that if Set had map
(new Set(ints)).map((x) => x % 2)
//=> ???

{
	"characters": [
		{
			"name": "Ganonu",
			"piece": 0
		},
		{
			"name": "Zeldu",
			"piece": 1
		},
		{
			"name": "Linku",
			"piece": 2
		},
		{
			"name": "Impu",
			"piece": -1
		},
		{
			"name": "Midnu",
			"piece": -1
		},
		{
			"name": "Tinglu",
			"piece": -1
		}
	]
}

Result.unpack : (a -> b) -> (e -> b) -> Result a e -> b

import Html exposing (Html, li, text)
import Html.Keyed exposing (ul)
import Json.Decode as Decode exposing (Decoder)
import Result.Extra as Result

-- Syntax for building unions and ADTs…
type TriforksPiece
    = Power
    | Wisdom
    | Courage

-- For transforming our JSON’s enum representation
triforksPieceFromEnum : Int -> Maybe TriforksPiece
triforksPieceFromEnum i =
    case i of
        0 -> Just Power
        1 -> Just Wisdom
        2 -> Just Courage
        _ -> Nothing

-- For transforming the union back to a String for the view
-- We _could_ run `toString` on Triforks Piece, but this
-- future-proofs us for translations
triforksPieceToString : TriforksPiece -> String
triforksPieceToString tp =
    case tp of
        Power -> "Power"
        Wisdom -> "Wisdom"
        Courage -> "Courage"

type alias Character =
    { name : String
    , piece : Maybe TriforksPiece
    }

-- In Elm we decode and explicitly verify our JSON schema via
-- a Json.Decode.Decoder
-- Note: Decode.map turning our Int into a Maybe TriforksPiece
characterDecoder : Decoder Character
characterDecoder =
    Decode.map2 Character
        (Decode.field "name" Decode.string)
        (Decode.field "piece" Decode.int |> Decode.map triforksPieceFromEnum)

-- Keyed HTML is best used in list-like data like our characters
-- Our label is a good unique key
viewCharacter : Character -> ( String, Html String )
viewCharacter { name, piece } =
    let
        -- Use map to compose a transformation of a union type
        -- into a string & then append to " – ", then let the
        -- value fall out with "", then append to the name
        label : String
        label =
            piece
				    |> Maybe.map (\p -> " - " ++ triforksPieceToString p)
                |> Maybe.withDefault ""
                |> (++) name
    in
        -- Ex. <li>Linku - Courage</li> or <li>Impu</li>
        ( label , li [] [ text label ] )

-- Assume we pass the JSON stringify’d string into the view
-- Unpack an Err’s String into text on failure while
-- putting Ok thru the list maker
view : String -> Html String
view input =
    let
        charactersDecoder : Decoder (List Character)
        charactersDecoder =
            Decode.field "characters" (Decode.list characterDecoder)
	 in
        case Decode.decodeString charactersDecoder input of
            Ok chars ->
                ul [] (List.map viewCharacter chars)
            Err err ->
                text err

import R from "ramda"
import { Either, Maybe } from "ramda-fantasy"
import h from "virtual-dom/h"

// Like Elm’s Dict.get, we need a safe function for getting
// values out of a map, and returning a Maybe since the
// function can fail to retrieve a value. Map.prototype.get
// returns `α | null`.
//∷ ∀ key val. Ord key ⇒ key → Map key val → Maybe val
const mapGet = R.curryN(2, (key, map) =>
	map instanceof Map ? Maybe(map.get(key)) : Maybe.Nothing()
)

// Now that we’re done building general helpers…

// Use an `Either` to handle JSON parsing errors — it’s similar
// to a `Maybe`, but is `Either α β = Left α | Right β`.
// We will be validating the structure too.
//∷ String → Either String [Char]
const decodeCharacterJSON = (j) => {
	let json

	try {
		json = JSON.parse(j)
	} catch(e) {
		// Fail on failed parse
		return Either.Left(`JSON parsing fail: ${e.message}`)
	}

	return R.ifElse(
		// condition for characters
		R.allPass([
			Array.isArray,
			R.all(R.propSatisfies((n) => typeof n === "string", "name"))
		]),
		// is array and all have string name prop, pipe thru & pass
		R.pipe(
			R.project([ "name", "piece" ]),
			Either.Right
		),
		// else, pipe thru & fail
		R.pipe(
			JSON.stringify,
			R.concat("JSON parsed, but characters are misformed: "),
			Either.Left
		)
	)(R.prop("characters", json))
}

// JavaScript doesn’t support ADTs or Enums, so a Map of
// Strings will have to do.
// Haskell: `newtype TriforksPiece = TriforksPiece String`
// Elm: `type alias TriforksPiece = String`
//∷ Map ℤ TriforksPiece
const TriforksPieces =
	new Map([
		[ 0, "Power" ],
		[ 1, "Wisdom" ],
		[ 2, "Courage" ]
	])

// Partially apply in the TriforksPiece Map
//∷ ℤ -> Maybe TriforksPiece
const triforksPieceFromEnum =
	R.flip(mapGet)(TriforksPieces)

// Ex. <li>Linku – Courage</li> or <li>Impu</li>
//∷ (Character) → VDOM
viewCharacter = ({ name, piece }) => {
	// Remember, piece : Maybe TriforksPiece
	//∷ String
	const label =
		`${name}${R.map(R.concat(" – "), piece).getOrElse("")}`

	return h("li", { key: label }, label)
}


//∷ [Character] → VDOM
viewCharacters = (chars) =>
	h("ul", {}, R.map(viewCharacter, chars))


// Assume our `view` takes in a JSON.stringify’d string of characters
//∷ String → VDOM
const view =
	R.pipe(
		 decodeCharacterJSON,
		 // map the Either then List to update the Triforks pieces
		 R.map(R.map(R.evolve({ piece: triforksPieceFromEnum }))),
		 // After our data is transformed into a way we like use
		 // `either` to unpack the String error & the List Character
		 // into their respective view functions
		 R.invoker(2, "either")((e) => h("div", {}, e))(toviewCharacters)
	)