On reimplementing the Select function

Question

I am working through the course Programming Paradigms via Mathematica. One of the exercises asks that you construct a function that mimics Select,even with three arguments. It also includes the following direction:

Do not use the Select[] function in your definition.

Here is an example of how Select works:

Select[{1, 2, 3, 4, 6, 8, 10}, EvenQ, 4]
(* {2, 4, 6, 8} *)

First I tested the following code and got the same result as Select:

l1 = {1, 2, 3, 4, 6, 8, 10};
l2 = {};
crit = EvenQ;
n = 4;
While[Length[l1] > 0 && Length[l2] < n,
 If[crit[First[l1]], l2 = Append[l2, First[l1]]];
    l1 = Rest[l1];
 ]
l2

(* {2, 4, 6, 8} *)

I then tried to write a function that would do the same thing (caution causes infinite loop):

Clear[whileSelect]
whileSelect[l1_List, crit_, n_] := Module[{l2},
  While[Length[l1] > 0 && Length[l2] < n,
    If[crit[First[l1]], l2 = Append[l2, First[l1]]];
        l1 = Rest[l1];
    ]
   l2
  ]

However I got a series of Set::shape: Lists {1,2,3,4,6,8,10} and {2,3,4,6,8,10} are not the same shape. >> error messages and the code put the computer into an infinite loop. I have looked at documentation on Module,Rest,Set and If but have not been able to figure out what I am doing wrong. I would greatly appreciate a point in the right direction.

