[Question][Hw3] fold_left_functions argument type

[ramel0915]

I'm trying to use fold_left_functions and I'm confused about the argument type. In the website, https://llvm.moe/ocaml/Llvm.html said val fold_left_functions : ('a -> llvalue -> 'a) -> 'a -> llmodule -> 'a

So fold_left_functions takes a function whose type is (a'->llvalue->'a) as the first argument.
However, in the VM machine, ((a'->b')->llvalue->a'->b') is needed.

Am I misunderstanding something..?

Thanks in advance!

[RiceBiscuits]

In this case, block_fold type must be (int * int)->llvalue->(int * int) due to second argument of the fold_left_functions.
But in your case, it seems that block_fold type is something different.
Please check a type of your function.

[ramel0915]

In this case, block_fold type must be (int * int)->llvalue->(int * int) due to second argument of the fold_left_functions.
But in your case, it seems that block_fold type is something different.
Please check a type of your function.

I think my function type is correct. Block_fold function type is already (int * int)->llvalue->(int * int)....
But in error message, compiler said it should be (a'->b')->llvalue->a'->b'.

[RiceBiscuits]

The error message said, your function type is (a'->b')->llvalue->a'->b'.

[ramel0915]

The error message said, your function type is (a'->b')->llvalue->a'->b'.

According to Ocaml website( https://ocaml.org/learn/tutorials/common_error_messages.html ),
Error: This expression has type A but an expression was expected of type B
means
my type: A
expected type: B, isn't it?

[KihongHeo]

According to the error msg, your function type is somewhat wrong.
It is hard to say something without actually seeing your definition. If you commit and push your current code, we can give proper feedback.

[ramel0915]

https://github.com/prosyslab-classroom/llvm-primer/blob/master/example.md
I used example code in llvm-primer. But it makes error....

[KihongHeo]

Some general tips:

• please take a look at the argument order carefully.
• if things are really confusing, you can manually annotate types and localize the program such as (the same example in the LLVM primer):

let scan_block : (int * int) -> llblock -> (int * int)
= fun (num_all, num_call) blk ->
  Llvm.fold_left_instrs                                   (* for each instruction in the block *)
    (fun (num_all, num_call) instr ->
      match Llvm.instr_opcode instr with                  (* count depending on the instruction opcode *)
      | Llvm.Opcode.Call -> (num_all + 1, num_call + 1)
      | _ -> (num_all + 1, num_call))
    (num_all, num_call) blk

Also you can annotate types for arbitrary expressions such as

...  (x : int) ... 

[ramel0915]

I found out the reason. I forgot to write semicolon for line delimiter.
Llvm.fold_left_functions (block_fold) (0,0) llm
llm
makes error. So I fixed it to
Llvm.fold_left_functions (block_fold) (0,0) llm ;
llm
Thank you Professor and TAs!