
-- 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)))

-- 모나드 = 연속된 연산 사이의 처리를 숨기는 패턴. 부품은 셋
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]

-- 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

-- 콜백 → 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 도 같은 식으로 푼다