Understanding Exhaustive Pattern Matching with `Match.type`, `Match.value`, `$match`, and `$is` i...

Hello. I'm trying to use exhaustive pattern matching and I'm not clear on when/how to use

Match.type

Match.type

Match.value

Match.value

$match

$match

, or

$is

$is

.

I've got my schema and data types defined using the Schema and Data packages, but one snag I'm noticing is that the patterns I need to match on closely resemble Schema definitions but are instead

PatternPrimitive

PatternPrimitive

types. Is it possible to create

PatternPrimitive

PatternPrimitive

s from my existing structs, or do I need to do this manually? That seems to deviate from the source of truth I've already established, though it should be fine if I use exhaustive matching. I think I was jut hoping/expecting to be able to pattern match on the structs I've already defined.

I'm also noticing I can use

$match

$match

and

$is

$is

to some effect... Is there a best practice I can follow, or is Effect so big and unopinionated here that it's kind of a "do what feels best" scenario?

For reference, the code I'm writing is like this:

export const CoveredCellSchema = Schema.Struct({
  revealed: Schema.Literal(false),
  flagged: Schema.Literal(false),
  live: Schema.Boolean,
  adjacents: Schema.Number,
});

export const CoveredClearCellSchema = Schema.Struct({
  // similar
});

export const CoveredLiveCellSchema = Schema.Struct({
  // similar
});

type CoveredCell = Schema.Schema.Type<typeof CoveredCellSchema>;
type CoveredClearCell = Schema.Schema.Type<
  typeof CoveredClearCellSchema
>;
type CoveredLiveCell = Schema.Schema.Type<typeof CoveredLiveSchema>;

// These two types represent the possible permutations of CoveredCell, so this match would be exhaustive.
const match = Match.type<CoveredCell>().pipe(
    Match.when(CoveredClearCell, (c) => ...),
    Match.when(CoveredLiveCell, (c) => ...),
    Match.exhaustive
  );

export const CoveredCellSchema = Schema.Struct({
  revealed: Schema.Literal(false),
  flagged: Schema.Literal(false),
  live: Schema.Boolean,
  adjacents: Schema.Number,
});

export const CoveredClearCellSchema = Schema.Struct({
  // similar
});

export const CoveredLiveCellSchema = Schema.Struct({
  // similar
});

type CoveredCell = Schema.Schema.Type<typeof CoveredCellSchema>;
type CoveredClearCell = Schema.Schema.Type<
  typeof CoveredClearCellSchema
>;
type CoveredLiveCell = Schema.Schema.Type<typeof CoveredLiveSchema>;

// These two types represent the possible permutations of CoveredCell, so this match would be exhaustive.
const match = Match.type<CoveredCell>().pipe(
    Match.when(CoveredClearCell, (c) => ...),
    Match.when(CoveredLiveCell, (c) => ...),
    Match.exhaustive
  );

The naming is awful, my apologies. I'm mostly curious if there is a common convention or best practice for situations like this. I've been searching all evening but having no luck so far. Thanks for any guidance on this!

Understanding Exhaustive Pattern Matching with `Match.type`, `Match.value`, `$match`, and `$is` i...

Hello. I'm trying to use exhaustive pattern matching and I'm not clear on when/how to use

Match.type

Match.type

Match.value

Match.value

$match

$match

, or

$is

$is

.

I've got my schema and data types defined using the Schema and Data packages, but one snag I'm noticing is that the patterns I need to match on closely resemble Schema definitions but are instead

PatternPrimitive

PatternPrimitive

types. Is it possible to create

PatternPrimitive

PatternPrimitive

$match

$match

and

$is

$is

export const CoveredCellSchema = Schema.Struct({
  revealed: Schema.Literal(false),
  flagged: Schema.Literal(false),
  live: Schema.Boolean,
  adjacents: Schema.Number,
});

export const CoveredClearCellSchema = Schema.Struct({
  // similar
});

export const CoveredLiveCellSchema = Schema.Struct({
  // similar
});

type CoveredCell = Schema.Schema.Type<typeof CoveredCellSchema>;
type CoveredClearCell = Schema.Schema.Type<
  typeof CoveredClearCellSchema
>;
type CoveredLiveCell = Schema.Schema.Type<typeof CoveredLiveSchema>;

// These two types represent the possible permutations of CoveredCell, so this match would be exhaustive.
const match = Match.type<CoveredCell>().pipe(
    Match.when(CoveredClearCell, (c) => ...),
    Match.when(CoveredLiveCell, (c) => ...),
    Match.exhaustive
  );

export const CoveredCellSchema = Schema.Struct({
  revealed: Schema.Literal(false),
  flagged: Schema.Literal(false),
  live: Schema.Boolean,
  adjacents: Schema.Number,
});

export const CoveredClearCellSchema = Schema.Struct({
  // similar
});

export const CoveredLiveCellSchema = Schema.Struct({
  // similar
});

type CoveredCell = Schema.Schema.Type<typeof CoveredCellSchema>;
type CoveredClearCell = Schema.Schema.Type<
  typeof CoveredClearCellSchema
>;
type CoveredLiveCell = Schema.Schema.Type<typeof CoveredLiveSchema>;

// These two types represent the possible permutations of CoveredCell, so this match would be exhaustive.
const match = Match.type<CoveredCell>().pipe(
    Match.when(CoveredClearCell, (c) => ...),
    Match.when(CoveredLiveCell, (c) => ...),
    Match.exhaustive
  );

Understanding Exhaustive Pattern Matching with `Match.type`, `Match.value`, `$match`, and `$is` i...

Similar Threads

Understanding Exhaustive Pattern Matching with `Match.type`, `Match.value`, `$match`, and `$is` i...

Similar Threads

Similar Threads

Similar Threads