let list_of_string s =
  let rec iter i s =
    if i = (String.length s) then []
    else s.[i] :: (iter (i + 1)) s
  in
  iter 0 s

let is_digit c =
  c >= '0' && c <= '9'

let is_upper c =
  c >= 'A' && c <= 'Z'

let is_lower c =
  c >= 'a' && c <= 'z'

let is_alpha c =
  (is_lower c) || (is_upper c)

let is_alphanum c =
  (is_alpha c) || (is_digit c)

let num s = 
  let pos = ref 0 in
      let rec one (c : char) = 
        if !pos >= Bytes.length s then false
        else if (is_digit c) then 
        begin
          pos := !pos + 1;
          two s.[!pos] 
        end
        else false
      and two (c : char) = 
        if !pos >= Bytes.length s then true
        else if (is_digit c) then 
        begin
          pos := !pos + 1;
          two s.[!pos] 
        end
        else false
  in s, (one s.[0])

(*
The following solution is based on DFA simulation. As the given
FSA is an NFA, it had to be converted to a DFA which is as follows:

        'a, 'b
         ---->
         \   /
     'a   \ /   _
  1' ----> 2' ----> 3'
           ^        |
           |        |
           |--------|
              'a, 'b

'a -> alpha, 'b -> beta

The above conversion has been done using the 'subset construction'
method.
*)

let id s =
  let pos = ref 0 in
    let rec one (c : char) = 
      if (is_alpha c) then 
      begin
        if (!pos+1 == Bytes.length s) then true
        else
        begin
          pos := !pos + 1;
          two s.[!pos]
        end
      end
      else false
    and two (c : char) = 
      if (is_alpha c || is_alphanum c) then
      begin 
        if (!pos+1 == Bytes.length s) then true
        else begin
          pos := !pos + 1;
          two s.[!pos]
        end
      end
      else if c=='_' then
      begin
        if (!pos+1 == Bytes.length s) then false
        else begin
          pos := !pos + 1;
          three s.[!pos]
        end
      end
      else false
    and three (c : char) = 
      if (is_alpha c || is_alphanum c) then
      begin 
        if (!pos+1 == Bytes.length s) then true
        else begin 
          pos := !pos + 1;
          two s.[!pos]
        end
      end
      else false
  in s, (one s.[0])
    

let test_nums () =
  let n = [ "a"; "123"; "2a3"; "Ab"] in
  let result = List.map num n in
    List.iter (fun (x, y) -> (Printf.printf "%s -> %b;\n" x y)) result

let test_ids () =
  let n = [ "a"; "ab";"_abc";"ab_c";"a1_b";"1a"] in
  let result = List.map id n in
    List.iter (fun (x, y) -> (Printf.printf "%s -> %b;\n" x y)) result

let _ = test_ids ()