工业聚 Lucifier129

🎯

Focusing

Thinking, coding and writing for fun

Lucifier129 / codata-lens-state-machine.ts

Created July 13, 2022 08:12

Modular state-management via codata & lens & state-machine

	type PrimitiveData = string \| number \| boolean \| null

	type ListData = LensData[]

	type ObjectData = {
	[key: string]: LensData
	}

	type LensData = PrimitiveData \| ListData \| ObjectData

Lucifier129 / push-stream.ts

Created July 8, 2022 09:53

push-stream via codata

	function pipe<A, B>(a: A, f: (a: A) => B): B;
	function pipe<A, B, C>(a: A, f: (a: A) => B, g: (b: B) => C): C;
	function pipe<A, B, C, D>(
	a: A,
	f: (a: A) => B,
	g: (b: B) => C,
	h: (c: C) => D
	): D;
	function pipe<A, B, C, D, E>(
	a: A,

Lucifier129 / pull-stream.ts

Last active July 7, 2022 09:40

pull-stream via codata

	function pipe<A, B>(a: A, f: (a: A) => B): B;
	function pipe<A, B, C>(a: A, f: (a: A) => B, g: (b: B) => C): C;
	function pipe<A, B, C, D>(
	a: A,
	f: (a: A) => B,
	g: (b: B) => C,
	h: (c: C) => D
	): D;
	function pipe<A, B, C, D, E>(
	a: A,

Lucifier129 / simple-rust-peg-parser.rs

Created March 12, 2022 11:53

	use std::collections::HashMap;
	extern crate peg;

	#[derive(Debug, Clone, PartialEq, Eq, Hash)]
	struct Variable(String);

	#[derive(Debug, Clone, PartialEq, Eq, Hash)]
	enum Value {
	Integer(i32),
	Variable(Variable),

Lucifier129 / class-match.ts

Last active February 5, 2022 14:46

	// library
	type Handler<T, R> = [new (...args: any) => T, (input: T) => R];

	type HandlerPattern<T extends Handler<any, any>> = T extends Handler<
	infer Pattern,
	any
	>
	? Pattern
	: unknown;

Lucifier129 / tagged-union.ts

Last active January 18, 2022 04:38

	type Prettier<T> = {
	[key in keyof T]: T[key];
	}

	type Tagged<Tag extends string> = {
	tag: Tag;
	};

	type Field<Key extends string, Value> = {
	[key in Key]: Value;

Lucifier129 / todo-app.remesh

Created November 16, 2021 07:38

A showcase of Remesh DSL


	domain TodoInputDomain {
	state TodoInput = ''

	command updateTodoInput(newTodoInput: string) {
	return TodoInput.new(newTodoInput)
	}
	}

	type Todo = {

Lucifier129 / merge-type.ts

Created September 5, 2021 11:56

conditional union/intersection types

	// type utils
	type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (
	x: infer R
	) => any
	? R
	: never;

	type UnionOf<T extends object> = T[keyof T];

	type IntersectionOf<T extends object> = UnionToIntersection<UnionOf<T>>;

Lucifier129 / procedural-tracer.ts

Created July 31, 2021 01:57

	type ProcedureContext = {
	path: Procedure[];
	next: (procedure: Procedure) => void;
	};

	type Procedure = {
	run: (ctx: ProcedureContext) => unknown;
	};

	const runProcedure = (

Lucifier129 / recoil-via-build-system.ts

Created May 13, 2021 03:37

implement recoil-like api via build-system abstraction

	export type Fetch<K = unknown, V = unknown> = (key: K) => V

	type Task<K = unknown, V = unknown> = (fetch: Fetch<K, V>) => V

	type Tasks<K = unknown, V = unknown> = (key: K) => Task<K, V> \| null

	type Store<K, V> = Map<K, V>

	type Build<K, V> = (tasks: Tasks<K, V>, key: K, store: Store<K, V>) => void