                 return false
             }
           }
-        case "a"..."z", "A"..."Z":
+        case "/":
+          switch self.nextChar
+          {
+            case "/"?:
+              return lexSinglelineComment()
+            case "*"?:
+              return lexMultilineComment()
+            default:
+              return makeTokenAndAdvance(type: .Operator("/"))
+          }
+        case "a"..."z", "A"..."Z", "_", "$":
           return lexIdentifier()
         default:
+          if self.isIdentifierHead(char)
+          {
+              return self.lexIdentifier()
+          }
+
           return makeTokenAndAdvance(type: .Unknown)
       }
     }


  func advance()
  {
    self.index = self.source.characters.index(after: self.index)
    self.column += 1
  }

  func advanceWhile(pred: (Character) -> Bool)
  {
    while let char = self.currentChar
    {
      if pred(char)
      {
        self.advance()
      }
      else
      {
          break
      }
    }
  }

    func lexAllMatchingAs(type: TokenType, pred: (Character) -> Bool) -> Token
    {
      let start = self.index
      let line = self.line
      let column = self.column

      self.advanceWhile(pred: pred)

      return Token(
        type: type,
        content: self.source[start..<self.index],
        line: line,
        column: column,
        index: start
      )
    }

  func lexIdentifier() -> Token
  {
    return lexAllMatchingAs(type: .Identifier)
    {
      switch $0
      {
        case "a"..."z", "A"..."Z":
          return true
        default:
          return false
      }
    }
  }

func lexNewline(isCRLF: Bool = false) -> Token

          default:
            return String($0)
        }
      }.joined(separator: "") + "\""
    }
  }
}
