map - Span a function across several consecutive elements in a list

Suppose that I have a list called list. I would like to span an arbitrary function f across specified consecutive elements in list.

Here is an example. Suppose the following:

list = {10, 20, 30, 40, 50, 60, 70};

I would like to obtain the following new lists:

{f[{10, 20, 30, 40}], 50, 60, 70}
{10, f[{20, 30, 40, 50}], 60, 70}
{10, 20, 30, 40, f[{50, 60, 70}]}

Is there a simple (perhaps even built-in) way to accomplish this in Mathematica 8? I have come up with the following function spanMap, but my method seems very complicated and clunky:

spanMap[function_, list_List, begin_Integer, end_Integer] := 
 Module[{result},
  If[begin == 1,
   If[end == Length[list], result = list;];
   If[begin < end < Length[list], 
    result = 
      Flatten[{function[list[[begin ;; end]]], 
        list[[(end + 1) ;;]]}];];
   ];


  If[begin > 1,
   If[end == Length[list], 
    result = 
      Flatten[{list[[1 ;; (begin - 1)]], 
        function[list[[begin ;; end]]]}];];
   If[begin < end < Length[list], 
    result = 
      Flatten[{list[[1 ;; (begin - 1)]], 
        function[list[[begin ;; end]]], list[[(end + 1) ;;]]}];];

   ];

  result
  ]

where

spanMap[f, list, 1, 4]
spanMap[f, list, 2, 5]
spanMap[f, list, 5, 7]

yield the desired results:

{f[{10, 20, 30, 40}], 50, 60, 70}
{10, f[{20, 30, 40, 50}], 60, 70}
{10, 20, 30, 40, f[{50, 60, 70}]}

albeit in a complicated, clunky way.

Answer

This is a good example where Internal`PartitionRagged (IPR) can be used very effectively. First, observe the following:

list = {10, 20, 30, 40, 50, 60, 70};


(* 3 continuous elements in the middle *)
Internal`PartitionRagged[list, {2, 3, 2}]
(* {{10, 20}, {30, 40, 50}, {60, 70}} *)

(* 3 continuous elements from the start *)
Internal`PartitionRagged[list, {0, 3, 4}]
(* {{}, {10, 20, 30}, {40, 50, 60, 70}} *)

(* 3 continuous elements at the end *)
Internal`PartitionRagged[list, {4, 3, 0}]

(* {{10, 20, 30, 40}, {50, 60, 70}, {}} *)

You see that for a "continuous span", you can always partition the list into 3 parts as {initial, continuous span, final} by properly choosing the arguments to IPR. This means that you simply need to MapAt your function f onto the second element of the partitioned list and then flatten it.

The function you want can be written as:

spanMap[f_, list_, {start_, end_}] := MapAt[
    f, Internal`PartitionRagged[list, {start - 1, end - start + 1, Length@list - end}], {2}
] ~Flatten~ 1

which is pretty clean and intuitive, IMO. Try it out!

spanMap[f, list, {1, 4}]

spanMap[f, list, {2, 5}]
spanMap[f, list, {5, 7}]

(*  {f[{10, 20, 30, 40}], 50, 60, 70}
    {10, f[{20, 30, 40, 50}], 60, 70}
    {10, 20, 30, 40, f[{50, 60, 70}]} *)