새로운 코딩 패러다임을 찾고 있습니다.

몇 달 전에 나는 토끼굴에 걸려 넘어졌습니다. 새로운 종류의 JavaScript/TypeScript 코딩 패러다임을 만들고자 하는 강한 열망이 있었습니다. 나는 지금까지도 내가 무엇을 원하는지, 왜 그것을 원하는지 명확하게 설명하는 데 어려움을 겪고 있습니다. 자신을 온전히 표현할 수 없기 때문에 코드를 유지하고 작성하는 데 어려움을 느낀다.

If there's anything out there similar to this idea, please let me know. I'd love to learn what's out there.

이를 설명하기 위한 몇 가지 방법은 다음과 같습니다.

빌딩 블록과 같은 기능을 제공하는 라이브러리 함수를 만들고 싶습니다.

다른 값을 "탭"할 수 있기를 원합니다.

기능적이거나 이벤트 기반인 것을 찾고 있습니다.

비동기 및 동기화 작업을 지원해야 합니다.

몇 달 전에 모듈 profound 을 만들었는데 현재 고장났지만 demo code on repl.it 으로 놀 수 있습니다.

import { placeholder, profound } from '@reggi/profound'

const alpha = profound({}, ({ }) => 'hello world I\'m a profound')
// console.log(alpha()) // hello world I\'m a profound

const beta = profound({ alpha }, ({ alpha }) => `I am using alpha as a dependency (${alpha})`)
// console.log(beta()) // I am using alpha as a dependency (hello world I'm a profound)

const gamma = profound({ alpha, beta }, ({ alpha, beta }) => `
    Gamma needs alpha and beta to run.
    Rather than being very redundant and running both in here. They are fetched for use. 
    If you pass alpha or beta into gamma, they are not run. 
    This function also takes any arguments that alpha, or beta need.
    Profounds become async: 
        1. If their dependencies are async and are being run (input dependent)
        2. If this callback is async
    (${alpha} ${beta})
`)

const age = placeholder<number>()('age')

const delta = profound({ age, gamma }, ({ age, gamma }) => gamma.length + age)

console.log(delta({ age: 30 })) // 514

처음에는 여기에서 무슨 일이 일어나고 있는지 명확하지 않을 수 있으므로 안내해 드리겠습니다.

profound의 결과는 함수입니다.

profound에는 두 개의 인수가 있습니다. 하나는 종속 함수 목록이고 다른 하나는 콜백입니다. 콜백 서명은 (args) => result 이며, 여기서 args는 종속성의 결과를 매핑하는 객체입니다.

A placeholder는 함수에서 파생될 수 없고 사용자가 입력해야 하는 항목에 대한 스텁입니다.

간단히 말해서, deep은 키가 있는 개체를 사용하여 값을 저장하고 결과를 전달하는 확인자입니다. 종속성을 명시적으로 실행하는 대신 종속성을 "탭"합니다.

이를 통해 기능을 "구성"할 수 있습니다.

어떻게든 TypeScript와 함께 작동하는 이 접근 방식을 마술처럼 얻었으므로 출력된 함수에 대한 인수가 "컴파일"되고 "종속"함수 트리가 포함됩니다.

정말 긴 사슬을 만들고 어떤 일이 일어날지 보고 이것을 한계까지 밀어붙이려 했고, 고장났습니다. TypeScript 오류로 이어지는:

Type instantiation is excessively deep and possibly infinite.

이 오류가 발생하지 않도록 방지하는 방법을 찾기 위해 StackOverflow issue 작성했습니다.

import {profound} from './profound';

export const example0 = profound({}, () => 'anything');
export const example1 = profound({example0}, () => 'anything');
export const example2 = profound({example1}, () => 'anything');
export const example3 = profound({example2}, () => 'anything');
export const example4 = profound({example3}, () => 'anything');
export const example5 = profound({example4}, () => 'anything');
export const example6 = profound({example5}, () => 'anything');
export const example7 = profound({example6}, () => 'anything');
export const example8 = profound({example7}, () => 'anything');
export const example9 = profound({example8}, () => 'anything');
export const example10 = profound({example9}, () => 'anything');
export const example11 = profound({example10}, () => 'anything');
export const example12 = profound({example11}, () => 'anything');
export const example13 = profound({example12}, () => 'anything');
export const example14 = profound({example13}, () => 'anything');
export const example15 = profound({example14}, () => 'anything');
export const example16 = profound({example12, example13, example14, example15}, () => 'anything');
export const example17 = profound({example16, example13, example14, example15}, () => 'anything');

수많은 반복적인 코드가 아닌 빌딩 블록처럼 느껴지도록 하는 방식으로 코드를 작성할 수 있다는 느낌을 받고 싶습니다.

내가 방지하려는 것은 다음과 같은 코드입니다.

function alpha (a) {
  return a
}

function beta (a, b) {
  return alpha(a) + b
}

function gamma (a, b, c) {
  return alpha(a) + beta(b) + c
}

어리석은 것처럼 보일 수 있지만 많이 발생하는 것 같습니다.

다음은 보다 실제적인 예입니다.

function validateEmail (email) {
  return email
}

async getDomain (email) {
  // ignore details
  return 'gmail.com'
}

// what should the arguments to this be?
async sendMessageFromEmail (email) {
  const domain = getDomain(email)
  if (domain == 'gmail.com') return 'sentEmail'
  return null
}

//or 

async sendMessageFromEmailWithDomain (email, domain) {
 if (domain == 'gmail.com') return 'sentEmail'
 return null
}

// or a hybrid

async sendMessage (email, domain?) {
 domain = domain ?? getDomain(email)
 if (domain == 'gmail.com') return 'sentEmail'
 return null
}

여기sendMessage에 몇 가지 순열이 있는 것을 볼 수 있습니다. 이것은 멍청한 예이지만 많은 코드에서 볼 수 있는 것을 발생시킵니다.

결론적으로

이런 종류의 패턴과 위의 경우를 처리하는 다른 방법에 대한 생각을 듣고 싶습니다. 아래에 의견을 남기거나 트위터에 문의하세요. 읽어 주셔서 감사합니다!