You're supposed to store l1 in a temporary variable. Try whileSelect[l1_List, crit_, n_] := Module[{l1temp = l1, l2}, (* stuff *)]. l1 = Rest[l1] will not work because if, say, you executed whileSelect[{1, 2, 3, 4, 6, 8, 10}, EvenQ, 3], you then encounter absurdities like {1, 2, 3, 4, 6, 8, 10} = Rest[{1, 2, 3, 4, 6, 8, 10}] due to replacement. But I'll let someone else flesh out the details... — J. M.'s missing motivation, Jun 21 '13 at 14:01
@0x4A4D, OK, I changed Module[{l2}... to Module[{l1temp = l1, l2}... I also changed all the instances of l1 inside the definition to l1temp, however I just get error messages and (*Null Hold[Append[l2$29158, 2], 2, 2, 2,...*) — Clif, Jun 21 '13 at 14:17
Consider whileSelect[l1_List, crit_, n_Integer] := Module[{l1temp = l1, l2 = {}, temp}, While[Length[l1temp] > 0 && Length[l2] < n, temp = First[l1temp]; If[crit[temp], AppendTo[l2, temp]]; l1temp = Rest[l1temp]]; l2], and note well what I did differently. — J. M.'s missing motivation, Jun 21 '13 at 14:35
@0x4A4D, Yes, that works +1. Now let me see if I can understand why. I am going to run it with Trace to see if I can understand how l1temp=Rest[l1temp] worked, whereas l1=Rest[l1] didn't, it may take a while. — Clif, Jun 21 '13 at 14:53
Closed as already answered, as I specifically addressed this issue here. — Mr.Wizard, Jun 21 '13 at 22:44
outline of a "mathematica-idiomatic" way: Take[Pick[list, fQ /@ list, True], max] — amr, Jun 21 '13 at 23:29
@amr A problem with that construct is that the test (fQ) is applied to every list element; a second problem occurs if max exceeds the number of matches. Also, there is no need for True in Pick as that is the default. If one chooses not to use built-in functions with a length parameter (e.g. Cases) I would use something like: select[lst_List, crit_, n_: Infinity] := Module[{f, r = 0}, f = If[r < n, If[crit@#, r++; Sow @ #], Return[]] &; Reap[f ~Scan~ lst][[2, 1]] ] with a block-based optimization if appropriate. — Mr.Wizard, Jun 22 '13 at 20:42
@mr.Wizard aye, that form is what i would use in my own little codes, it's not meant for performant robustitude. your function is almost exactly what i was going to post before the thread was closed, except with pattern matching on the output of Reap like this: {{_, {}} -> {}, {_, {out_}} :> out} to handle the case where the length is 0. then again, that could just be checked in the beginning. derp derp. — amr, Jun 22 '13 at 21:27

score 3 · Answer 1 · edited Jun 16 '20 at 09:23

My answer is along the same lines as Wizard's, but I don't think Return is necessary or desirable. Also, to mimic Select better, the 3rd argument needs have the default value ∞.

whileSelect[l1_List, crit_, n : (_Integer | ∞) : ∞] /; n > 0 :=
  Module[{t = l1, l2 = {}},
    While[Length[t] > 0 && Length[l2] < n, 
      If[crit[First[t]], l2 = Append[l2, First[t]]];
      t = Rest[t]];
  l2]

Then you have

whileSelect[Range@10, EvenQ, 3]

{2, 4, 6}

But, if you omit the 3rd argument, you get

whileSelect[Range@10, EvenQ]

{2, 4, 6, 8, 10}

and the following doesn't evaluate

whileSelect[Range@10, EvenQ, -2]

whileSelect[{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, EvenQ, -2]

Note; Select prints an error message in this last case. I leave implementing that behavior as a exercise :-)

Edit

Here is a more functional-style implementation:

altSelect[l1_List, crit_, n : (_Integer?Positive | ∞)] :=
  Module[{u},
    Take[u = altSelect[l1, crit], Min[Length@u, n]]]
altSelect[l1_List, crit_] :=
  (crit@# && #) & /@ l1 /. False :> Sequence[]

...or, one could have done n : (_Integer?Positive | Infinity) : Infinity. — J. M.'s missing motivation, Jun 21 '13 at 15:34
Thank You and yes, setting the default value for n was next on the todo list, and I can't say that I had a good idea. I will work on error message generation for the case of -n. I also appreciate the functional-style, I guess I would call it recursive, code. I can't say that I understand it, but I will look forward to studying it. — Clif, Jun 21 '13 at 18:41

score 3 · Answer 2 · answered Jun 21 '13 at 22:02

3

I suppose it's time to put in my take:

mySelect[list_List, crit_, n : (_Integer?Positive | ∞) : ∞] := Block[{k = 0}, 
         Reap[Scan[If[crit @ # && (++k) <= n, Sow[#]] &, list]][[-1, 1]]]

where I use Scan[] to loop though the input list and Sow[]/Reap[] to accumulate the elements selected according to the set criterion.

answered Jun 21 '13 at 22:02

J. M.'s missing motivation

124,525
11
401
574

Thanks again for the help, I went back and changed the original code again replacing l1 with l1temp as you had suggested in the first comment and it worked, I must have made a mistake earlier. – Clif Jun 22 '13 at 12:00

score 2 · Answer 3 · answered Jun 21 '13 at 15:50

2

Here's a one-line function that doesn't use If or While, but instead vectorizes the list into True/False, then uses these to index into the list.

sel[list_, crit_, maxLen_] := 
  Take[out = Rest@list[[Union[Range[Length[list]]  Boole[crit /@ list]]]], 
       Min[maxLen, Length[out]]]

For example:

sel[Range[10], OddQ, 4]

{1, 3, 5, 7}

answered Jun 21 '13 at 15:50

bill s

68,936
4
101
191

Thank you for working on this. I am going to study the Take[out=... some more so that I'll understand what it is doing. – Clif Jun 21 '13 at 18:45
@Clif -- It is simpler than it might appear: it assigns the variable out to the right hand side of the equals sign. You are used to seeing this in a separate line of code; here it is used inside a function (in this case, Take) to do the definition. The Take command removes all but the first several entries, either maxLen or Length[out], whichever is smaller. – bill s Jun 22 '13 at 01:07

score 2 · Answer 4 · answered Jun 21 '13 at 22:25

Here's the easiest, probably:

sel[list_, crit_, n_: Infinity] := Cases[list, _?crit, 1, n]

Almost seems like cheating. This one is similar.

sel[list_, crit_, n_: Infinity] := Extract[list, Position[list, _?crit, 1, n]]

The problem is that there are so many ways to do the same thing. I can't tell from the statement of the question whether a program from "scratch" was desired, or to search out more-or-less ready-made substitutes. (I'm not familiar with the book.)

Thanks for helping, I am looking over the documentation on Cases and Extract. — Clif, Jun 22 '13 at 11:57

score 1 · Accepted Answer · answered Jun 21 '13 at 14:53

The following code does what you want to do.

Clear[whileSelect]
whileSelect[l1_List, crit_, n_] := Module[{l1temp = l1, l2 = {}},
  While[Length[l1temp] > 0 && Length[l2] < n, 
   If[crit[First[l1temp]], l2 = Append[l2, First[l1temp]]];
   l1temp = Rest[l1temp];
   ];
   Return[l2];
  ]

The important lesson for you is, that you have to declare a local variable for l1 because an argument is not considered a variable by mathematica. So when you wrote l1 = Rest[l1], mathematica tried to assign a list to a list, not change any variables.

BTW: The code still contains some flaws, but it shows the essential changes. I also recommend using Return, though just writing l2 without semicolon would suffice, too.

thank you, declaring a local variable is a good point. I'll try to keep that in mind in the future. — Clif, Jun 21 '13 at 15:09
While this answer did not address the default value of n case, it did clearly state where I had made a mistake ,local value as opposed to argument. — Clif, Jun 22 '13 at 12:04

On reimplementing the Select function

5 Answers5

Edit