Big data: Algorithms and performance

def read_fasta_fast(filename):
    with open(filename, "r") as f: 
        txt = f.read()
        entries = []
        for entry in txt.split(">")[1:]:
            lines = entry.split("\n")
            entries.append((lines[0], "".join(lines[1:])))
    return entries

def read_fasta_safe(filename):
    entries = []
    header = None
    sequences = []
    with open(filename, "r") as f: 
        for line in f.readlines():
            line = line.strip()
            if line[0] == ">":
                if header:
                    entries.append((header, "".join(sequences)))
                header = line
                sequences = []
            else:
                if header:
                    sequences.append(line)
                else:
                    raise ValueError("Entry is missing a header")
    if header:
        entries.append((header, "".join(sequences)))
    return entries

struct FastaEntry {
    std::string header;
    std::string sequence;
};

std::vector<FastaEntry> read_fasta(const std::string& filename) {
    std::vector<FastaEntry> entries;
    std::ifstream file(filename);
    if (!file.is_open()) {
        std::cerr << "Error opening file: " << filename << std::endl;
        return entries;
    }

    std::string line;
    FastaEntry current_entry;
    bool in_sequence = false;

    while (std::getline(file, line)) {
        if (line.empty()) continue;

        if (line[0] == '>') {
            if (in_sequence) {
                entries.push_back(std::move(current_entry));
                current_entry = FastaEntry();
            }
            in_sequence = true;

            current_entry.header = line.substr(1, line.size() - 1);
        } else {
            current_entry.sequence.append(line);
        }
    }

    if (in_sequence) {
        entries.push_back(std::move(current_entry));
    }

    return entries;
}

import Data.List.Split (split, startsWith)

parseFasta :: String -> [(String, String)]
parseFasta = map ((\(h: xs) -> (h, concat xs)) . lines) . split (startsWith ">")

import qualified Data.ByteString as B
import qualified Data.ByteString.Char8 as C
import qualified Data.Text as T

parseFastaFast :: B.ByteString -> [(Header, Sequence)]
parseFastaFast = map (\(h: xs) -> (h, B.concat xs)) . map C.lines . tail . C.split '>'

parseFastaFast :: T.Text -> [(T.Text, T.Text)]
parseFastaFast = map (\(h:xs) -> (h, T.concat xs)) . map T.lines . tail . T.split ((==) '>')

isSpace :: Word8 -> Bool
isSpace c = c <= 0x20

isNewline :: Word8 -> Bool
isNewline c = c == 0x0a || c == 0x13

isStart :: Word8 -> Bool
isStart c = c == 0x3e

parseFasta :: Parser [(B.ByteString, B.ByteString)]
parseFasta = many' parseEntry <* endOfInput
  where
  parseEntry :: Parser (Header, Sequence)
  parseEntry = do
    _ <- skip isStart
    header <- takeWhile1 (not . isNewline)
    _ <- skipWhile isSpace
    sequence <- B.concat <$> many' seqLine
    return (header, sequence)

  seqLine :: Parser B.ByteString
  seqLine = do
    line <- takeWhile1 (\c -> not (isStart c) && not (isSpace c))
    _ <- skipWhile isSpace
    return line

parseFasta :: Monoid seq => Parser header -> Parser seq -> Parser [(header, seq)]
parseFasta parseHeader parseSeq = many' parseEntry <* endOfInput
  where
  parseEntry :: Parser (Header, Sequence)
  parseEntry = do
    _ <- skip isStart
    header <- parseHeader
    _ <- skipWhile isSpace
    sequence <- mconcat <$> sepBy (takeWhile1 (not . isNewLine)) parseSeq
    return (header, sequence)

// Define a linked list of header/sequence pairs
typedef struct FastaEntry {
    char* header;
    char* sequence;
    struct FastaEntry* next;
}  FastaEntry;

// Make a linked list of FASTA entries given a buffer that contains
// the full FASTA file with a length of size `size`.
FastaEntry* parse_fasta(char* buffer, const size_t size){

  // initial position in the file
  size_t file_idx = 0;

  // initial position in the fasta sequence
  size_t fasta_idx = 0;

  // initial fasta entry
  FastaEntry* root = NULL;
  FastaEntry* tip = root;

  // fastfoward to the first fasta entry
  // usually this will be the first character
  if(buffer[file_idx] != '>'){
    // skip any initial comments or whitespace
    while(buffer[file_idx] != '>'){
      file_idx++;
    }
    file_idx++;
  }

  // walk through the buffer character by character
  while(file_idx < size){

    // start a new entry
    if(buffer[file_idx] == '>'){
      // allocate memory for a new entry
      FastaEntry* next_tip = (FastaEntry*)malloc(sizeof(FastaEntry));
      if (!next_tip) {
          perror("Failed to allocate memory");
          return NULL;
      }
      next_tip->header = buffer + file_idx + 1;

      // link prior tip to new tip
      tip->next = next_tip;

      // become the next tip
      tip = next_tip;

      // go to last char before newline
      while(file_idx < size && buffer[file_idx] != '\n'){
        file_idx++;
      }
      if(file_idx < size){
        // set newline to null
        buffer[file_idx] = '\0';
      }
      // go to first char of sequence (assume '\n' line ends)
      file_idx++;
      // set sequence
      tip->sequence = buffer + file_idx;
    }
    // else if we are in sequence ...
    else {
      fasta_idx = file_idx;
      // loop to the next entry
      while(file_idx < size && buffer[file_idx] != '>'){
        // if not a newline, then swap set as next sequence character
        if(buffer[file_idx] != '\n'){
          buffer[fasta_idx] = buffer[file_idx];
          fasta_idx++; 
        }
        file_idx++;
      }
      // set newline before '>' to null
      buffer[fasta_idx] = '\0';
    }
  }

  // return the first element in the linked list
  return root;
}