OCaml：使用一个范围来构建列表，该范围的大小ID由从float转换为int的整数确定

Question

I'm trying to build a list in OCaml that takes its end range variable from a function which returns an int cast from a float:

    #require "batteries"
    #require "pa_comprehension"
    #require "core_kernel"
open Batteries
open Core_kernel

let factor_of num fact = num mod fact == 0 ;;

let limit num =  Float.to_int (floor (sqrt num) ) ;;

the population of this list is not performed due to:

Error: This expression has type int but an expression was expected of type [< Downto | To ]

in both the (yummy) batteries list comprehension:

[? List: x | x <- 0--(limit num) ; factor_of num x ?] ;;

and the (slightly less but still quite readable) core_kernel List constructor:

List.(range 0 (limit num) |> filter ~f:( fun x -> factor_of num x) );;

I'm thinking that the return from limit num is trapped inside the (evil) monad that provides the Float.to_int function. This also happens when using Float.int_of_float, the type signatures are the same:

utop # Float.to_int;;
- : float -> int = <fun>

So... how do I get my int 'out' of the monad, or, if this is not the problem, what is going on and how do I cast to an actual int that is usable in this way?

Also, could someone point me to a decent 'What the hell are these things: Monads' tutorial for tiny, tiny brains? I am at my wits end with them.

UPDATE: The error was not caused by any monadic behaviour (or use at all, in fact) it was due to the incorrect use of an infix operator (mod) and a couple of other quirks in functional thinking that I have not completely understood. I'm not sure this post should still exist but maybe it is an example of the mistakes you can make when moving into the functional paradigm...?

Answer 1

I have managed to get to the source of the problem. Over thinking and a late night:

The error was not caused by any monadic behaviour (or use of monads at all, in fact) it was due to the incorrect use of an infix operator (mod) and a couple of other quirks in functional thinking that I have not completely understood. I'm not sure this post should still exist but maybe it is an example of the mistakes you can make when moving into the functional paradigm...?

Credit to helping me fix the issue to Str for helping me bend my mind. Joe Gob has also pointed out the main issue in the code. More casting between float and int based of the types required by my functions.

This is the corrected code (deps.ml is a requirements file):

   #use "deps.ml";;
open Batteries
open Core_kernel

let factor_of num fact = num mod fact == 0 ;;

let limit num = 2 * Float.to_int (floor (sqrt num)) ;;

let factor_list_of num =
  [? List: x | x <- 1--(limit (Int.to_float num)) ; factor_of num x ?]

let sum_factors num = ( List.fold_right (+) (factor_list_of num) 0 )

let is_perfect num = sum_factors num == num
let is_abundant num = sum_factors num > num
let is_deficient num = sum_factors num < num

Basically I have been spoiled by Ruby, but I strongly advise rubyists to take up ocaml, it's has the closest style to ruby code of the functional languages.