생성자는 항상 그 클래스의 새 인스턴스를 돌려준다. 생성자를 private 으로 막고 static create 를 두면 셋을 할 수 있다: 유효성 검사에 실패하면 null(또는 Result)을 돌려주고(이름이 3자 미만이면 null), 인자에 따라 다른 하위 클래스를 돌려주고(circle 이면 Circle, rect 면 Rectangle), 이미 있는 인스턴스를 돌려준다(싱글톤). 단순 초기화만 필요하면 생성자가 더 직관적이다.

-- 생성자는 항상 새 인스턴스를 준다. private 생성자 + static create 면 셋이 된다
create :: String -> Maybe User           -- 1 실패를 값으로 (null / Result)
create name | length name < 3 = Nothing
            | otherwise       = Just (User name)

shape :: Kind -> Size -> Shape           -- 2 하위 클래스를 고른다 (팩토리)
shape Circle = circle
shape Rect   = rectangle

config :: IO Config                      -- 3 같은 인스턴스 (싱글톤): instance ??= new Config()
config = readIORef instanceRef >>= maybe (newConfig >>= cache) pure
-- 단순 초기화만이면 생성자가 더 직관적
#381

Redux 스타일 store 는 상태 하나와 리스너 목록 하나다. dispatch(action) 은 reducer(지금 상태, action) 으로 새 상태를 만들어 갈아 끼우고, 리스너 전부에게 새 상태를 알린 뒤 action 을 돌려준다. subscribe 는 리스너를 곧바로 지금 상태로 한 번 부르고 목록에 넣으며, 목록에서 빼는 함수를 돌려준다. getState 는 지금 상태를 읽는다.

-- state 는 클로저에 가두고, 바꾸는 길은 dispatch → reducer 하나뿐
createStore :: (s -> a -> s) -> s -> Store s a
dispatch a = do state %= (`reducer` a)
                s <- read state
                mapM_ ($ s) =<< read listeners
                pure a

-- Redux 와 다른 점: 리스너에 state 를 넘기고, 등록 즉시 한 번 부른다
subscribe  l = l =<< read state >> listeners %= (l :) >> pure (listeners %= filter (/= l))
subscribeR l = listeners %= (l :)            -- Redux: 인자 없이 부르고, 리스너가 getState() 로 읽는다

reducer s (Add item) = s { items = items s ++ [item] }
reducer s _          = s

store = createStore reducer { items = [] }
subscribe store (print . items)
dispatch store (Add { body = "hello" })
#484

Children API 로 children 을 재귀 순회하며 원하는 type 을 찾을 수 있다 — Fragment 는 풀고, 문자열·숫자는 isValidElement 로 거르고, props.children 으로 내려간다. 하지만 어디에 두든 찾아 주는 Tabs 는 암묵적 의존·약한 타입·매 렌더 순회로 예측하기 어렵다. React 문서도 Children 은 드물고 깨지기 쉽다고 한다. 대신 Tabs.Root > Tabs.List > Tabs.Trigger, Tabs.Content 처럼 구조를 소비자가 드러내는 Compound Component 로 쓴다.

