Ustice

Type Functions: Making Type-Level Programming Ordinary

Status: Brainstorm / discussion draft
Goal: Explore a TypeScript-compatible way to make type-level programming look and behave more like ordinary TypeScript.

Summary

TypeScript already has a powerful type-level programming language.

It supports branching through conditional types, local bindings through infer, iteration through recursion, pattern matching through conditional inference, and higher-order abstractions through a variety of encodings. It is powerful enough to support substantial compile-time computation—and, famously, even Doom.

Ustice

Boolean Algebra in a nutshell for JS/TS programmers

There are a lot of strategies that you will hear about in the Javascript community for keeping your conditionals from becoming a tangled mess. This isn't like them. This is someting different. MATH! Boolean Algebra to be exact. I use it all the time to simplify complex conditionals. There are two things that you need to know: de Morgan's Theorem, and Karnaugh (pronounced CAR-no) Maps. (Don't worry, there is no test)

de Morgan's Theorem

De Morgan's Theorem is great distributing nots (!), and for when you want to convert an && to an ||, or back. This is it:

 !(A && B) = !A || !B

Ustice

def larger_of(a, b):
  return a if a[1] > b[1] else b

def reset_to(index):
  return [index, 1]

def is_sequential(a, b):
  return a == b - 1

def grow(vector):

Ustice

// ==UserScript==
// @name     D&D Beyond fixed sidebar
// @version  6
// @grant    none
// @include /^(https://www.dndbeyond.com/profile/[^/]*/characters/.*|https://www.dndbeyond.com/characters/.*)$/
// ==/UserScript==
const clickElement = (query) => {
  console.log('Clicking ' + query)
  const element = document.querySelector(query)
  element?.click()

Ustice

/**
 * Compares the properties of two objects and returns an array of paths to the 
 * properties of the baseObject that are different or non-existant in the 
 * compareObject.
 *
 * person0 = {
 *   name: {
 *     first: 'Eve'
 *   }
 * };