null 일 수 있는 단계를 잇는다: 스크롤 요소 → 그 안의 #id 요소 → 첫 사각형 → scrollLeft 를 그 left 로. 어느 단계든 null 이 나오면 뒤 단계는 부르지 않고 null 로 끝난다. Maybe 의 map 으로 쓰면 체인 하나, generator 로 쓰면 단계마다 if (!x) return 으로 일찍 빠져나간다 — 같은 모양이다.

-- null 일 수 있는 단계를 체크 없이 잇는다
fmap :: (a -> b) -> Maybe a -> Maybe b
fmap f (Just x) = ofNullable (f x)   -- 결과가 null 이면 Nothing 으로
fmap _ Nothing  = Nothing            -- 뒤 단계는 부르지 않는다

scrollTo id = ofNullable scrollElement
  >>= querySelector ("#" ++ id)
  >>= (listToMaybe . getClientRects)
  <&> \rect -> root.scrollLeft := left rect

-- generator 로 쓰면 같은 모양의 early return
handleScroll id = do
  root   <- scrollElement   -- if (!root) return
  target <- querySelector ("#" ++ id) root   -- if (!target) return
  yield (maybe 0 left (listToMaybe (getClientRects target)))
#533

모나드는 세 부품이다. 값을 감싸는 타입(로그가 붙은 숫자), 값을 감싸는 함수 unit(로그가 빈 채로 감싼다), 감싼 값에 함수를 이어 붙이는 bind(결과는 새 값, 로그는 앞뒤를 이어 붙인다). Option·Promise 도 같은 모양이고 Promise 에선 then 이 bind 다. 다만 Promise 는 근사다 — then 이 붙은 객체(thenable)를 자동으로 펼쳐서, unit(x) 에 f 를 bind 한 것과 f(x) 가 달라진다(left identity 가 깨진다).

-- 모나드 = 연속된 연산 사이의 처리를 숨기는 패턴. 부품은 셋
data Logged a = Logged { result :: a, logs :: [String] }    -- 1 감싸는 타입

unit :: a -> Logged a                                       -- 2 감싸기 (return)
unit n = Logged n []

bind :: Logged a -> (a -> Logged b) -> Logged b             -- 3 잇기 (flatMap)
bind (Logged x l) f = let Logged y l' = f x in Logged y (l ++ l')   -- 로그 합치기가 숨는다

-- Option·Promise 도 모나드다. Promise 에선 then 이 bind
-- 단 Promise 는 근사다: thenable 을 자동으로 펼쳐 left identity 가 깨진다
unit x `bind` f == f x                                      -- 법칙
v = { then: r => r(42) } ; f x = resolve [x]
(resolve v `then` f) == [42]  /=  f v == [v]
#534

Just 10 에 bind 로 safeDivide _ 2 를 이으면 Just 5 가 된다. safeDivide _ 0 을 이으면 0 으로 나눌 수 없어 Nothing 이 되고, 그 뒤에 무엇을 bind 해도 함수를 부르지 않고 Nothing 이 그대로 흐른다. 중간마다 null 검사를 쓰지 않아도 실패가 끝까지 전파된다.

-- TypeScript 로 Maybe 를 만든다: Just·Nothing 두 클래스에 bind 하나씩
data Maybe a = Just a | Nothing

bind :: Maybe a -> (a -> Maybe b) -> Maybe b
bind (Just x) f = f x        -- class Just    { bind(fn) { return fn(this.value) } }
bind Nothing  _ = Nothing    -- class Nothing { bind(fn) { return this } } — fn 을 안 부른다

safeDivide :: Double -> Double -> Maybe Double
safeDivide _ 0 = Nothing
safeDivide x y = Just (x / y)

Just 10 `bind` (`safeDivide` 2) == Just 5
Just 10 `bind` (`safeDivide` 0) == Nothing
#535

같은 세 단계(fetch → process → display)를 콜백은 안으로 중첩하고, Promise 는 then 으로 옆으로 잇고, async/await 는 위에서 아래로 쓴다. then 에 넘긴 함수가 값을 돌려주면 Promise 로 감싸고(map), Promise 를 돌려주면 풀어서 잇는다(flatMap). 한 메서드가 둘 다 해서 Promise 안의 Promise 는 만들어지지 않는다.

-- 콜백 → Promise → async/await: 같은 세 단계를 쓰는 세 가지 방법
callback = fetchData (processData (displayData))     -- 안으로 중첩
chain    = fetchData >>= processData >>= displayData  -- then 으로 옆으로
main = do                                             -- 위에서 아래로
  d <- fetchData
  p <- processData d
  displayData p

-- then 은 모나드의 >>= 와 map 을 한 메서드로 한다
then :: Promise a -> (a -> b | Promise b) -> Promise b
then p f = case f x of
  Promise q -> q            -- 풀어서 잇는다 (flatMap)
  v         -> resolve v    -- 감싼다 (map)
-- 그래서 Promise (Promise a) 는 만들어지지 않는다 — thenable 도 같은 식으로 푼다
#536