denisputnov

import {useEffect} from 'react';

type EventKey = string;
type EventHandler<T = any> = (payload: T) => void;
type EventMap = Record<EventKey, EventHandler>;
type Bus<E> = Record<keyof E, E[keyof E][]>;

interface EventBus<T extends EventMap> {
  on<Key extends keyof T>(key: Key, handler: T[Key]): () => void;
  off<Key extends keyof T>(key: Key, handler: T[Key]): void;

SanariSan

javascript: (function () {
  var text = document.body.innerText;
  var spl = text.split(" ");
  if (spl.length > 3000) {
    text = spl.slice(0, 3000).join(" ");
  }

  fetch('https://api.openai.com/v1/completions', {
    method: 'POST',
    headers: {

semeleven

const fs = require("fs");
const path = require("path");
const util = require("util");
const { exec } = require("child_process");
const yargs = require("yargs/yargs");
const { hideBin } = require("yargs/helpers");
const execAsync = util.promisify(exec);

function commonYargs() {
    const argv = yargs(hideBin(process.argv))

ryanlintott

//
//  LayoutThatFits.swift
//  WWDC22Experiments
//
//  Created by Ryan Lintott on 2022-06-08.
//

import SwiftUI

struct LayoutThatFits: Layout {

byte-sourcerer

/**
 *  MacEditorTextView
 *  Copyright (c) Thiago Holanda 2020-2021
 *  https://twitter.com/tholanda
 *
 *  MIT license
 *  Modified by https://github.com/cjwcommuny for TextKit 2
 */

import Combine

ai

Краткая характеристика:

1. У него много сторов и сторы могут зависеть друг от друга, а не один большой стор и селекторы. То есть он ближе к Эфектору, чем в Редаксу/MobX. Всё ради tree shaking.
2. Он ближе к стору прямых измений. В публичном API нет экшенов. Но всё-таки value = 1 на манер MobX запрещены — значения можно менять только через спец. методы. И в синхронизации состояния с сервером экшены есть (просто скрыты из публичного API).

Плюсы:

1. Может работать без Логакса, чисто как стейт-менеджер.
2. API специально создан, чтобы хранить в сторах бизнес-логику, чем разгружать компоненты и упрощать переносимость приложения между фреймворками.
3. От 157 байт (!) в вашем JS-бандле.
4. Расчитан на агрессивный tree shaking, чтобы в JS-бандле был только код того состояния, которые используются в текущих страницах.
5. Очень ленивый — сторы на которых никто не подписан выгружаются из памяти, а их бизнес-логика останавливается.

nodkz

/* @flow */
/* eslint-disable no-param-reassign */

import express, { type $Request, type $Response } from 'express';
import uniqid from 'uniqid';
import aws from 'aws-sdk';

export type SignResult = {
  publicUrl: string,
  signedUrl: string,

nicklockwood

// Swift's untyped errors are a goddam PiTA. Here's the pattern I use to try to work around this.
// The goal is basically to try to guarantee that every throwing function in the app throws an
// ApplicationError instead of some unknown error type. We can't actually enforce this statically
// But by following this convention we can simplify error handling

enum ApplicationError: Error, CustomStringConvertible {
    
  // These are application-specific errors that may need special treatment
  case specificError1
  case specificError2(SomeType)

rohozhnikoff

import { Styler } from '../style/react-native-styler';

/* 
    если заменить StyleSheet.create({}) на Styler.create({})
    то все будет работать аналогично, включая перфоманс оптимизации
    
    к итоговому обьекту добавляется метод .$(), работающий аналогично вебовскому classNames
    
    плюс, в Styler.create можно загнать функцию, аргументом в которые отправляется глобальная тема и утилиты
*/

andymatuschak

A composable pattern for pure state machines with effects

State machines are everywhere in interactive systems, but they're rarely defined clearly and explicitly. Given some big blob of code including implicit state machines, which transitions are possible and under what conditions? What effects take place on what transitions?

There are existing design patterns for state machines, but all the patterns I've seen complect side effects with the structure of the state machine itself. Instances of these patterns are difficult to test without mocking, and they end up with more dependencies. Worse, the classic patterns compose poorly: hierarchical state machines are typically not straightforward extensions. The functional programming world has solutions, but they don't transpose neatly enough to be broadly usable in mainstream languages.

Here I present a composable pattern for pure state machiness with effects,