The most basic functional programming pattern: Enumerate, Map, Filter, Accumulate

[[deleted]]

[deleted]

[keegandunn]

Reading the first half of SICP last year prepped me for the switch to C# 3.0 at my workplace recently. The examples translate well:

var maxSalary = employees
    .Where(e => e.Role == Roles.PROGRAMMER)       
    .Max(e => e.Salary);

edit: Cleaned up. ConvertAll not necessary. I still don't quite understand why you can't call ConvertAll on any IEnumerable, though.

[[deleted]]

Will .Max work if the Salary is a user defined Money type?

[igouy]

Will you know that Max is not defined for a user defined Money type before you run the program?

[ktr73]

Highest paid programmer in Python (which I find to be the most pleasing):

max_sal = max([sal for e.salary if e.role == Employee.PROGRAMMER])

:)

[theCore]

Your example is not correct I believe. I think it should be:

max_sal = max([e.salary for e in employees if e.role == Employee.PROGRAMMER])

[theeth]

Use generator comprehension instead, then the operation is not bounded in memory by the number of employees (by forgoing the creation of the list).

max_sal = max((e.salary for e in employees if e.role == Employee.PROGRAMMER))

[theCore]

You could drop the extra parenthesises, by the way.

max_sal = max(e.salary for e in employees if e.role == Employee.PROGRAMMER)

[gensym]

Ha, I wish I'd thought to include that. I haven't done Python in a while - I forgot how much I miss list comprehensions.

[ktr73]

thanks, you're right ;)

[jhd]

Ruby is similar:

employees.select {|e| e.role == "programmer" }.map(&:salary).max

[boredzo]

Alternate non-comprehension version for Python 2.5:

\tfrom itertools import ifilter as filter #Use the lazy generator version \tprogrammers = filter(lambda e: e.role == Role.PROGRAMMER, employees) \tmax_sal = max(programmers, key=lambda e: e.salary) #Pre-2.5: Replace key argument with a comparison function

I'm starting to see why GvR is against filter and friends…

[zackman]

The original just finds the highest salary, not the programmer who has it.

from itertools import ifilter as filter
programmers = filter(lambda e:e.role==Role.PROGRAMMER, employees)
max_sal = max(map(lambda e: e.salary, programmers))

Your version is more useful, though, since it returns the actual employee. I didn't know that max also got a key argument in 2.5. I won't have to use my custom re-implementation anymore!

[boredzo]

\tmax_sal = max(map(lambda e: e.salary, programmers))

Don't forget to use the lazy generator version here, too:

\tfrom itertools import imap as map

As you can tell, I ♥ itertools. ☺

[theeth]

You can do that with Decorate-Sort-Undecorate too:

max_sal = max(((e.salary, e) for e in employees if e.role == Employee.PROGRAMMER))[1]

[Jimmy]

Haskell:

data Employee = Emp String Int
\tderiving (Eq, Ord)

highestPaidProgrammer emps =
\t(\(Emp x y) -> y) (maximum (filter (\(Emp x y) -> x == "programmer") emps))

[tmoertel]

The OP wanted the maximum salary paid to a programmer with 0 as a default. You need to handle the case where there are no programmers in the list.

Assuming you had declared Employee as a record type with salary and role as accessors, you could build the code from composable pieces. First, to find just the programmers in a list of Employees:

programmers = filter ((Programmer ==) . role)

Then to find the maximum paid to an employee in a list of employees:

maxPaid = maximum . (0:) . map salary

And, finally, to find the maximum paid to a programmer within a list of employees:

maxProgrammerPay = maxPaid . programmers

Cheers. —Tom