<div id="readability-page-1" class="page"><div><h2 id="파생된-상태를-만드는-단방향-흐름의-selector"><a href="#%ED%8C%8C%EC%83%9D%EB%90%9C-%EC%83%81%ED%83%9C%EB%A5%BC-%EB%A7%8C%EB%93%9C%EB%8A%94-%EB%8B%A8%EB%B0%A9%ED%96%A5-%ED%9D%90%EB%A6%84%EC%9D%98-selector" aria-hidden=""></a>파생된 상태를 만드는 단방향 흐름의 selector</h2>
Recoil은 <a href="https://recoiljs.org/docs/api-reference/core/selector" target="_blank" rel="nofollow">selector</a> API를 제공한다. React의 <code>useMemo</code>, <a href="https://redux.js.org/usage/deriving-data-selectors" target="_blank" rel="nofollow">Redux의 selector</a> 처럼 다른 상태를 기반으로 파생된 상태(derived state) 만들어내는 역할을 한다. 간단한 예를 들면 작업 목록에서 완료된 작업만 추려내고 싶을 때 사용할 수 있다.
<div data-language="tsx"><pre><code>import { atom, selector } from 'recoil';

type Job = { content: string; isDone: boolean };

const jobListState = atom&lt;Job[]&gt;({
 key: 'jobListState',
 default: [],
});

const completedJobsSelector = selector({
 key: 'completedJobsSelector',
 get: ({ get }) =&gt; {
 const jobList = get(jobListState);
 const completed = jobList.filter((v) =&gt; v.isDone);
 return completed;
 },
});</code></pre></div>
<h2 id="쓰기까지-가능한-양방향-흐름을-가진-selector"><a href="#%EC%93%B0%EA%B8%B0%EA%B9%8C%EC%A7%80-%EA%B0%80%EB%8A%A5%ED%95%9C-%EC%96%91%EB%B0%A9%ED%96%A5-%ED%9D%90%EB%A6%84%EC%9D%84-%EA%B0%80%EC%A7%84-selector" aria-hidden=""></a>쓰기까지 가능한 양방향 흐름을 가진 selector</h2>
그런데 Recoil은 “쓰기 가능한 selector 상태”, writable selector라는 개념을 구현해 두었다. React를 사용해 온 사람이라면 ‘selector’라는 명사는 파생된 상태를 의미하며, 단방향 흐름을 가진 데이터라는 인식을 가지고 있어서 다소 의아하게 느껴질 수 있다. selector인데 양방향 데이터 흐름을 가진 것이라니?
예를 들어 속도 정보를 관리해야 할 때 원본 데이터는 마일(mile)/h인데 화면 상에는 킬로미터(km)/h로 표시해야 하는 경우가 있을 수 있다. 그 관계를 atom과 selector로 표현하면 다음과 같다.
<div data-language="tsx"><pre><code>const mphState = atom({
 key: 'mphState',
 default: 0,
});

const kphState = selector({
 key: 'kphState',
 get: ({ get }) =&gt; {
 const mph = get(mphState);
 return mph * 1.609; // 1마일은 약 1.609킬로부터
 },
});</code></pre></div>
이렇게 작성한 <code>kphState</code> 상태는 쓰기가 불가능한 상태다. 즉 <code>useSetRecoilState</code> 나 <code>useRecoilState</code> 훅의 파라미터로 넣을 수 없다. 하지만 selector에 <code>set</code> 속성을 추가한다면 쓰기가 가능해진다. 컴포넌트에서 <code>useSetRecoilState</code> 을 사용해 <code>kphState</code>의 setter 함수를 만들면 킬로미터/h 값을 넘겨서 <code>mphState</code> 상태를 업데이트할 수 있게 되는 것이다.
<div data-language="tsx"><pre><code>export const kphState = selector&lt;number&gt;({
 key: 'kphState',
 get: ({ get }) =&gt; {
 const mph = get(mphState);
 return mph * 1.609;
 },
 set: ({ set }, newValue) =&gt; {
 if (typeof newValue === 'number') {
 set(mphState, newValue / 1.609); // 킬로미터를 마일로 변환한다
 }
 },
});

