Piotr Monwid-Olechnowicz hasparus

Refinement Types

What are they?

TLDR: type + predicate = refinement type

We have a type called T and a predicate on T ( (x: T) => boolean ) called P.
We can say that P refines T into a type PT, where PT is a subtype of T containing all values x of type T for which P(x) === true.

Sources

I'll try to sort it from less known to widely known.

Tomasz Łakomy
- https://tlakomy.com/who-is-senior-developer/
asthasr
- https://asthasr.github.io/posts/danger-of-simplicity/
Justin Meiners
- Think in Math
swyx
Learn in Public

Epistemic Effort: Low-to-medium effort. It isn't my best work, but I hope it shows that contributing to DefinitelyTyped isn't scary. I might refine it into a meetup talk or a tutorial someday.

18:37

I'm using both theme-ui and chakra-ui in an app, and it just doesn't work. Don't get me wrong, they're both really good libraries, and they're both using @emotion/core to provide the dynamic styling API that IMHO

Yo I'm Piotr
I'm working at Chop-Chop. We're recruiting. I'll get some money for bringing you in.
3 things I wanna sell tonight
1. Follow me on Twitter
2. Option has problems
3. Write your own instances

Yo I'm Piotr Monwid-Olechnowicz.

	function hasKey<T extends object, K extends string>(x: T, key: K): x is T & { [_ in K]: unknown } {
	return key in x;
	}

	type TypeOfs = {
	string: string;
	number: number;
	object: object;
	};


	type HeaderLinkProps<As extends ElementType> = { as?: As } & Omit<
	ComponentPropsWithoutRef<typeof s.a> & ComponentPropsWithoutRef<As>,
	"as"
	>;
	const HeaderLink = <As extends ElementType = "a">(
	props: HeaderLinkProps<As>
	) => (
	<s.a
	sx={{

	import * as ts from "typescript";

	const sourceFile = ts.createSourceFile(
	"example.ts",
	`
	interface Host {
	/**
	* @mockType {internet.ipv6}
	*/
	addr: string;

	import * as ts from "typescript";
	import { join } from "path";
	import { readFileSync } from "fs";

	// const source = `
	// import React, { FC } from 'react'
	// import { ReactThreeFiber } from './three-types'

	// type Three = typeof import('three')

	interface A { type: 'A', a: 10 };
	interface B { type: 'B', b: [11] };
	type AB = A \| B;

	type TypeOf<T extends { type: any }> = T extends { type: infer Type } ? Type : never;

	type Cases<T extends { type: any }, R> = {
	[P in TypeOf<T>]: (val: Extract<T, { type: P }>) => R
	}

	type Empty = undefined;
	const Empty = undefined;

	type Pending = 'Pending';
	const Pending = 'Pending';

	interface CrmUser {
	domain: string;
	}