Back to Questions
3.8k
views5
comments
List.choosei?
f#

Is there an easier way to do a choose operation based not only on the element data in the list, but also on the index? For example, there is List.map, and List.mapi that also gives the index to the function for comparison. Is there a counterpart for List.choose (List.choosei?)

I've been getting around this by creating a tuple with the index and using the single tuple in a pattern matching function.

Is there a better way? Just curious if anyone has any insights :)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#light

// Data type for our rectangle
type Rectangle = {X:int; Y:int; W:int; H:int}

// Switches (On=1, Off=0) for numbered squares
//               01 02 03 04
let switches = [| 1; 0; 1; 0|];

// A is an "int list list"
// 99 means "always put a rectangle here
// 00 means "never put a rectangle here
// <n> means "put a rectangle here only if switches(n) is On"
let A = [[01;99;02];
         [00;99;00];
         [03;99;04]];

let AllowRectangleHere (r, c, item)=
  match item with
  | 99 -> Some {X=c; Y=r; W=1; H=1}
  | 00 -> None
  |  i ->  if (switches.[i-1] = 1) then Some {X=c; Y=r; W=1; H=1} else None  
  
let rectangleList = 
  A
  |> List.mapi (fun r row -> row |> List.mapi (fun c item -> (r,c,item)))  // create a tuple
  |> List.concat // squash the "list list" into a "list"
  |> List.choose AllowRectangleHere

-Matt

.

I don't understand your domain model, but you can define choosei in term of choose:

1
2
3
4

let choosei f l =
  let i = ref (-1) in
  let f' x = incr i; f !i x in
  List.choose f' l
By on 1/5/2008 2:25 PM ()

A perhaps simple solution without using mutables (which might be worth getting in the habbit of avoiding as they would break in a different situation when used with a seq that was enumerated twice) would be:

1
2
3
4

module Array =
    let choosei f = Array.mapi f >> Array.choose id
module List =
    let choosei f = List.mapi f >> List.choose id
By on 2/7/2013 5:00 AM ()

Ah, d2bg, that's very clever.

So, that snippet of code is just keeping a mutable counter (in this case, i) and incrementing it each time f' is called, which in turn calls f with the attached counter?

By on 1/5/2008 2:49 PM ()

If you can use Array2, it seems like the ideal data structure for this problem. Unfortunately, it doesn't behave nicely with the rest of the F# collections library (no of_*/to_* functions).

Pretty much how you did it is the way to go. One way to rewrite it to remove some of the convolusion is:

1
2
3
4
5

let rectangleList2 =
  [ for x in 0 .. (List.length A)
    for y in 0 .. (List.nth A x |> List.length)
    -> (x, y, List.nth (List.nth A x) y) ]
  |> List.choose AllowRectangleHere

This does exactly what you were doing, but uses a list comprehension instead of nested List.mapi/concat calls. This is similar to how Array2.map is implemented, although Array2 uses regular double-nested for loops, not a comprehension. It should be easy to turn this into a function, if you so desire.

Regards,

z.

By on 12/30/2007 9:03 PM ()

Wow, thanks z.

I'll have to look into the Array2 data structure. I keep discovering more cool (and undocumented? or at least hard-to-find) stuff :)

Thanks again.

By on 1/2/2008 8:45 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper