module RnaTranscription

module Dna =
    type Nucleotides = A | C | G | T with
        static member Parse = function
            | 'A' -> Ok A
            | 'C' -> Ok C
            | 'G' -> Ok G
            | 'T' -> Ok T
            | c -> Error (sprintf "%c is not a DNA nucleotide" c)

    let parse (dna: string) =
        let folder (state, ind) item =
            let formatError ind err =
                sprintf "(%d): %s" ind err

            let result =
                match state, item with
                | Ok x,     Ok y    -> Ok (seq {yield! x; yield y})
                | Error x,  Ok _    -> Error x
                | Ok _,     Error y -> Error (formatError ind y)
                | Error x,  Error y -> Error (sprintf "%s\r\n%s" x (formatError ind y))

            result, ind + 1

        dna
        |> Seq.map Nucleotides.Parse
        |> Seq.fold folder (Ok Seq.empty, 0)
        |> fst

module Rna =
    type Nucleotides = A | C | G | U

    let toString (rna: Nucleotides seq) =
        rna
        |> Seq.map string
        |> String.concat ""

module Transcription =

    let dnaToRna (dna: Dna.Nucleotides seq) =
        let mapper = function
            | Dna.G -> Rna.C
            | Dna.C -> Rna.G
            | Dna.T -> Rna.A
            | Dna.A -> Rna.U

        Seq.map mapper dna

let toRna (dna: string) =
    match Dna.parse dna with
    | Ok dna -> dna |> Transcription.dnaToRna |> Rna.toString
    | Error msg -> sprintf "Invalid DNA sequence.\n%s" msg