Parser

open System

type Token =
| STRING of string
| DELIMITER
| EOL

type chars = char list

module Chars =

    let toString : chars -> _ = List.rev >> String.Concat

let parse (input : string) =

    let rec parseEscapeSeq (acc : chars) = function
    | ('"' | '\\') as c :: t -> t |> parseString (c :: acc)
    | _ -> failwith "Invalid escape sequence"

    and parseString (acc : chars) = function
    | '\\' :: t -> t |> parseEscapeSeq acc
    | '"' :: t -> acc, t
    | c :: t -> t |> parseString (c :: acc)
    | [] -> failwith "Unterminated string literal"

    and parse (tokens : Token list) = function
    | '\n' :: t -> t |> parse (Token.EOL :: tokens)
    | h :: t when Char.IsWhiteSpace h -> t |> parse tokens
    | ',' :: t -> t |> parse (Token.DELIMITER :: tokens)
    | '"' :: t ->
        let str, t = t |> parseString []
        t |> parse ((str |> Chars.toString |> Token.STRING) :: tokens)
    | [] -> tokens
    | _ -> failwith "Invalid symbol"

    input |> List.ofSeq |> parse [] |> List.rev

"""
"variable1", "variable2"
"test with quote\"", "test2\\", "test3"
"""|> parse