I’m not an OCaml person but I do know other functional languages. I looked into Alcotest and it looks like the function after “`Quick” has to be unit -> unit. Because OCaml has currying, and I think test_increment already returns unit, all you should have to do is add an extra parameter of type unit. I believe that would be done like this:
let test_increment (new_value, original_value) () =
Now the expression test_increment (1, 0) returns a function that must be passed a unit to run its body. That means you can change the lambdas to e.g. this:
test_case "blah" `Quick (test_increment (1, 0))
I don’t know OCaml precedence rules so the enclosing parentheses here may not be necessary.
I’d also note that taking new_value and original_value as a tuple would probably be considered not idiomatic unless it makes sense for the structure of the rest of your code, especially because it limits currying like we did with the unit being able to be passed later. Partial application/currying is a big part of the flexibility of functional languages.
Edit: if you’re getting into functional programming you may also consider calling increment_by_one “succ” or “successor” which is the typical terminology in functional land.
Currying is converting a function with n parameters to n functions that each have one parameter. This is done automatically in most primarily functional languages. Then, partial application is when you supply less than n arguments to a curried function. In short, currying happens at the function definition and partial application happens at the function call.
Currently the type of test_increment is (int, int) -> unit -> unit. What we want is int -> int -> unit -> unit. The more idiomatic way would have this function definition:
let test_increment new_value original_value () =
Which would require this change in the callers:
test_case "blah" `Quick (test_increment 1 0);
See, in most primarily functional languages you don’t put parentheses around function parameters/arguments, nor commas between them - in this case, only around and between members of tuples.
I’m not an OCaml person but I do know other functional languages. I looked into Alcotest and it looks like the function after “`Quick” has to be
unit -> unit. Because OCaml has currying, and I thinktest_incrementalready returnsunit, all you should have to do is add an extra parameter of typeunit. I believe that would be done like this:Now the expression
test_increment (1, 0)returns a function that must be passed aunitto run its body. That means you can change the lambdas to e.g. this:I don’t know OCaml precedence rules so the enclosing parentheses here may not be necessary.
I’d also note that taking
new_valueandoriginal_valueas a tuple would probably be considered not idiomatic unless it makes sense for the structure of the rest of your code, especially because it limits currying like we did with theunitbeing able to be passed later. Partial application/currying is a big part of the flexibility of functional languages.Edit: if you’re getting into functional programming you may also consider calling
increment_by_one“succ” or “successor” which is the typical terminology in functional land.deleted by creator
Currying is converting a function with n parameters to n functions that each have one parameter. This is done automatically in most primarily functional languages. Then, partial application is when you supply less than n arguments to a curried function. In short, currying happens at the function definition and partial application happens at the function call.
Currently the type of
test_incrementis(int, int) -> unit -> unit. What we want isint -> int -> unit -> unit. The more idiomatic way would have this function definition:let test_increment new_value original_value () =Which would require this change in the callers:
test_case "blah" `Quick (test_increment 1 0);See, in most primarily functional languages you don’t put parentheses around function parameters/arguments, nor commas between them - in this case, only around and between members of tuples.