Pure function, one slot refers to List-position

Question

I used all my google-fu trying to find how to make this work; read the docs as well. What have I missed? I feel sure this can't be a new question, but I can't find anything Here is is:

Take[#1, {#2, Length[#1]}] &[V3, 3]

V3 is a List. This above works.

When I do this (someInteger is an unassigned integer variable):

Take[#1, {#2, Length[#1]}] &[V3, someInteger]

I get this error:

Sequence specification (+n, -n, {+n}, {-n}, {m, n}, or {m, n, s}) expected at position 2.

If I only define the pure function (don't pass arguments in [ ]) then it's OK - until the first attempt to use that pure function.

Is this something that should be solved by appropriate use of Evaluate?

Seems List "Takes" are evaluated only with actual numbers and not variables.

EDIT: I am trying to take a successively smaller piece of the List (it's an exercise from a book I'm using).

V3={1,2,3,4,5,6,7,8}

I want to use a pure function to get lists as follows: 1....8 2....8 3....8

It's a trivial exercise using Table, but the apparent difficulty of doing it with a pure function has me puzzled - I'm sure I'm missing something.

V3 = Table[mm, {mm, 1, 5}]

Table[V3[[j ;;]], {j, 1, 5}]

result is  {{1, 2, 3, 4, 5}, {2, 3, 4, 5}, {3, 4, 5}, {4, 5}, {5}}

Answer 1

You say you need a pure function to accept substitution values. My interpretation of this would be that you want the following:

t = Take[#1, {#2, Length[#1]}] &[V3, #] &

This defines t as a function that accepts the values as follows:

t /@ Range[8]

(*
==> {{1, 2, 3, 4, 5, 6, 7, 8}, {2, 3, 4, 5, 6, 7, 8}, {3, 4, 5, 6,
   7, 8}, {4, 5, 6, 7, 8}, {5, 6, 7, 8}, {6, 7, 8}, {7, 8}, {8}}
*)

The slot # at the end is filled with the "substitution value", whereas the slot #1 in the first part (which is taken without modification from your original definition) is filled with V3.

Sometimes cascades of # and & denoting pure functions can be a little hard to read. In that case, it could be better to use Function.

Answer 2

You can do it by nesting pure functions.

r = Range[6];
f = Function[i, Part[#, i ;;]] &;
f[r][3]

{3, 4, 5, 6}

f[r] /@ Range[Length[r]]

{{1, 2, 3, 4, 5, 6}, {2, 3, 4, 5, 6}, {3, 4, 5, 6}, {4, 5, 6}, {5, 6}, {6}}

Answer 3

This is a rather weird question because don't give any explanation of why you are trying to do this the way you are. The obvious reply is that if this is trivial with Table why not use Table? Other natural Mathematica approaches include Algohi's comment:

V3[[# ;;]] & /@ Range[Length[V3]]

Or my preference, with Array:

V3[[# ;;]] & ~Array~ Length[V3]

If you wish to make this operation a function you can use standard function definition syntax:

foo[v_List] := v[[# ;;]] & ~Array~ Length[v]

Now:

foo[{1, 2, 3, 4}]

{{1, 2, 3, 4}, {2, 3, 4}, {3, 4}, {4}}

If for some reason you want this as an anonymous function rather than foo you could use:

v \[Function] v[[# ;;]] & ~Array~ Length[v]

See \[Function] for reference.

This also may interest you:

NestWhileList[Rest, V3, Length@# > 1 &]

{{1, 2, 3, 4, 5, 6, 7, 8}, {2, 3, 4, 5, 6, 7, 8}, {3, 4, 5, 6, 7, 8},
 {4, 5, 6, 7, 8}, {5, 6, 7, 8}, {6, 7, 8}, {7, 8}, {8}}

Answer 4

Take[#1, {#2, Length[#1]}] &[V3, someInteger] is equivalent to Take[V3, {someInteger, Length[V3]}]. But, Take[list,{m,n}] expects both m and n to be specific integers. Hence, the error message. Perhaps, you could explain what you are trying to accomplish.

With respect to edit

Is this what you had in mind?

f[list_, someInteger_] :=  NestList[Take[#1, {someInteger, Length[#1]}] &, list, 
  Round[Length[list]/(someInteger - 1)] - 1]

or, equivalently,

f = NestList[(Take[#1, {l, Length[#1]}] &) /. l -> #2, #1, Round[Length[#1]/(#2 - 1)] - 1] &

f[Range[1, 8], 2]    
(* {{1, 2, 3, 4, 5, 6, 7, 8}, {2, 3, 4, 5, 6, 7, 8}, {3, 4, 5, 6, 7, 
  8}, {4, 5, 6, 7, 8}, {5, 6, 7, 8}, {6, 7, 8}, {7, 8}, {8}} *)

f[Range[1, 8], 4]
(* {{1, 2, 3, 4, 5, 6, 7, 8}, {4, 5, 6, 7, 8}, {7, 8}} *)