incremental transform

transform.fs

let seqInnerJoin predicate seq1 seq2 =
    let findPairs predicate seq2 element1 =
        seq2
        |> Seq.where (predicate element1)
        |> Seq.map (fun element2 -> element1, element2)
    seq1
    |> Seq.map (findPairs predicate seq2)
    |> Seq.collect (fun pair -> pair)
    
    
// use your closure

let seqInnerJoin predicate seq1 seq2 =
    let findPairs element1 =
        seq2
        |> Seq.where (predicate element1)
        |> Seq.map (fun element2 -> element1, element2)
    seq1
    |> Seq.map findPairs
    |> Seq.collect (fun pair -> pair)
    
// look your last collect uses id
let seqInnerJoin predicate seq1 seq2 =
    let findPairs element1 =
        seq2
        |> Seq.where (predicate element1)
        |> Seq.map (fun element2 -> element1, element2)
    seq1
    |> Seq.map findPairs
    |> Seq.collect id
    
// hmm ... but wait map f >> collect id === collect f (try to see why)
let seqInnerJoin predicate seq1 seq2 =
    let findPairs element1 =
        seq2
        |> Seq.where (predicate element1)
        |> Seq.map (fun element2 -> element1, element2)
    seq1
    |> Seq.collect findPairs
    
// predicate is ususally something like a -> bool - let's call it joinable
// and one single |> looks bad so remoe it as well

let seqInnerJoin joinable seq1 seq2 =
    let findPairs element1 =
        seq2
        |> Seq.where (joinable element1)
        |> Seq.map (fun element2 -> element1, element2)
    Seq.collect findPairs seq1
    
// give some type-annotations but remove the verbose argument-names and rename where to filter
let seqInnerJoin (joinable : 'a -> 'b -> bool) (s : 'a seq) (s' : 'b seq) : ('a*'b) seq =
    let findPairsFor a =
        s'
        |> Seq.filter (joinable a)
        |> Seq.map (fun b -> a,b)
    Seq.collect findPairsFor s