const KPHInput: React.FC&lt;Props&gt; = () =&gt; {
 const setKph = useSetRecoilState(kphState);
 return (
 &lt;input type="number" onChange={(e) =&gt; setKph(parseInt(e.target.value))} /&gt;
 );
};</code></pre></div>
<h3 id="쓰기-가능한-selector의-초기화-기능"><a href="#%EC%93%B0%EA%B8%B0-%EA%B0%80%EB%8A%A5%ED%95%9C-selector%EC%9D%98-%EC%B4%88%EA%B8%B0%ED%99%94-%EA%B8%B0%EB%8A%A5" aria-hidden=""></a>쓰기 가능한 selector의 초기화 기능</h3>
<code>kphState</code> selector의 <code>set</code> 속성의 두번째 파라미터인 <code>newValue</code>의 타입을 확인해보면 <code>number | DefaultValue</code> 로 되어있음을 알 수 있다. <code>DefaultValue</code> 타입은 <code>set</code> 콜백이 setter(업데이트) 함수를 통해 호출되었는지, resetter(초기화) 함수로 호출되었는지 구분해주는 역할을 한다. 컴포넌트에서 <code>useSetRecoilState</code> 를 사용해서 만들었다면 setter 함수가 되고, <code>useResetRecoilState</code>를 사용해서 만들었다면 resetter 함수가 된다.
<div data-language="tsx"><pre><code>export const kphState = selector&lt;number&gt;({
 key: 'kphState',
 get: ({ get }) =&gt; {
 const mph = get(mphState);
 return mph * 1.609;
 },
 set: ({ set, reset }, newValue) =&gt; {
 // selector의 resetter를 호출하면 newValue는 DefaultValue 인스턴스가 된다.
 if (newValue instanceof DefaultValue) {
 reset(mphState);
 } else if (typeof newValue === 'number') {
 set(mphState, newValue / 1.609);
 }
 },
});

const ResetKPHButton: React.FC&lt;Props&gt; = () =&gt; {
 const resetKph = useResetRecoilState(kphState); // resetter 함수 생성

 return &lt;button onClick={resetKph}&gt;Reset KPH&lt;/button&gt;;
};</code></pre></div>
<h2 id="언제-사용하면-좋은가"><a href="#%EC%96%B8%EC%A0%9C-%EC%82%AC%EC%9A%A9%ED%95%98%EB%A9%B4-%EC%A2%8B%EC%9D%80%EA%B0%80" aria-hidden=""></a>언제 사용하면 좋은가?</h2>
쓰기 가능한 selector에 대한 개념은 파악이 되었다. 그런데 더 중요한 질문이 남았다. 그래서 왜, 언제 사용하면 좋을까이다.
위의 예제에 있는 것처럼 마일-킬로미터 같은 관계를 차치하고 생각하면 쓰기 가능한 selector는 그저 “컴포넌트 외부에 모듈 형태로 선언 가능한 Recoil 상태 업데이트 콜백 함수”라는 개념이 되긴 한다. 하지만 완전히 자유롭게 아무 일이나 할 수는 없다. <code>selector</code> 함수의 타입 선언을 보면 <code>get</code> 콜백이 필수 값이라서 <code>set</code>만 선언할 수는 없으며, <code>get</code> 콜백이 리턴하는 타입과 <code>set</code> 콜백에 전달되는 <code>newValue</code>의 타입이 일치해야 한다.
<div data-language="tsx"><pre><code>function selector&lt;T&gt;({
 key: string,

 get: ({
 get: GetRecoilValue,
 getCallback: GetCallback,
 }) =&gt; T | Promise&lt;T&gt; | RecoilValue&lt;T&gt;, // 타입 T에 해당하는 값, T를 리턴하는 Promise,

 set?: (
 {
 get: GetRecoilValue,
 set: SetRecoilState,
 reset: ResetRecoilState,
 },
 newValue: T | DefaultValue, // setter로 전달하는 값은 T 타입 값이어야 한다.
 ) =&gt; void,
})</code></pre></div>
Redux의 reducer 함수처럼 전달할 값과 업데이트할 상태를 자유롭게 구현하라는 용도로 제공된 기능은 아님을 알 수 있다. <code>T</code> 타입을 가진 파생된 상태를 만들어야 하고, 동시에 <code>T</code> 타입의 값을 전달해서 다른 상태를 업데이트할 필요가 있을 때 쓰기 가능한 selector를 사용할 필요가 생긴다. 또는 파생된 상태를 초기화시키고 싶을 때 유용하게 사용할 수 있다.
그런데 초기화라면 굳이 selector의 <code>set</code> 콜백을 사용할 필요 없이 selector의 소스가 되는 <code>atom</code>상태를 직접 초기화시키면 되는 것 아닌가?라는 질문이 나올 수 있다. 물론 그렇게 초기화 로직을 구현해도 상관없다. 하지만 코드의 가독성과 유지 보수성에 차이가 올 것이다. 파생된 상태는 여러 개의 <code>atom</code>과 <code>selector</code> 상태를 기반으로 복잡한 로직을 거쳐 만들어질 수도 있다. 그렇다면 초기화 시키는 로직 역시 여러 과정이 필요할 수 있다. 그런데 reset이 여러 곳에서 필요하다면 그 로직을 어떻게 모듈화할 것인가? 커스텀 훅 함수를 사용할 수도 있겠지만 selector의 <code>set</code> 콜백을 사용하면 더 간편하다. 상태 업데이트를 위한 기능도 제공하며 자연스럽게 모듈화도 되는 셈이니 말이다.
Redux의 reducer 역할은 쓰기 가능한 selector보다는 <code>useRecoilTransaction</code>과 <code>useRecoilCallback</code>에 커스텀 훅 함수를 조합해서 구현하는 편이 좋다.
<h2 id="code-classlanguage-textuserecoiltransactioncode을-사용한-recoil-상태-업데이트"><a href="#code-classlanguage-textuserecoiltransactioncode%EC%9D%84-%EC%82%AC%EC%9A%A9%ED%95%9C-recoil-%EC%83%81%ED%83%9C-%EC%97%85%EB%8D%B0%EC%9D%B4%ED%8A%B8" aria-hidden=""></a><code>useRecoilTransaction</code>을 사용한 Recoil 상태 업데이트</h2>
<code>useRecoilTransaction</code>은 <code>useCallback</code>처럼 컴포넌트 안에서 사용할 수 있는 함수를 만드는 훅 함수다. 파라미터로 팩토리 함수를 전달하는 방식을 사용해 Recoil의 상태를 관리할 수 있는 인터페이스를 제공한다.
<div data-language="tsx"><pre><code>interface TransactionInterface {
 get: &lt;T&gt;(RecoilValue&lt;T&gt;) =&gt; T; // Recoil 상태를 가져온다
 set: &lt;T&gt;(RecoilState&lt;T&gt;, (T =&gt; T) | T) =&gt; void; // 상태를 업데이트한다
 reset: &lt;T&gt;(RecoilState&lt;T&gt;) =&gt; void; // 상태를 초기화한다
}

