package main_test

import (
  "testing"
)

type Lexer struct {
  input string // the string being scanned.
  pos   int    // current position in the input.
}

func (l *Lexer) char() byte {
  return l.input[l.pos]
}
func (l *Lexer) withPos(n int) *Lexer {
  l.pos = n
  return l
}

func Is[T comparable](s T, vals ...T) bool {
  for _, v := range vals {
    if s == v {
      return true
    }
  }
  return false
}

const (
  firstSmallCharConst   = ' '
  midSmallCharConst     = '\t'
  lastSmallCharConst    = '\n'
  firstLargeCharConst   = 'a'
  midLargeCharConst     = 'j'
  lastLargeCharConst    = 'z'
  noMatchSmallCharConst = 'x'
  noMatchLargeCharConst = '-'
)

var (
  firstSmallCharVar   = firstSmallCharConst
  midSmallCharVar     = midSmallCharConst
  lastSmallCharVar    = lastSmallCharConst
  firstLargeCharVar   = firstLargeCharConst
  midLargeCharVar     = midLargeCharConst
  lastLargeCharVar    = lastLargeCharConst
  noMatchSmallCharVar = noMatchSmallCharConst
  noMatchLargeCharVar = noMatchLargeCharConst
  firstLex            = &Lexer{input: " \t\n", pos: 0}
  midLex              = firstLex.withPos(1)
  lastLex             = firstLex.withPos(2)
  noMatchLex          = &Lexer{input: "xyz", pos: 0}
)

var (
  exprOR = func(c rune) bool {
    return c == ' ' || c == '\t' || c == '\n' || c == '\r'
  }
  exprORLarger = func(c rune) bool {
    return c == 'a' || c == 'q' || c == 'r' || c == 'd' || c == 'w' || c == 'f' || c == 't' || c == 'b' || c == 'y' || c == 'z'
  }
  exprORMethod = func(lex *Lexer) bool {
    return lex.char() == ' ' || lex.char() == '\t' || lex.char() == '\n'
  }
  exprORMethodLarger = func(lex *Lexer) bool {
    return lex.char() == 'a' || lex.char() == 'q' || lex.char() == 'r' || lex.char() == 'd' || lex.char() == 'w' || lex.char() == 'f' || lex.char() == 't' || lex.char() == 'b' || lex.char() == 'y' || lex.char() == 'z'
  }
  switchCase = func(c rune) bool {
    switch c {
    case ' ', '\t', '\n':
      return true
    }
    return false
  }
  switchCaseLarger = func(c rune) bool {
    switch c {
    case 'a', 'q', 'r', 'd', 'w', 'f', 't', 'b', 'y', 'z':
      return true
    }
    return false
  }
  switchCaseMethod = func(lex *Lexer) bool {
    switch lex.char() {
    case ' ', '\t', '\n':
      return true
    }
    return false
  }
  switchCaseMethodLarger = func(lex *Lexer) bool {
    switch lex.char() {
    case 'a', 'q', 'r', 'd', 'w', 'f', 't', 'b', 'y', 'z':
      return true
    }
    return false
  }
  genericIs = func(c rune) bool {
    return Is(c, ' ', '\t', '\n')
  }
  genericIsMethod = func(lex *Lexer) bool {
    return Is(lex.char(), ' ', '\t', '\n')
  }
  genericIsLarger = func(c rune) bool {
    return Is(c, 'a', 'q', 'r', 'd', 'w', 'f', 't', 'b', 'y', 'z')
  }
  genericIsMethodLarger = func(lex *Lexer) bool {
    return Is(lex.char(), 'a', 'q', 'r', 'd', 'w', 'f', 't', 'b', 'y', 'z')
  }
)

