I am implementing a lexer for an experimental language by the name "Phoenix", the language supports four primary arithmetic expression for integers only (add, subtract, multiply, divide), variable assignment and print statement.

Typical input:

```
# this is a comment
value = 1 + 7 / 4 * (30)
print('Value = ', value)

```

**lexer.go:**

```
package lexer

import (
    "bytes"
    "fmt"
    "io"
    "os"
    "phoenix/log"
    "phoenix/token"
    "unicode"
)

// Lexer type for our lexer
type Lexer struct {
    SourceFileName          string
    fh                      *os.File
    UnScannedChar           byte
    CurrentLine, CurrentCol uint64
}

// New sets up the lexer
func (l *Lexer) New(fileName string) {
    tmpFh, err := os.Open(fileName)
    l.fh = tmpFh

    if err != nil {
        log.Error(fmt.Sprintf("couldn't open file '%v'", fileName))
        os.Exit(0)
    }

    l.SourceFileName = fileName
    l.CurrentLine = 1
}

// NextChar updates Lexer.unScannedChar
func (l *Lexer) NextChar() (err error) {
    tempChar := make([]byte, 1)
    _, er := l.fh.Read(tempChar)

    if er != nil {
        if er == io.EOF {
            err = io.EOF
            return
        }
        log.Error(fmt.Sprintf("error while reading from file '%v'",
            l.SourceFileName))
        os.Exit(0)
    }
    l.UnScannedChar = tempChar[0]

    if l.UnScannedChar == '\n' {
        l.CurrentLine++
        l.CurrentCol = 0
    } else {
        l.CurrentCol++
    }
    return
}

func (l *Lexer) isIdentifierStart() bool {
    return unicode.IsLetter(rune(l.UnScannedChar)) ||
        l.UnScannedChar == '_'
}

func (l *Lexer) isIdentifierPart() bool {
    return l.isIdentifierStart() || unicode.IsNumber(rune(l.UnScannedChar))
}

func (l *Lexer) scanInteger() (newToken token.Token) {
    var buffer bytes.Buffer

    buffer.WriteString(string(l.UnScannedChar))
    l.NextChar()

    for unicode.IsDigit(rune(l.UnScannedChar)) {
        buffer.WriteString(string(l.UnScannedChar))
        l.NextChar()
    }

    newToken.Rep = token.INTEGER
    newToken.Data = buffer.String()
    return
}

func (l *Lexer) scanID() (newToken token.Token) {
    var buffer bytes.Buffer

    buffer.WriteString(string(l.UnScannedChar))
    l.NextChar()

    for l.isIdentifierPart() {
        buffer.WriteString(string(l.UnScannedChar))
        l.NextChar()
    }

    newToken.Data = buffer.String()
    switch newToken.Data {
    case "print":
        newToken.Rep = token.PRINT
    default:
        newToken.Rep = token.ID
    }

    /* we need to seek back the reading cursor as  the next call of NextToken()
    will invoke NextChar(), neglecting the current unscanned character */
    l.fh.Seek(-1, os.SEEK_CUR)

    return
}

func (l *Lexer) scanString() (newToken token.Token) {
    var buffer bytes.Buffer

    l.NextChar()

    for l.UnScannedChar != '\'' {
        buffer.WriteString(string(l.UnScannedChar))
        l.NextChar()
    }

    newToken.Rep = token.STRING
    newToken.Data = buffer.String()
    return
}

// NextToken scans the Lexer.UnScannedChar and creates its correspondant token
func (l *Lexer) NextToken() (newToken token.Token) {
    err := l.NextChar()

    if err == io.EOF {
        newToken.Rep = token.EOF
        return
    }
    // scan integers
    if unicode.IsDigit(rune(l.UnScannedChar)) {
        return l.scanInteger()
    }

    // scan identifiers and print keyword
    if l.isIdentifierStart() {
        return l.scanID()
    }

    // scan strings
    if l.UnScannedChar == '\'' {
        return l.scanString()
    }

    // skip comments
    if l.UnScannedChar == '#' {
        err := l.NextChar()
        for err != io.EOF && l.UnScannedChar != '\n' {
            err = l.NextChar()
            if err == io.EOF {
                newToken.Rep = token.EOF
                return
            }
        }
        return l.NextToken()
    }

    switch l.UnScannedChar {
    case '\f', '\t', '\r', ' ':
        return l.NextToken()
    case '\n':
        newToken.Rep = token.NEWLINE
    case '(':
        newToken.Rep = token.LPAREN
    case ')':
        newToken.Rep = token.RPAREN
    case ',':
        newToken.Rep = token.COMMA
    case '+':
        newToken.Rep = token.ADD
    case '-':
        newToken.Rep = token.SUB
    case '*':
        newToken.Rep = token.MUL
    case '/':
        newToken.Rep = token.DIV
    case '=':
        newToken.Rep = token.ASSIGN
    default:
        log.Error(fmt.Sprintf(
            "at file %v, line %v: unknown character '%c'", l.SourceFileName,
            l.CurrentLine, l.UnScannedChar))
        newToken.Rep = token.UNKNOWN
    }
    return
}

```

**token.go:**

```
package token

const (
    SINGLEQ rune = iota
    LPAREN
    RPAREN
    COMMA
    ASSIGN
    ADD
    SUB
    MUL
    DIV
    STRING
    INTEGER
    REAL
    ID
    PRINT
    NEWLINE
    EOF
    UNKNOWN
)

type Token struct {
    Rep  rune
    Data string
}

func (t Token) String() string {
    switch t.Rep {
    case SINGLEQ:
        return "'"
    case LPAREN:
        return "("
    case RPAREN:
        return ")"
    case COMMA:
        return ","
    case ASSIGN:
        return "="
    case ADD:
        return "+"
    case SUB:
        return "-"
    case MUL:
        return "*"
    case DIV:
        return "/"
    case STRING:
        return "string"
    case INTEGER:
        return "integer"
    case ID:
        return "identifier"
    case PRINT:
        return "print"
    case NEWLINE:
        return "newline"
    case EOF:
        return "EOF"
    }
    return "unknown"

}

```

I need the lexer to be as fast as possible and the code should be flexible to implement more extensions/features for the language. 

So how can it be improved?