Four MLs (and a Python)

    $ time wc big-data.csv                                                                     
     1252045  1252045 17805309 big-data.csv
    
    real    0m0.417s
    user    0m0.411s
    sys     0m0.004s

    $ time ./sum-ocaml big-data.csv                                                            
    6143290.,13087196.,14473656.,50128757.,3765822.,1290420.
    
    real    0m3.680s
    user    0m3.666s
    sys     0m0.008s


    $ time python3 sum.py big-data.csv          
    6143290.0,13087196.0,14473656.0,50128757.0,3765822.0,1290420.0
    
    real    0m7.186s
    user    0m7.131s
    sys     0m0.036s

    $ time python2 sum.py big-data.csv         
    6143290.0,13087196.0,14473656.0,50128757.0,3765822.0,1290420.0
    
    real    0m5.146s
    user    0m5.111s
    sys     0m0.012s

    $ time pypy2 sum.py big-data.csv            
    6143290.0,13087196.0,14473656.0,50128757.0,3765822.0,1290420.0
    
    real    0m2.754s
    user    0m2.697s
    sys     0m0.052s

    let rec fold_channel f acc chan =
      match input_line chan with
      | line -> fold_channel f (f line acc) chan
      | exception End_of_file -> acc

    let comma = Str.regexp ","

    let values_of_line line =
      List.map float_of_string (Str.split comma line)

    let sum_channel chan =
      let folder line tot = List.map2 (+.) tot (values_of_line line) in
      fold_channel folder (values_of_line (input_line chan)) chan

    let sum_and_print_file filename =
      let chan = open_in filename in
      sum_channel chan |> List.map string_of_float |> String.concat "," |> print_string;
      close_in chan

    let () =
      match Sys.argv with
      | [|_; filename|] -> sum_and_print_file filename
      | _ -> failwith "Exactly 1 filename must be given"

I moved the regexp instantiation outside the loop, see the results below ("orig" is your code, "proper" has the regexp parsed only once):

  > bash -c 'time ./orig bigdata.csv'
  15502592020.,15502065537.6,15519223046.6,15498884970.,15502078298.,15519530367.3,15510803256.2,15519590717.2,15511590976.

  real    0m3.110s
  user    0m3.107s
  sys     0m0.003s

  > bash -c 'time ./proper bigdata.csv'
  15502592020.,15502065537.6,15519223046.6,15498884970.,15502078298.,15519530367.3,15510803256.2,15519590717.2,15511590976.

  real    0m2.596s
  user    0m2.590s
  sys     0m0.003s

    import random
    with open("big-data.csv","w") as f:
        for b in range(1000000):
            f.write(','.join([str(random.random()) for x in range(20)])+"\n")  

The script from the blog takes 7.3 seconds to chew through it on my machine with Python 2.7.8, and 4.9-5.5 seconds with PyPy, a reasonable improvement. Out of interest, taking all the boilerplate and checking off, the following is 7 lines versus the 24 lines or so in the blog and runs in a similar 4.9-5.4 second range on PyPy (although performance blows out under Python 2.7.8 to 13 seconds or ~6 seconds slower than the blog). Somewhat more Pythonic, and more likely do be done live in the REPL without even bothering to write a script, to my mind.

    from collections import Counter
    c = Counter()
    lines = (rawline.strip().split(",") for rawline in open("big-data.csv"))
    for line in lines:
        for colname, colval in enumerate(line):
            c[colname]+=float(colval)
    print c  

    time pypy sum5.py ./big-data.csv

    real	0m4.972s
    user	0m4.946s
    sys	        0m0.024s  

    time wc big-data.csv  

    real	0m3.701s
    user	0m3.672s
    sys	        0m0.028s

    print map(sum,zip(*([float(x) for x in rawline.strip().split(",")] for rawline in open("big-data.csv"))))

In my experience with OCaml, I have found the syntax a bit too unfavourable like the author did, but the resulting code was very fast. With concurrency sorted out, I wonder if it could take on Rust, Nim, and Go as far as systems-programming is concerned (esp since Go has the weight of Google behind it).

It also helps that the language designers have written a large tutorial on systems programming: https://ocaml.github.io/ocamlunix/

Then there's this epic Mirage OS built with Cloud Computing in mind by Anil and his team of OCaml zealots: http://openmirage.org/

And I've said this before: If only SML actually had proper unicode support, I might use it for something real.

    import System.Environment
    import qualified Data.Vector.Unboxed as V
    import Data.Vector.Unboxed (Vector)

    display :: Vector Double -> String
    display ds | V.null ds = ""
            | otherwise = tail . concatMap format . V.toList $ ds
                    where format d = ',' : show d

    csv_sums :: String -> Vector Double
    csv_sums input = go (V.length $ h) 1 h t where
        h : t = map (V.fromList . read . bracket) $ lines input
        bracket s = '[' : s ++ "]"
        go s n summary [] = summary
        go s n summary (x:xs)
            | V.length x == s  = go s (n + 1) (V.zipWith (+) summary x) xs
            | otherwise        = if blankLastLine then summary
                                                else error "Inconsistent lengths."
                where blankLastLine = case xs of [] -> V.length x == 0
                                                _  -> False

    main = do
        paths <- getArgs
        if length paths /= 1
            then error "Exactly one filename must be given."
            else readFile (head paths) >>= putStrLn . display . csv_sums

Except from a totally different programming paradigm what do ML-derivateves have to offer?

Also the author states that ML is "statically typed", "type inference"... Why does a statically typed langauge need "type inference"? As I understand this - I'm probably wrong but - dynamically type == type inference.

If anyone takes the time to answer... Well thanks a priori! :^)

The only thing that seems to be an obvious omission is the omission of Haskell.