-- Children API 로 트리를 뒤질 수 있다 — 가능하지만 비추천
traverse :: Type -> ReactNode -> [Element]
traverse t = concatMap go . toArray
  where
    go c | not (isValidElement c) = []                         -- string·number 도 들어온다
         | type' c == Fragment    = traverse t (children c)    -- Fragment 는 푼다
         | otherwise              = [c | type' c == t] ++ traverse t (children c)

-- 동적 래핑: 링크가 하나라도 있으면 그대로, 아니면 <ul> 로
wrap cs | any (isJust . url) (filter isValidElement (toArray cs)) = cs
        | otherwise                                               = ul cs

-- 암묵적 의존 · 타입 약함 · 매 렌더 순회 · 예측 불가 → Compound Component 로
tabs = Tabs.Root [ Tabs.List [Tabs.Trigger "a" "A"], Tabs.Content "a" "Content" ]
-- 2013년엔 Context 도 없었다: "선언형"인데 명령형 순회를 주던 이중성
-- deepMap·deepFind·deepFilter 가 필요하면 react-children-utilities
#496

Redux 스타일 store 는 상태 하나와 리스너 목록 하나다. dispatch(action) 은 reducer(지금 상태, action) 으로 새 상태를 만들어 갈아 끼우고, 리스너 전부에게 새 상태를 알린 뒤 action 을 돌려준다. subscribe 는 리스너를 곧바로 지금 상태로 한 번 부르고 목록에 넣으며, 목록에서 빼는 함수를 돌려준다. getState 는 지금 상태를 읽는다.

-- 간단한 Redux 스타일 store: 상태 하나 + 리스너 목록 하나
createStore :: (s -> a -> s) -> s -> Store s a
createStore reducer s0 = Store { getState, subscribe, dispatch }   -- s0: 만들 때 리듀서와 함께 넘기는 초기 상태 (preloadedState)
  where
    getState      = read state
    dispatch a    = do s' <- reducer <$> read state <*> pure a
                       state := s'
                       mapM_ ($ s') =<< read listeners
                       pure a
    subscribe l   = do l =<< read state          -- 지금 상태로 한 번 곧바로
                       listeners %= (l :)
                       pure (listeners %= filter (/= l))   -- 해지 함수
#529

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

useGenerator 의 상태는 useReducer 하나다. idle 에서 start 로 running 이 되고(에러도 함께 비운다), yield 는 status 를 두고 value 만 바꾸며, generator 가 끝나면 done, 본문 어디서든 throw 하면 catch 에서 error 로 errored 다. cancel 은 abort 하고 idle 로 되돌린다 — 안 하면 running 에 멈춘다. unmount 되면 cleanup 이 abort 하고, 기다리던 await wait 가 reject 돼 throw 가 나지만 aborted 라 에러로 치지 않는다. 같은 훅을 쓰는 쪽이 재진입 정책을 고른다: LoadingButton 은 running 동안 disabled 로 다시 못 누르게 하고 JSX 를 yield 하면 그대로 라벨이 된다. 검색은 run(q) 마다 직전 실행을 abort 하고 다시 시작해, a 다음 ab 를 치면 a 의 remote 결과가 끼어들지 않는다.

-- isLoading 없이 onClick 에서 yield 만 한다 — 시간이 코드의 한 방향(↓)으로만 흐를 때
--   멀티 단계 loading · progressive search · optimistic mutation(optimistic | reconciled | rolledBack)
data Status  = Idle | Running | Errored | Done
data Event a = Start | Yield a | Finish | Throw Error | Cancel

step :: State a -> Event a -> State a
step s Start     = s { status = Running, error = Nothing }   -- 상태와 에러 초기화가 한 번에 — 따로 set 하다 어긋날 일이 없다
step s (Yield v) = s { value = v }                           -- status 는 두고 값만
step s Finish    = s { status = Done }
step s (Throw e) = s { status = Errored, error = Just e }
step s Cancel    = s { status = Idle }                       -- 없으면 Running 에 멈춘다

-- 핸들러는 값의 흐름(async generator), 훅은 그걸 접는다
state = foldl step initial (run fn args)

run :: (Signal -> args -> Stream a) -> args -> [Event a]
run fn args = Start : map Yield (untilAborted (fn signal args)) ++ end
  where end | aborted   = []          -- abort 로 생긴 throw 는 에러가 아니다
            | otherwise = [Finish]    -- 본문 어디서 throw 하든 Throw e
-- run 은 직전 실행을 abort 하고 다시 시작한다 · unmount 도 abort

-- 재진입 정책은 쓰는 쪽이 고른다
--   버튼: Running 동안 disabled, yield 한 JSX 가 곧 라벨
--   검색: run 마다 재시작 — tier 경계(await wait)가 곧 취소 지점이라 debounce 가 필요 없다
searchTiers q = do wait 100; yield [q ++ ":local"]
                   wait 300; yield [q ++ ":local", q ++ ":remote"]

-- 확인: a 를 치고 150ms 에 ab
shown == [["a:local"], ["ab:local"], ["ab:local", "ab:remote"]]   -- a:remote 는 끼어들지 않는다
#540