let rec tList = function
    | x :: xs y :: ys -> (x,y) :: tList xs ys
    | [] _ -> []
    | _ [] -> []

let rec qsort list = 
  match list with
    | f::rest -> 
        (qsort (List.filter ( fun n -> n <= f ) rest)) @ [f] @
        (qsort (List.filter ( fun n -> n > f ) rest))
    | [] -> []

let rec qsort list = function
    | f::rest -> 
        (qsort (List.filter ( fun n -> n <= f ) rest)) @ [f] @
        (qsort (List.filter ( fun n -> n > f ) rest))
    | [] -> []

D>let rec tList = function
D>    | x :: xs y :: ys -> (x,y) :: tList xs ys
D>    | [] _ -> []
D>    | _ [] -> []
D>

let rec tList (xs, ys) =
    match (xs, ys) with
        | (x :: xs, y :: ys) -> (x, y) :: tList (xs, ys)
        | ([], []) -> []
        | (_, _) -> throw new System.Exception ("...")

do System.Console.WriteLine(tList ([1, 2, 3, 4], ["-1-", "-2-", "-3-", "-4-"]))

let rec zip lst1 lst2 = match lst1,lst2 with
  | [],_ -> []
  | _, []-> []
  | (x::xs),(y::ys) -> (x,y) :: (zip xs ys);;

let rec zip = function
  | [],_ -> []
  | _, []-> []
  | (x::xs),(y::ys) -> (x,y) :: (zip xs ys);;

public tList['a, 'b] (x : list ['a], y : list ['b]) : list ['a * 'b]
{
    | ([], []) => []
    | (x :: xs, y :: ys) => (x, y) :: tList(xs, ys)
    | _ => throw System.ArgumentException ("tList")
}

VD>Кстати, как правльно в F# генерировать исключения? Что-то 20 минут доки рыл, так и не нашел .

val raise : #Exception -> 'b

raise (new Exception("Ooops! Exception!"))

val failwith    : string -> 'a  // генерит FailureException
val invalid_arg : string -> 'a  // генерит InvalidArgumentException

VD>Да, есть такое дело. Но это уже тараканы ОКамла .

VD>public tList['a, 'b] (x : list ['a], y : list ['b]) : list ['a * 'b]
VD>{
VD>    | ([], []) => []
VD>    | (x :: xs, y :: ys) => (x, y) :: tList(xs, ys)
VD>    | _ => throw System.ArgumentException ("tList")
VD>}
VD>

tList [] _ = []
tList _ [] = []
tList (x : xs) (y : ys) = (x,y) : tList xs ys

D>tList [] _ = []
D>tList _ [] = []
D>tList (x : xs) (y : ys) = (x,y) : tList xs ys
D>

tList = zip

D>tList [] _ = []
D>tList _ [] = []
D>tList (x : xs) (y : ys) = (x,y) : tList xs ys
D>

def tList (x, y)
{
    | (_, []) => []
    | ([], _) => []
    | (x :: xs, y :: ys) => (x, y) :: tList(xs, ys)
}

ie>>, но до J далековато

zip =. ,.

zip =. ,.

 1 2 3 ,. 4 5

 zip [1, 2 ,3] [ 5, 6]

ie>А это как zip написать

a =. 1 2 3
b =. 4 5
((i.((# a) <. (#b))) { a) ,. ((i.((# a) <. (#b))) { b)