func BenchmarkValueMembership(b *testing.B) {
  b.Run("Smaller", func(b *testing.B) {
    b.Run("ExprOR", func(b *testing.B) {
      b.Run("First", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, First, Literal
            _ = exprOR(' ')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, First, Const
            _ = exprOR(firstSmallCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, First, Var
            _ = exprOR(firstSmallCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, First, Method
            _ = exprORMethod(firstLex)
          }
        })
      })
      b.Run("Middle", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, Middle, Literal
            _ = exprOR('\t')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, Middle, Const
            _ = exprOR(midSmallCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, Middle, Var
            _ = exprOR(midSmallCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, Middle, Method
            _ = exprORMethod(midLex)
          }
        })
      })
      b.Run("Last", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, Last, Literal
            _ = exprOR('\n')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, Last, Const
            _ = exprOR(lastSmallCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, Last, Var
            _ = exprOR(lastSmallCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, Last, Method
            _ = exprORMethod(lastLex)
          }
        })
      })
      b.Run("NoMatch", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, NoMatch, Literal
            _ = exprOR('x')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, NoMatch, Const
            _ = exprOR(noMatchSmallCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, NoMatch, Var
            _ = exprOR(noMatchSmallCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, ExprOR, NoMatch, Method
            _ = exprORMethod(noMatchLex)
          }
        })
      })
    })
    b.Run("SwitchCase", func(b *testing.B) {
      b.Run("First", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, First, Literal
            _ = switchCase(' ')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, First, Const
            _ = switchCase(firstSmallCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, First, Var
            _ = switchCase(firstSmallCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, First, Method
            _ = switchCaseMethod(firstLex)
          }
        })
      })
      b.Run("Middle", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, Middle, Literal
            _ = switchCase('\t')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, Middle, Const
            _ = switchCase(midSmallCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, Middle, Var
            _ = switchCase(midSmallCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, Middle, Method
            _ = switchCaseMethod(midLex)
          }
        })
      })
      b.Run("Last", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, Last, Literal
            _ = switchCase('\n')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, Last, Const
            _ = switchCase(lastSmallCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, Last, Var
            _ = switchCase(lastSmallCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, Last, Method
            _ = switchCaseMethod(lastLex)
          }
        })
      })
      b.Run("NoMatch", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, NoMatch, Literal
            _ = switchCase('x')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, NoMatch, Const
            _ = switchCase(noMatchSmallCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, NoMatch, Var
            _ = switchCase(noMatchSmallCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, SwitchCase, NoMatch, Method
            _ = switchCaseMethod(noMatchLex)
          }
        })
      })
    })
    b.Run("GenericIs", func(b *testing.B) {
      b.Run("First", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, First, Literal
            _ = genericIs(' ')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, First, Const
            _ = genericIs(firstSmallCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, First, Var
            _ = genericIs(firstSmallCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, First, Method
            _ = genericIsMethod(firstLex)
          }
        })
      })
      b.Run("Middle", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, Middle, Literal
            _ = genericIs('\t')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, Middle, Const
            _ = genericIs(midSmallCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, Middle, Var
            _ = genericIs(midSmallCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, Middle, Method
            _ = genericIsMethod(midLex)
          }
        })
      })
      b.Run("Last", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, Last, Literal
            _ = genericIs('\n')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, Last, Const
            _ = genericIs(lastSmallCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, Last, Var
            _ = genericIs(lastSmallCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, Last, Method
            _ = genericIsMethod(lastLex)
          }
        })
      })
      b.Run("NoMatch", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, NoMatch, Literal
            _ = genericIs('x')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, NoMatch, Const
            _ = genericIs(noMatchSmallCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, NoMatch, Var
            _ = genericIs(noMatchSmallCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Smaller, GenericIs, NoMatch, Method
            _ = genericIsMethod(noMatchLex)
          }
        })
      })
    })
  })
  b.Run("Larger", func(b *testing.B) {
    b.Run("ExprOR", func(b *testing.B) {
      b.Run("First", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, First, Literal
            _ = exprORLarger('a')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, First, Const
            _ = exprORLarger(firstLargeCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, First, Var
            _ = exprORLarger(firstLargeCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, First, Method
            _ = exprORMethodLarger(firstLex)
          }
        })
      })
      b.Run("Middle", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, Middle, Literal
            _ = exprORLarger('j')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, Middle, Const
            _ = exprORLarger(midLargeCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, Middle, Var
            _ = exprORLarger(midLargeCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, Middle, Method
            _ = exprORMethodLarger(midLex)
          }
        })
      })
      b.Run("Last", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, Last, Literal
            _ = exprORLarger('z')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, Last, Const
            _ = exprORLarger(lastLargeCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, Last, Var
            _ = exprORLarger(lastLargeCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, Last, Method
            _ = exprORMethodLarger(lastLex)
          }
        })
      })
      b.Run("NoMatch", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, NoMatch, Literal
            _ = exprORLarger('-')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, NoMatch, Const
            _ = exprORLarger(noMatchLargeCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, NoMatch, Var
            _ = exprORLarger(noMatchLargeCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, ExprOR, NoMatch, Method
            _ = exprORMethodLarger(noMatchLex)
          }
        })
      })
    })
    b.Run("SwitchCase", func(b *testing.B) {
      b.Run("First", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, First, Literal
            _ = switchCaseLarger('a')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, First, Const
            _ = switchCaseLarger(firstLargeCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, First, Var
            _ = switchCaseLarger(firstLargeCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, First, Method
            _ = switchCaseMethodLarger(firstLex)
          }
        })
      })
      b.Run("Middle", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, Middle, Literal
            _ = switchCaseLarger('j')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, Middle, Const
            _ = switchCaseLarger(midLargeCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, Middle, Var
            _ = switchCaseLarger(midLargeCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, Middle, Method
            _ = switchCaseMethodLarger(midLex)
          }
        })
      })
      b.Run("Last", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, Last, Literal
            _ = switchCaseLarger('z')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, Last, Const
            _ = switchCaseLarger(lastLargeCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, Last, Var
            _ = switchCaseLarger(lastLargeCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, Last, Method
            _ = switchCaseMethodLarger(lastLex)
          }
        })
      })
      b.Run("NoMatch", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, NoMatch, Literal
            _ = switchCaseLarger('-')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, NoMatch, Const
            _ = switchCaseLarger(noMatchLargeCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, NoMatch, Var
            _ = switchCaseLarger(noMatchLargeCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, SwitchCase, NoMatch, Method
            _ = switchCaseMethodLarger(noMatchLex)
          }
        })
      })
    })
    b.Run("GenericIs", func(b *testing.B) {
      b.Run("First", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, First, Literal
            _ = genericIsLarger('a')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, First, Const
            _ = genericIsLarger(firstLargeCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, First, Var
            _ = genericIsLarger(firstLargeCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, First, Method
            _ = genericIsMethodLarger(firstLex)
          }
        })
      })
      b.Run("Middle", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, Middle, Literal
            _ = genericIsLarger('j')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, Middle, Const
            _ = genericIsLarger(midLargeCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, Middle, Var
            _ = genericIsLarger(midLargeCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, Middle, Method
            _ = genericIsMethodLarger(midLex)
          }
        })
      })
      b.Run("Last", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, Last, Literal
            _ = genericIsLarger('z')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, Last, Const
            _ = genericIsLarger(lastLargeCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, Last, Var
            _ = genericIsLarger(lastLargeCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, Last, Method
            _ = genericIsMethodLarger(lastLex)
          }
        })
      })
      b.Run("NoMatch", func(b *testing.B) {
        b.Run("Literal", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, NoMatch, Literal
            _ = genericIsLarger('-')
          }
        })
        b.Run("Const", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, NoMatch, Const
            _ = genericIsLarger(noMatchLargeCharConst)
          }
        })
        b.Run("Var", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, NoMatch, Var
            _ = genericIsLarger(noMatchLargeCharVar)
          }
        })
        b.Run("Method", func(b *testing.B) {
          for b.Loop() {
            // Factors: Larger, GenericIs, NoMatch, Method
            _ = genericIsMethodLarger(noMatchLex)
          }
        })
      })
    })
  })
}