// Args가 실제로 사용할 콜백의 파라미터들이 된다.
function useRecoilTransaction_UNSTABLE&lt;Args&gt;(
 callback: TransactionInterface =&gt; (...Args) =&gt; void,
): (...Args) =&gt; void</code></pre></div>
아래는 useRecoilTransaction을 사용하는 예제다. 만들어진 함수는 <code>goForward(100)</code> 같은 방식으로 호출해서 <code>positionState</code> 상태를 업데이트하는데 쓸 수 있다.
<div data-language="tsx"><pre><code>const goForward = useRecoilTransaction_UNSTABLE(
 ({ get, set }) =&gt;
 (distance) =&gt; {
 const heading = get(headingState);
 const position = get(positionState);

 set(positionState, {
 x: position.x + cos(heading) * distance,
 y: position.y + sin(heading) * distance,
 });
 },
);</code></pre></div>
<code>useRecoilCallback</code>이 Recoil 상태에 접근하기 위해 <code>snapshot</code> 을 사용해야 하는 것에 비하면 비교적 간편하게 상태를 관리할 수 있다. 다만 리턴 값을 넘길 수 없으며, selector 상태와 비동기 atom은 사용할 수 없는 등의 한계가 있다. 그리고 상태 업데이트 외의 side effect를 만들고 싶다면 <code>useRecoilTransaction</code>이 아닌 <code>useRecoilCallback</code>을 사용하라는 가이드를 공식 문서에서 주고 있다.
<h2 id="참고-자료"><a href="#%EC%B0%B8%EA%B3%A0-%EC%9E%90%EB%A3%8C" aria-hidden=""></a>참고 자료</h2>
<ul>
<li><a href="https://recoiljs.org/docs/api-reference/core/selector/#writeable-selectors" target="_blank" rel="nofollow">selector(options) | Recoil</a></li>
<li><a href="https://recoiljs.org/docs/api-reference/core/useRecoilTransaction/" target="_blank" rel="nofollow">useRecoilTransaction_UNSTABLE(callback, deps) | Recoil</a></li>
<li><a href="https://recoiljs.org/docs/api-reference/core/useRecoilCallback" target="_blank" rel="nofollow">useRecoilCallback(callback, deps) | Recoil</a></li>
</ul></div></div>

blog.rhostem.com

