+/"1 ". > (< ;. _2) freads 'my.txt'

+/'"I"$" "\:'0:`my.txt

geometric_mean =. # %: */

public double geometric_mean(List<double> data)
{
    double mul = 1;
    foreach(var x in data)
    {
        mul *= x;
    }
    return Math.Pow(mul, 1/data.Count);
}

var sums = from line in File.ReadAllLines("Numbers.txt")
           let numbers = from c in line.Split(' ')
                         select float.Parse(c)
           select numbers.Sum();
           
sums.ToList().ForEach(Console.WriteLine);

+/ % #

len(open('xorg.conf').readlines())

[reduce(lambda a,b:int(a)+int(b), x.split(' ')) for x in open('nums').readlines()]

IO.foreach("nums.txt"){|s| p s.split(' ').inject{|a,b| a.to_i+b.to_i}}

using Nemerle.Utility;
using System.IO;
using System;

module TextReadeExtension
{
    public ReadLines(this reader : TextReader) : list[string]
    {
        mutable lines = [];
        mutable line = reader.ReadLine();
        while (null != line)
        {
            lines ::= line;
            line = reader.ReadLine();
        }
        lines;
    }
}

File
    .OpenText("test.txt")
    .ReadLines()
    .Map(x => x.Split(array[' ']).Fold(0, (a, b) => int.Parse(a) + b))
    .Iter(Console.WriteLine : int -> void);

sub add($$)
{
    my ($a,$b) = @_;
    return $a+$b;
}
sub reduce
{
    my $op=shift;
    my $a = shift;
    for my $i (@_) {
        $a = &$op($a,$i);
    }
    return $a;
}

print join("\n",map { reduce(\&add,0,split) } <>);

map { print reduce(\&add,0,split),"\n"; } <>;

try
{
    SumLines("test.txt");
}
catch
{
    _ is FormatException => Console.WriteLine("Incorrect file format.");
}

#!perl -np
$_=reduce(\&add,0,split);

1 2 3

1
2
3

,. 1 2 3

1 
2
3

,. +/"1 ". > (< ;. _2) freads 'my.txt'

import Control.Arrow
import Control.Exception

main = handle print $ do
       readFile "test" >>= return.process >>= putStr
process = lines >>> map sumline >>> unlines
sumline = words >>> map (read::String->Int) >>> sum >>> show

file <- openFile "somefile.txt" ReadMode
doSomethingWith file
hClose file

import Prelude hiding (catch)
import Control.Exception (catch, ErrorCall)

> print (read "notnumber" + 5) `catch` (\(ErrorCall s) -> print s)

(>>>) :: Arrow a => a b c -> a c d -> a b d

(>>=) :: Monad a => a b -> (b -> a c) -> a c

File.ReadAllLines("Numbers.txt").Select(l => l.Split(' ').Select(s => int.Parse(s)).Sum()).ToArray();

Array.ForEach(File.ReadAllLines("Numbers.txt").Select(l => l.Split(' ').Select(s => int.Parse(s)).Sum()).ToArray(), Console.WriteLine);

print "\n".join( sum(x.split(' ')) for x in open('nums').readlines() )

[sum(map(int, x.split())) for x in open('nums')]

print '\n'.join(sum(map(int, x.split())) for x in open('nums'))

import Control.Monad (forM)

main = do reader <- readFile "test.txt"
          forM (lines reader) $ \line ->
               print $ sum $ map read $ words line

main = readFile "test.txt" >>= mapM_ (print.sum.map read.words) . lines

using System.Console;
using System.IO;
using Nemerle.Utility;

def res = File.ReadAllLines(@"..\..\test.txt").Map(
  x => x.Split(' ').Fold(0, (a, b) => int.Parse(a) + b));
WriteLine($"..$res");

using System.Console;
using System.IO;
using Nemerle.Utility;

foreach (line in File.ReadAllLines("test.txt"))
  WriteLine(line.Split(' ').Map(int.Parse).Fold(0, _ + _));

,. +/ |: (". ;. _2) freads 'my.txt'

,. +/@". ;. _2 freads 'my.txt'

File.ReadAllLines("Numbers.txt").Select(l => l.Split(' ').Select(s => int.Parse(s)).Sum()).ToArray();

+/'["I"$" "vs/:read0`my.txt]

(+/@".);._2(1!:1<'my.txt')

(+/@".);._2(1!:1<'my.txt')

+/$".,; @$% ^_2&%^$'my.txt'

+/@".;._2 (#~~:&CR) 1!:1<'c:\\my.txt'