n-ary list map means a function that does map or map2 or map3 or …. (Where map2 is zipWith, not the one you get from the list monad.) In Common Lisp the lambda

n-ary list map means a function that does map or map2 or map3 or …. (Where map2 is zipWith, not the one you get from the list monad.) In Common Lisp the lambda-list looks something like: (MAPCAR func list &rest lists) And a slow implementation might look like: (defun mapcar1 (f list &aux r) (tagbody g (when list (push (funcall f (pop list)) r) (go g)) (nreverse r))) (defun every (pred list) (dolist (x list) (unless (funcall pred x) (return nil))) t) (defun mapcar (f list &rest lists) (prog ((lists (cons list lists)) r) loop (when (every #'consp lists) (push (apply f (mapcar1 #'car lists) r) (setf lists (mapcar1 #'cdr lists)) (go loop)) (nreverse r))) To implement such a function in ocaml you need to do something like: type ('ftype,'output) t = | [] : ('a,'a) t | (::) : 'a list * ('b,'c) t -> ('a -> 'b,'c) t val mapn : f:'f -> ('f,'x) t -> 'x In haskell you would use a heterogenous list and type families. But note that I didn’t implement mapn in ocaml as it would be hard and unreadable… One nice quality of dynamic languages is that you get very useful objects like lists or python/JavaScript style ‘dicts’ and lots of standard library functions to operate on them. You can implement them in a statically typed language to some extent but they are much less versatile and less first class. It means you often need to write different functions that do basically the same thing because they use different record or tulle types as input. I don’t think any mainstream languages are very close to static typing with structural subtyping.