Golang实现TypeScript风格模式匹配功能的插件库go-pattern-match的使用

什么是模式匹配？

模式匹配起源于ML、Haskell和Erlang等函数式编程语言。它提供了一种强大的技术，用于基于输入与模式的匹配来控制流程。

与使用条件语句和switch语句的命令式控制流相比，模式匹配能够实现更简洁和声明式的代码，特别是在处理复杂的条件逻辑时。它避免了冗长的样板代码，更好地传达了意图。

关键组件

• Patterner: 这是一个需要实现Match函数的接口。任何实现此接口的类型都可以用作匹配器中的模式。
• Handler: 这是一个返回泛型类型T的函数类型。当找到匹配时调用此函数。
• Matcher: 这是一个结构体，保存要匹配的值、指示是否找到匹配的标志以及找到匹配时要返回的响应。

基本使用方法

package main

import (
  "fmt"
  "github.com/phakornkiong/go-pattern-match/pattern"
)

func match(input []int) string {
  return pattern.NewMatcher[string](input).
    WithValues(
      []any{1, 2, 3, 4},
      func() string { return "Nope" },
    ).
    WithValues(
      []any{
        pattern.Any(),
        pattern.Not(36),
        pattern.Union[int](99, 98),
        255,
      },
      func() string { return "Its a match" },
    ).
    Otherwise(func() string { return "Otherwise" })
}

func main() {
  fmt.Println(match([]int{1, 2, 3, 4}))      // "Nope"
  fmt.Println(match([]int{25, 35, 99, 255})) // "Its a match"
  fmt.Println(match([]int{1, 5, 6, 7}))      // "Otherwise"
}

主要API方法

NewMatcher[T any, V any](input V) *Matcher[T, V]

创建一个新的Matcher实例。泛型T和V代表任何类型。

T是处理函数在找到匹配时将返回的类型。 V是将与模式匹配的输入值的类型。

.WithPattern(pattern Patterner, fn Handler[T]) *Matcher[T, V]

检查提供的模式是否匹配整个输入。如果找到匹配，则调用提供的Handler函数并返回响应T。

.WithPatterns(patterns []Patterner, fn Handler[T]) *Matcher[T, V]

检查每个提供的模式是否匹配每个输入。如果找到匹配，则调用提供的Handler函数并返回响应T。

.WithValue(value V, fn Handler[T]) *Matcher[T, V]

检查提供的值与整个输入之间是否存在深度相等。如果找到匹配，则调用提供的Handler函数并返回响应T。

.WithValues(values any, fn Handler[T]) *Matcher[T, V]

如果模式作为模式提供，它将通过在每个值上调用Match方法来检查任何提供的值是否匹配输入，否则将对每个值进行深度相等检查。如果找到匹配，则调用提供的Handler函数并返回响应T。

.Otherwise(fn Handler[T]) *Matcher[T, V]

当没有找到输入的匹配时调用。它调用提供的Handler函数并返回响应T。

常用模式示例

Any模式

func match(input int) string {
  return pattern.NewMatcher[string](input).
    WithValue(
      2,
      func() string { return "Nope" },
    ).
    WithPattern(
      pattern.Any(), // 总是匹配
      func() string { return "Its a match" },
    ).
    Otherwise(func() string { return "Nope" })
}

match(5) // "Its a match"
match(6) // "Its a match"
match(7) // "Its a match"

Not模式

func match(input int) string {
  return pattern.NewMatcher[string](input).
    WithValue(
      2,
      func() string { return "2" },
    ).
    WithPattern(
      pattern.Not(3), // 如果不是3则匹配
      func() string { return "Its a match" },
    ).
    Otherwise(func() string { return "Otherwise" })
}

match(3) // "Otherwise"
match(6) // "Its a match"
match(7) // "Its a match"

When模式

func match(input int) string {
  return pattern.NewMatcher[string](input).
    WithValue(
      2,
      func() string { return "2" },
    ).
    WithPattern(
      // 如果输入大于100则匹配
      pattern.When[int](func(i int) bool { return i > 100 }),
      func() string { return "Its a match" },
    ).
    Otherwise(func() string { return "Otherwise" })
}

match(2)   // "2"
match(99)  // "Otherwise"
match(100) // "Its a match"
match(105) // "Its a match"

Union模式

func FoodSorterWithPattern(input string) (output string) {
  output = pattern.NewMatcher[string](input).
    WithPattern(
      pattern.Union("apple", "strawberry", "orange"),
      func() string { return "fruit" },
    ).
    WithPattern(
      pattern.Union("carrot", "pok-choy", "cabbage"),
      func() string { return "vegetable" },
    ).
    Otherwise(func() string { return "unknown" })

  return output
}

FoodSorterWithPattern("apple")  // "fruit"
FoodSorterWithPattern("orange") // "fruit"
FoodSorterWithPattern("carrot") // "vegetable"
FoodSorterWithPattern("candy")  // "unknown"

String模式

func match(input string) string {
  pattern1 := pattern.String().
    StartsWith("hello").
    EndsWith("world").
    MaxLength(11)

  pattern2 := pattern.String().
    Contains("dni").
    Regex(regexp.MustCompile("night$"))

  pattern3 := pattern.String().
    MinLength(3)

  pattern4 := pattern.String()

  return pattern.NewMatcher[string](input).
    WithPattern(
      pattern1,
      func() string { return "pattern 1" },
    ).
    WithPattern(
      pattern2,
      func() string { return "pattern 2" },
    ).
    WithPattern(
      pattern3,
      func() string { return "pattern 3" },
    ).
    WithPattern(
      pattern4,
      func() string { return "pattern 4" },
    ).
    Otherwise(func() string { return "This is impossible" })
}

match("hello world") // "pattern 1"
match("goodnight")   // "pattern 2"
match("abc")         // "pattern 3"
match("ab")          // "pattern 4"
match("")            // "pattern 4"

Slice模式

func match(input []int) string {
  pattern1 := pattern.Slice[int]().
    Head(1).
    Tail(100)

  subPattern2 := pattern.Int().Between(75, 100)

  pattern2 := pattern.Slice[int]().
    Contains(25).
    Contains(50).
    ContainsPattern(subPattern2)

  subHeadPattern3 := pattern.Int().Gt(1000)
  subTailattern3 := pattern.Int().Gt(2500)
  pattern3 := pattern.Slice[int]().
    HeadPattern(subHeadPattern3).
    TailPattern(subTailattern3)

  return pattern.NewMatcher[string](input).
    WithPattern(
      pattern1,
      func() string { return "pattern 1" },
    ).
    WithPattern(
      pattern2,
      func() string { return "pattern 2" },
    ).
    WithPattern(
      pattern3,
      func() string { return "pattern 3" },
    ).
    Otherwise(func() string { return "No pattern matched" })
}

match([]int{1, 2, 3, 100})       // "pattern 1"
match([]int{2, 25, 85, 50})      // "pattern 2"
match([]int{1001, 25, 3, 25001}) // "pattern 3"

总结

go-pattern-match库为Golang提供了类似TypeScript风格的强大模式匹配功能，使得复杂的条件逻辑可以以更声明式和简洁的方式表达。通过使用各种内置模式和方法，开发者可以构建灵活且易于维护的模式匹配逻辑。