devanshj

// ps: this is might be a little outdated compared to one in my closed source project
import { useSpring, to, SpringValue,   animated } from "@react-spring/web"
import { assertNever, Ex } from "./";
import * as Re from "react";

namespace Sp {
  export type Springable = number | string | readonly (string | number)[];
  export interface Spring<T extends Springable> { __Spring: void, __T: T }
  export interface UnknownSpring extends Spring<Springable> {}

devanshj

Replying to https://twitter.com/DavidKPiano/status/1430627497612283910

(This isn't the actual piece I would have written, this is just extempore)

Let's take a look at these two machines

const fetchUserhMachine = createMachine({
  context: {},
  initial: "idle",

devanshj

const useStates = <S extends string>({ initial, effects }: {
    initial: S,
    effects: 
        & { [K in S]: () => PromiseOrValue<NullOrValue<Exclude<S, K>>> }
        & { ERROR: (error: unknown) => PromiseOrValue<NullOrValue<S>> }
}): StateTuple<WithError<S>> => {
    let [state, setState] = useState(initial as WithError<S>);
    const runEffect = (state: WithError<S>, error?: unknown) => {
        let returned = state === "ERROR" ? effects[state](error) : effects[state]();
        if (returned instanceof Promise) {

devanshj

// https://twitter.com/steveruizok/status/1297977525755424771

declare const machine:
  <D extends Definition<D>>(definition: D) =>
    ({ withTransitions: <T extends { [event in string]: State<D> }>(transition: T) => D & T })

declare const childMachine:
  <D extends Definition<D>>(config: D) => D & Tag<"ChildMachine">;

type Definition<D> =

devanshj

Declarative writing style and "space"

(Disclaimer: this is not to encourage writing expressions all the time no matter what, I'm just pointing out some things that makes me want to write expressions more.)

What do you think is the difference between...

function parity(x) {
    if (x % 2 === 0) {
        return Parity.EVEN

devanshj

This is an explanation for https://mobile.twitter.com/devanshj__/status/1204338726471688192

Okay so our task is to convert { a: A, b: B } | { b: B, c: C } to { a: A, b: B, c?: never } | { a?: never b: B, c: C }.

Now first thing to get is we somehow need each type from that union. We can use the distributive property of the conditional type. (I learned this from @jcalz) like this:

type Exact<Spec> = Spec extends any ? {
  each: Spec // here Spec will be each union at a time
} : never;