Popularity
4.0
Growing
Activity
0.0
Declining
91
2
6

Programming language: Go
License: MIT License
Tags: Utilities    

pattern-match alternatives and similar packages

Based on the "Utilities" category.
Alternatively, view pattern-match alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of pattern-match or a related project?

Add another 'Utilities' Package

README

Go pattern matching

Mentioned in Awesome Go Go Report Card Build Status codecov GoDoc LICENSE

It's just another implementation of pattern matching in Go. I have been inspired by Python pattern matching, that's why I wanted to try writing something similar in Go :) For now the following matching are implemented :

  • [x] Simple types (like int, int64, float, float64, bool..).
  • [x] Struct type.
  • [x] Slices (with HEAD, TAIL, OneOf patterns).
  • [x] Dictionary (with ANY, OneOf pattern).
  • [x] Regexp.
  • [x] Additional custom matching (ability to add special matching for some, structs for example).

Usages

Fibonacci example:

func fib(n int) int {
    _, res := match.Match(n).
        When(1, 1).
        When(2, 1).
        When(match.ANY, func() int { return fib(n-1) + fib(n-2) }).
        Result()

    return res.(int)
}

Simple types:

isMatched, mr := match.Match(42).
                When(42, 10).
                Result()
// isMatched - true, mr - 10

With Structs:

  • Simple check value by type ```go val := TestStruct{1}

isMatched, _ := Match(val). When(func(TestStruct) {}, 1). Result()


- Check value by type and condition
```go
val := TestStruct{1}

isMatched, _ := Match(val).
    When(func(ts TestStruct) bool { return ts.value == 42 }, 1).
    When(func(ts AnotherStruct) bool { return ts.stringValue == "hello" }, 2).
    Result()

With Maps:

isMatched, mr := match.Match(map[string]int{
                    "rsc": 3711,
                    "r":   2138,
                    "gri": 1908,
                    "adg": 912,
                }).
                When(map[string]interface{}{
                    "rsc": 3711,
                    "r":   2138,
                    "gri": 1908,
                    "adg": match.ANY,
                }, true).
                Result()

With Slices:

isMatched, mr := match.Match([]int{1, 2, 3, 4, 5, 6}).
                When([]interface{}{match.HEAD, 3, match.OneOf(3, 4), 5, 6}, 125).
                Result()

With regexps:

isMatched, mr := match.Match("gophergopher").
                When("gophergopher", func() interface{} { return true }).
                Result()

Without result:

func main() {
    Match(val).
    When(42, func() { fmt.Println("You found the answer to life, universe and everything!") }).
    When(ANY, func() { fmt.Println("No.. It's not an answer.") }).
    Result()
}

Installation

Just go get this repository in the following way:

go get github.com/alexpantyukhin/go-pattern-match

Full example

package main

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

func main() {
    isMatched, mr := match.Match([]int{1, 2, 3}).
        When(42, false).
        When([]interface{}{match.HEAD, 2, 3}, true).
        Result()


    if isMatched {
        fmt.Println(mr)
    }
}


*Note that all licence references and agreements mentioned in the pattern-match README section above are relevant to that project's source code only.