F sharp passenger tattoo assignment concept

AssignTattoo.fs

open System

type PassengerType = 
   | Adult 
   | Children 
   | Infant
 
type Passenger = {
    FirstName: String;
    LastName: String;
    Type: PassengerType;
}
 
let passengers = [ 
    { FirstName = "first1"; LastName = "last1"; Type = Adult };
    { FirstName = "first2"; LastName = "last2"; Type = Infant };
    { FirstName = "first3"; LastName = "last3"; Type = Adult };
    { FirstName = "first4"; LastName = "last4"; Type = Children };
    { FirstName = "first5"; LastName = "last5"; Type = Children };
    { FirstName = "first6"; LastName = "last6"; Type = Infant };
    { FirstName = "first7"; LastName = "last7"; Type = Adult };
]

let adults, children, infants = 
    let FilterPassenger passengerType = 
        List.filter (fun p -> p.Type = passengerType) passengers
    FilterPassenger Adult, FilterPassenger Children, FilterPassenger Infant

let pairs, freeAdults = 
   let rec Pairwise pairs frees = function
      | adult::adults, infant::infants -> 
         let pair = adult, infant
         Pairwise (pair::pairs) frees (adults, infants)
      | adults, _ -> pairs, frees @ adults
   Pairwise [][] (adults, infants)

let childWithTattoo, freeAdultsWithTattoo, pairsWithTattoo =
    let offsetRef = ref 1
    let TattooWithGap gap = 
        let currentOffset = !offsetRef
        List.mapi (fun i v -> 
            incr offsetRef
            currentOffset + i * gap, v)
    TattooWithGap 1 children, TattooWithGap 1 freeAdults, TattooWithGap 2 pairs

for tatoo, child in childWithTattoo do 
   printfn "%i %s" tatoo child.FirstName
printfn ""

for tatoo, adult in freeAdultsWithTattoo do 
   printfn "%i %s" tatoo adult.FirstName
printfn ""

for tatoo, (adult, infant) in pairsWithTattoo do 
   printfn "%i %s %s" tatoo adult.FirstName infant.FirstName 

without noise

let children, (pairs, freeAdults) = 
   let rec pairwise pairs frees = function
      | adult::adults, infant::infants -> 
         let pairs = (adult, infant)::pairs
         pairwise pairs frees (adults, infants)
      | adults, _ -> pairs, frees @ adults

   let filter ty =  List.filter (fun p -> p.Type = ty) paxes
   filter Children, pairwise [] [] (filter Adult, filter Children)


let childWithTattoo, freeAdultsWithTattoo, pairsWithTattoo =
   let offset = ref 0
   let tatooise gap = 
      List.mapi (fun i v -> 
         incr offset
         i * gap + !offset, v)
   tatooise 1 children, tatooise 1 freeAdults, tatooise 2  pairs

Fixed according to the best practice!