Recursive call in if expression - ocaml

Question

    module Dfs = struct 
    let rec dfslsts g paths final =
        let l = PrimePath.removeDuplicates (PrimePath.extendPaths g paths)
        in
        let f elem =
            if  (List.mem "%d" (List.flatten final) = false) then (dfslsts g ["%d"] (List.flatten l)::final) 
            else final 
        in
        List.iter f (Graph.nodes g)

    end

Error: This expression has type string but an expression was expected of type int list

This error occurred when I called dfslsts function, which is recursive, inside the if condition. The function dfslsts returns a list of lists. If I try to replace the complex expression in if statement to

if  (List.mem "%d" (List.flatten final) = false) then "%d"
else "%d"

then I get Error: This expression has type 'a -> string but an expression was expected of type 'a -> unit Type string is not compatible with type unit at List.iter line.

How do I solve this problem and are we allowed to call a recursive function inside the if expression.

This is the definition of my graph type:

    module Graph = struct

    exception NodeNotFound of int

    type graph = {
        nodes : int list;
        edges : (int * int) list;
    }

    let makeGraph () =
        {
            nodes = [];
            edges = [];
        }

    let rec isNodeOf g n = List.mem n g.nodes

    let nodes g = g.nodes

    let edges g = g.edges

    let addNode g n =
        let nodes = n::g.nodes and edges = g.edges in
        {
            nodes;
            edges;
        }

    let addEdge g (n1, n2) =
        if ((isNodeOf g n1) = false) then
            raise (NodeNotFound n1)
        else if ((isNodeOf g n2) = false) then
            raise (NodeNotFound n2)
        else
            let nodes = g.nodes
            and edges = (n1, n2) :: g.edges in
            {
                nodes;
                edges;
            }

    let nextNodes g n =
        let rec findSuccessors edges n =
            match edges with
              [] -> []
            | (n1, n2) :: t ->
                if n1 = n then n2::findSuccessors t n
                else findSuccessors t n
        in
        findSuccessors g.edges n

    let rec lastNode path =
        match path with
          [] -> raise (NodeNotFound 0)
        | n :: [] -> n
        | _ :: t -> lastNode t

end

module Paths = struct
    let extendPath g path =
        let n         = (Graph.lastNode path) in
        let nextNodes = Graph.nextNodes g n   in
        let rec loop path nodes =
            match nodes with
              []     -> []
            | h :: t -> (List.append path [h]) :: (loop path t)
        in
        loop path nextNodes

    let rec extendPaths g paths =
        match paths with
          []     -> []
        | h :: t -> List.append (extendPath g h) (extendPaths g t) 

    (* Given a list lst, return a new list with all duplicate entries removed *)
    let rec removeDuplicates lst =
        match lst with
          []
        | _ :: [] -> lst
        | h :: t  ->
            let trimmed = removeDuplicates t in
            if List.mem h trimmed then trimmed
            else h :: trimmed

end

Recursive call in if expression - ocaml

Answers (1)

Related Questions