Фрактальная шизофрения

Тогда вам стоит вот это почитать — http://conal.net/fran/tutorial.htm На практике реактивное программирование на потоках вылилось в штуки вроде reactive LINQ.

Да, делим, и дальше в статье описывается как именно и что с этого получается ;)

Разговор о том, что первично, тем более если вы сравниваете с концепцией "начало начал не имеет начала, безначальность бесконечна" (фрактал), был бы не особо уместен. В моем понимании это лишь одна из составляющих — движение есть следствие взаимодействия других сил, и для меня оно не первично.

Не знаю, как вы сделали вывод, что я отрицаю структуру в интерфейсах — но это другой слой, который не относится к данным, и представлен в виде иерархичного DOM-дерева, создаваемого опять же иерархичной композицией реакт-компонентов. Прокидывать же в инпут данные через всех родителей, а сигналы от него собирать по всей цепочке — это и есть ограничение, заставляющее "учитывать везде предельную скорость взаимодействия", портальность снимает эту проблему. Но она присутствует в цепочках react props, когда данные, нужные одному лишь чайлду, заставляют всех родителей и соседние компоненты перерендериваться, а в предлагаемой "фрактальной" архитектуре, похоже, именно так.

Ну вот не знаю про "шаг впереди". В ваших примерах есть как раз "обмен данными между компонентами" в виде

export const App = fractal(async function* () {
    const { User } = await import('./user')

    while (true) yield `User ${yield* User}`
})

В моей же схеме данные от User лежали бы в общедоступном хранилище, с ними удобно работать, нормализовывать, мутировать, создавать сложные селекторы из композиции различных параметров, сериализовывать в json-структуры, использовать для общения с другими сервисами по АПИ.

А ваш подход скорее из мира, когда данные хранились в дата-атрибутах DOM, постоянно извлекались и сериализовывались-десериализовывались, и так же работать с постоянными yield для извлечение набора актуальных данных — это затратно. Код будет погрязать в бесконечных

Promise.all(await exec(One), await exec(Two))
   .then(arr => arr.map(frame => frame.data))
   .then(finallyGotSomeRelevantData)

// вместо

const store = observable({
   one: 1,
   two: 2,
   get relevantData() { return [this.one, this.two]}
})

const easyGetAllYouNeed = store.relevantData;

Не очень понял про то, как вы хотите одну сущность переводить одновременно в json и html — то есть в объектах описывать все возможные комбинации раскладки и атрибуты? Вроде нет, в ваших примерах на гитхабе используются вполне классический JSX в xml-формате, только с очень сложным извлечением данных.

Что-то почитал репозитории и, кажется, толковую дискуссию мы не создадим. Мне банально непонятен весь этот звездочный код и его смысл

    const Counters = fractal(async function* _Counters() {
        yield* TODO_MODE(TodoMode.Service)

        while (true) {
            let active = 0
            let completed = 0

            for (const Todo of yield* Todos) {
                const { Done } = (yield* Todo) as TodoService
                ;(yield* Done) ? completed++ : active++
            }

            yield { completed, active }
        }
    })

Тоже много лет назад писал подобные системы, полные функциональщины и скрытых слоев, с привкусом Алохоморы при выполнении. Но потом дорос до понимания, что лучший код — максимально простой и понятный, так как работаю в корпоративных продуктах, где это — ключ к успеху. Бывает, приходят ребята с очень нестандартными подходами, но их код не понимают и приходится переписывать после их ухода. В общем, не вижу пользы от вашего подхода, кроме как для саморазвития)

Ну просто у меня есть догадка (возможно, неверная), что когда хочется написать const res = yield something(), то обычно это на самом деле желание сделать res = await something() и иметь something() как async function. Yield предназначен для генерации последовательностей, его использование для чего-то еще — пережитки старины глубокой, когда люди еще не догадались до async-await.

Но тут все-таки «мясо» идеи не в генераторах

Я, честно говоря, все равно плохо понял, в чем преимущество перед реактивностью из Реакта.

Но тут все-таки «мясо» идеи не в генераторах, а в том, как смотреть на потоки данных.

Именно так. Генераторы с их возможностью ввода/вывода параметров по ходу выполнения просто оказались идеальными кандидатами для организации локаничного решения.

Я, честно говоря, все равно плохо понял, в чем преимущество перед реактивностью из Реакта.

Ни в чем, я не ставлю фрактал в противовес реакту, реактивность последнего во фрактальных приложениях попросту не используется, используется только рендеринг jsx -> html, что может быть заменено на гораздо более легковесную альтернативу.

Интеграцию именно с react я написал потому что это привычный для меня инструмент и естественно это первое, что пришло мне в голову, плюс ко всему — широкий охват желающих попробовать с минимумом усилий. Был бы я backend разработчиком — я бы в первую очередь написал интеграцию с чем-то серверным.

Разве что тут задается не только структура интерфейса, но и любых других данных

Всё правильно, фрактал задает общий стиль для описания любых данных и автоматически организует их "течение". Если рассматривать всё приложение как одно большое дерево с потоком данных, направленным к корню, то на листьях будут скорее всего примитивы, а на выходе из корня поток сложных структур, например jsx-снимков, которые отдаются реакту для рендера.

Продолжая разговор о генераторах и реакте, может не по теме, но могу привести некоторую параллель, смотрите — ниже два абсолютно идентичных компонента, первый реакт, второй фрактал

function Counter() {
    const [count, setCount] = useState(0)
    // !
    return (
        <div>
            <p>Current value {count}</p>
            <button onClick={() => setCount(count + 1)}>Increment</button>
        </div>
    )
}

const Counter = fractal(async function* () {
    const Value = fraction(0)

    while (true) { // !
        const count = yield* Value

        yield (
            <div>
                <p>Current value {count}</p>
                <button onClick={() => Value.use(count + 1)}>Increment</button>
            </div>
        )
    }
})

Реакт будет вызывать функцию Counter каждый раз, когда будет вызываться setCount, при этом useState по факту отработает полностью только при первом вызове, реакт отслеживает это внутри себя с помощью "магии" и при последующих вызовах реакт пропускает её, как бы имитирует то, что код сразу же выполняется с того места где я поставил восклицательный знак.

Фрактал просто идет до первого yield (по пути собирая зависимости, подключенные через yield*) отдает полученное значение в поток и ждёт изменений, как только дождался, код, благодаря генератору, просто продолжает своё выполнение c момента последней остановки до следующего yield и так по кругу. Никакой магии — всё последовательно и логично, но суть не в этом.

Не правда ли эти два компонента даже визуально на уровне кода выглядят очень похожими? Существенная разница здесь в том, что react компонент сильно ограничен тем, что должен использоваться только в составе jsx-кода и отдавать значение, соответствующее интерфейсу JSX.Element, в то время как фрактал может отдавать что угодно и использоваться в составе чего угодно.

Надеюсь, что пример получился удачным :)