파생된 상태를 만드는 단방향 흐름의 selector
Recoil은 selector API를 제공한다. React의 useMemo, Redux의 selector 처럼 다른 상태를 기반으로 파생된 상태(derived state) 만들어내는 역할을 한다. 간단한 예를 들면 작업 목록에서 완료된 작업만 추려내고 싶을 때 사용할 수 있다.
import { atom, selector } from 'recoil';
type Job = { content: string; isDone: boolean };
const jobListState = atom<Job[]>({
 key: 'jobListState',
 default: [],
});
const completedJobsSelector = selector({
 key: 'completedJobsSelector',
 get: ({ get }) => {
 const jobList = get(jobListState);
 const completed = jobList.filter((v) => v.isDone);
 return completed;
 },
});
쓰기까지 가능한 양방향 흐름을 가진 selector
그런데 Recoil은 “쓰기 가능한 selector 상태”, writable selector라는 개념을 구현해 두었다. React를 사용해 온 사람이라면 ‘selector’라는 명사는 파생된 상태를 의미하며, 단방향 흐름을 가진 데이터라는 인식을 가지고 있어서 다소 의아하게 느껴질 수 있다. selector인데 양방향 데이터 흐름을 가진 것이라니?
예를 들어 속도 정보를 관리해야 할 때 원본 데이터는 마일(mile)/h인데 화면 상에는 킬로미터(km)/h로 표시해야 하는 경우가 있을 수 있다. 그 관계를 atom과 selector로 표현하면 다음과 같다.
const mphState = atom({
 key: 'mphState',
 default: 0,
});
const kphState = selector({
 key: 'kphState',
 get: ({ get }) => {
 const mph = get(mphState);
 return mph * 1.609; // 1마일은 약 1.609킬로부터
 },
});
이렇게 작성한 kphState 상태는 쓰기가 불가능한 상태다. 즉 useSetRecoilState 나 useRecoilState 훅의 파라미터로 넣을 수 없다. 하지만 selector에 set 속성을 추가한다면 쓰기가 가능해진다. 컴포넌트에서 useSetRecoilState 을 사용해 kphState의 setter 함수를 만들면 킬로미터/h 값을 넘겨서 mphState 상태를 업데이트할 수 있게 되는 것이다.
export const kphState = selector<number>({
 key: 'kphState',
 get: ({ get }) => {
 const mph = get(mphState);
 return mph * 1.609;
 },
 set: ({ set }, newValue) => {
 if (typeof newValue === 'number') {
 set(mphState, newValue / 1.609); // 킬로미터를 마일로 변환한다
 }
 },
});
const KPHInput: React.FC<Props> = () => {
 const setKph = useSetRecoilState(kphState);
 return (
 <input type="number" onChange={(e) => setKph(parseInt(e.target.value))} />
 );
};
쓰기 가능한 selector의 초기화 기능
kphState selector의 set 속성의 두번째 파라미터인 newValue의 타입을 확인해보면 number | DefaultValue 로 되어있음을 알 수 있다. DefaultValue 타입은 set 콜백이 setter(업데이트) 함수를 통해 호출되었는지, resetter(초기화) 함수로 호출되었는지 구분해주는 역할을 한다. 컴포넌트에서 useSetRecoilState 를 사용해서 만들었다면 setter 함수가 되고, useResetRecoilState를 사용해서 만들었다면 resetter 함수가 된다.
export const kphState = selector<number>({
 key: 'kphState',
 get: ({ get }) => {
 const mph = get(mphState);
 return mph * 1.609;
 },
 set: ({ set, reset }, newValue) => {
 // selector의 resetter를 호출하면 newValue는 DefaultValue 인스턴스가 된다.
 if (newValue instanceof DefaultValue) {
 reset(mphState);
 } else if (typeof newValue === 'number') {
 set(mphState, newValue / 1.609);
 }
 },
});
const ResetKPHButton: React.FC<Props> = () => {
 const resetKph = useResetRecoilState(kphState); // resetter 함수 생성
 return <button onClick={resetKph}>Reset KPH</button>;
};
언제 사용하면 좋은가?
쓰기 가능한 selector에 대한 개념은 파악이 되었다. 그런데 더 중요한 질문이 남았다. 그래서 왜, 언제 사용하면 좋을까이다.
위의 예제에 있는 것처럼 마일-킬로미터 같은 관계를 차치하고 생각하면 쓰기 가능한 selector는 그저 “컴포넌트 외부에 모듈 형태로 선언 가능한 Recoil 상태 업데이트 콜백 함수”라는 개념이 되긴 한다. 하지만 완전히 자유롭게 아무 일이나 할 수는 없다. selector 함수의 타입 선언을 보면 get 콜백이 필수 값이라서 set만 선언할 수는 없으며, get 콜백이 리턴하는 타입과 set 콜백에 전달되는 newValue의 타입이 일치해야 한다.
function selector<T>({
 key: string,
 get: ({
 get: GetRecoilValue,
 getCallback: GetCallback,
 }) => T | Promise<T> | RecoilValue<T>, // 타입 T에 해당하는 값, T를 리턴하는 Promise,
 set?: (
 {
 get: GetRecoilValue,
 set: SetRecoilState,
 reset: ResetRecoilState,
 },
 newValue: T | DefaultValue, // setter로 전달하는 값은 T 타입 값이어야 한다.
 ) => void,
})
Redux의 reducer 함수처럼 전달할 값과 업데이트할 상태를 자유롭게 구현하라는 용도로 제공된 기능은 아님을 알 수 있다. T 타입을 가진 파생된 상태를 만들어야 하고, 동시에 T 타입의 값을 전달해서 다른 상태를 업데이트할 필요가 있을 때 쓰기 가능한 selector를 사용할 필요가 생긴다. 또는 파생된 상태를 초기화시키고 싶을 때 유용하게 사용할 수 있다.
그런데 초기화라면 굳이 selector의 set 콜백을 사용할 필요 없이 selector의 소스가 되는 atom상태를 직접 초기화시키면 되는 것 아닌가?라는 질문이 나올 수 있다. 물론 그렇게 초기화 로직을 구현해도 상관없다. 하지만 코드의 가독성과 유지 보수성에 차이가 올 것이다. 파생된 상태는 여러 개의 atom과 selector 상태를 기반으로 복잡한 로직을 거쳐 만들어질 수도 있다. 그렇다면 초기화 시키는 로직 역시 여러 과정이 필요할 수 있다. 그런데 reset이 여러 곳에서 필요하다면 그 로직을 어떻게 모듈화할 것인가? 커스텀 훅 함수를 사용할 수도 있겠지만 selector의 set 콜백을 사용하면 더 간편하다. 상태 업데이트를 위한 기능도 제공하며 자연스럽게 모듈화도 되는 셈이니 말이다.
Redux의 reducer 역할은 쓰기 가능한 selector보다는 useRecoilTransaction과 useRecoilCallback에 커스텀 훅 함수를 조합해서 구현하는 편이 좋다.
useRecoilTransaction을 사용한 Recoil 상태 업데이트
useRecoilTransaction은 useCallback처럼 컴포넌트 안에서 사용할 수 있는 함수를 만드는 훅 함수다. 파라미터로 팩토리 함수를 전달하는 방식을 사용해 Recoil의 상태를 관리할 수 있는 인터페이스를 제공한다.
interface TransactionInterface {
 get: <T>(RecoilValue<T>) => T; // Recoil 상태를 가져온다
 set: <T>(RecoilState<T>, (T => T) | T) => void; // 상태를 업데이트한다
 reset: <T>(RecoilState<T>) => void; // 상태를 초기화한다
}
// Args가 실제로 사용할 콜백의 파라미터들이 된다.
function useRecoilTransaction_UNSTABLE<Args>(
 callback: TransactionInterface => (...Args) => void,
): (...Args) => void
아래는 useRecoilTransaction을 사용하는 예제다. 만들어진 함수는 goForward(100) 같은 방식으로 호출해서 positionState 상태를 업데이트하는데 쓸 수 있다.
const goForward = useRecoilTransaction_UNSTABLE(
 ({ get, set }) =>
 (distance) => {
 const heading = get(headingState);
 const position = get(positionState);
 set(positionState, {
 x: position.x + cos(heading) * distance,
 y: position.y + sin(heading) * distance,
 });
 },
);
useRecoilCallback이 Recoil 상태에 접근하기 위해 snapshot 을 사용해야 하는 것에 비하면 비교적 간편하게 상태를 관리할 수 있다. 다만 리턴 값을 넘길 수 없으며, selector 상태와 비동기 atom은 사용할 수 없는 등의 한계가 있다. 그리고 상태 업데이트 외의 side effect를 만들고 싶다면 useRecoilTransaction이 아닌 useRecoilCallback을 사용하라는 가이드를 공식 문서에서 주고 있다.
참고 자료
selector(options) | Recoil
useRecoilTransaction_UNSTABLE(callback, deps) | Recoil
useRecoilCallback(callback, deps) | Recoil

Recoil의 쓰기 가능한 셀렉터

댓글