JSPM

  • ESM via JSPM
  • ES Module Entrypoint
  • Export Map
  • Keywords
  • License
  • Repository URL
  • TypeScript Types
  • README
  • Created
  • Published
  • Downloads 9
  • Score
    100M100P100Q48320F
  • License MPL-2.0

Variant types in Roblox TypeScript

Package Exports

  • @rbxts/variant
  • @rbxts/variant/out/init.lua

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (@rbxts/variant) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

Variant (for Roblox)

This is a roblox typescript variant (heh, pun) of Variant. See the Variant documentation on how to use Variant.

A variant type is like an enum but each case can hold some extra data.

npm i --save @rbxts/variant

As per the original repo description - Variant aims to bring the experience of variant types to TypeScript. Variant types, a.k.a. discriminated unions in the TypeScript world, are an excellent tool for describing and handling flexible domain models and tiny DSLs. However, because "TypeScript instead builds on JavaScript patterns as they exist today" using them as-is can result in tedious and fragile code. This project addresses that by providing well-typed, fluent, and expressive tools to safely do away with the boilerplate.

Documentation

Example usage

import { variantModule, TypeNames, VariantOf, fields, match } from "@rbxts/variant";

export const Animal = variantModule({
    dog: fields<{name: string, favoriteBall?: string}>(),
    cat: fields<{name: string, furnitureDamaged: number}>(),
    snake: (name: string, pattern = 'striped') => ({name, pattern}),
});

export type Animal<T extends TypeNames<typeof Animal> = undefined>
    = VariantOf<typeof Animal, T>;

const aDog = Animal.dog({name: "Wally"}); // will result in a discriminate value of { type: "dog", name: "Wally" }
const aCat = Animal.cat({name: "Whiskers", furnitureDamaged: true}); // will result in a discriminate value of { type: "cat", name: "Whiskers", 
const aSnake = Animal.snake("Nyx", "dotted")

const describeAnimal = (animal: Animal) => match(animal, {
    cat: ({name}) => `${name} is sleeping on a sunlit window sill.`,
    dog: ({name, favoriteBall}) => [
        `${name} is on the rug`,
        favoriteBall ? `nuzzling a ${favoriteBall} ball.` : '.' 
    ].join(' '),
    snake: s => `${s.name} is enjoying the heat of the lamp on his ${s.pattern} skin`,
});

print(describeAnimal(aDog)) //  Wally is on the rug
print(describeAnimal(aCat)) // Whiskers is sleeping on a sunlit window sill.
print(describeAnimal(aSnake)) // Nyx is enjoying the heat of the lamp on his spotted skin

Supports

Functions

  • cast
  • isOfVariant
  • keys
  • keymap
  • lookup
  • match
  • matchElse (deprecated in main lib, so not included)
  • narrow
  • outputTypes
  • partialLookup
  • partialMatch (deprecated in main lib, so not included)

Variant Creation

  • variant
  • fields
  • payload
  • variantFactory
  • variantList
  • variantModule

Types

  • Flags<T>
  • Handler<T>
  • KeysOf<T>
  • Lookup<T, U>
  • Matrix<T>
  • TypeNames<T>
  • VariantCreator<T, F, K?>
  • VariantModule<K>
  • VariantOf<T>
  • TypeExt<K, T>
  • WithProperty<K, T> (deprecated in main lib, so not included)

Credits

Thanks to Paarth for creating this awesome library for vanilla TypeScript, without their awesome work this would not exist.