Какая идиома OCaml эквивалентна функции диапазона Python?

Ну вот:

let rec range i j = if i > j then [] else i :: (range (i+1) j)

Обратите внимание, что это не хвостовая рекурсия. В современных версиях Python даже есть ленивый диапазон.

Я не знаю идиомы, но вот довольно естественное определение с использованием инфиксного оператора:

# let (--) i j = 
    let rec aux n acc =
      if n < i then acc else aux (n-1) (n :: acc)
    in aux j [] ;;
val ( -- ) : int -> int -> int list = <fun>
# 1--2;;
- : int list = [1; 2]
# 1--5;;
- : int list = [1; 2; 3; 4; 5]
# 5--10;;
- : int list = [5; 6; 7; 8; 9; 10]

В качестве альтернативы, расширение синтаксиса понимания (который дает синтаксис [i .. j] для вышеупомянутого), вероятно, будет включен в будущую версию "версия сообщества" OCaml, так что это может стать идиоматическим. Однако я не рекомендую начинать играть с расширениями синтаксиса, если вы новичок в этом языке.

Кстати, в Haskell вы бы предпочли использовать

enumFromTo 1 n
[1 .. n]

Это просто ненужно.

take n [1 ..]
take n $ iterate (+1) 1

С Батареи в комплекте вы можете написать

let nums = List.of_enum (1--10);;

Оператор -- генерирует перечисление от первого значения ко второму. Оператор --^ аналогичен, но перечисляет полуоткрытый интервал (1--^10 будет нумеровать от 1 до 9).

Если вы используете open Batteries (это версия стандартной библиотеки от сообщества), вы можете использовать range(1,n+1) с помощью List.range 1 `To n (обратите внимание на обратную цитату перед To).

Более общий способ (также требующий батарей) - использовать List.init n f, который возвращает список, содержащий (f 0) (f 1) ... (f (n-1)).

OCaml имеет специальный синтаксис для сопоставления с образцом в диапазонах:

let () =
  let my_char = 'a' in
  let is_lower_case = match my_char with
  | 'a'..'z' -> true (* Two dots define a range pattern *)
  | _ -> false
  in
  printf "result: %b" is_lower_case

Чтобы создать диапазон, вы можете использовать Core:

List.range 0 1000

Немного поздно в игре, но вот моя реализация:

let rec range ?(start=0) len =
    if start >= len
    then []
    else start :: (range len ~start:(start+1))

Затем вы можете использовать его очень похоже на функцию python:

range 10 
     (* equals: [0; 1; 2; 3; 4; 5; 6; 7; 8; 9] *)

range ~start:(-3) 3 
     (* equals: [-3; -2; -1; 0; 1; 2] *)

естественно, я думаю, что лучший ответ - просто использовать Core, но это может быть лучше, если вам нужна только одна функция, и вы пытаетесь избежать использования полной структуры.

Это работает в базе OCaml:

＃ List.init 5 (fun x -> x + 1);; - : int list = [1; 2; 3; 4; 5]

Если вам не нужен параметр "шаг", простой способ реализовать эту функцию:

let range start stop = List.init (abs @@ stop - start) (fun i -> i + start)

Следом за Алексом Ковентри сверху, но еще короче.

let range n = List.init n succ;;    
> val range : int -> int list = <fun>   
range 3;;                           
> - : int list = [1; 2; 3]              

Придумал это:

let range a b =
  List.init (b - a) ((+) a)

Если вы намереваетесь подражать ленивому поведению range, я бы рекомендовал использовать модуль Stream. Что-то типа:

let range (start: int) (step: int) (stop: int): int stream =
    Stream.from (fn i -> let j = i * step + start in if j < stop then Some j else None)

Лично я использую для этого библиотеку диапазонов ocaml

 (* print sum of all values between 1 and 50, adding 4 to all elements and excluding 53 *)
 Range.(from 1 50 |> map ((+) 4) |> filter ((!=) 53) |> fold (+) 0 |> print_int);;