Learn Modern OCaml for Python and Javascript Developers

let () = Random.self_init ()

(* We use recursion instead of a `while` loop. The `rec` keyword allows a function to call itself. *)
let rec game_loop secret =
  print_string "> "; 
  flush stdout; (* Ensure prompt is drawn before waiting for input *)
  
  let input = read_line () in
  
  (* int_of_string_opt returns an option (Some int or None). 
     The pipeline operator `|>` passes `input` as the last argument to the function. *)
  match input |> int_of_string_opt with
  | None ->
      print_endline "Please type a valid number!";
      game_loop secret
  | Some guess ->
      if guess < secret then begin
        print_endline "Higher!";
        game_loop secret
      end else if guess > secret then begin
        print_endline "Lower!";
        game_loop secret
      end else
        print_endline "You win!"

let () =
  let secret_number = Random.int 100 + 1 in
  print_endline "Guess the number between 1 and 100!";
  game_loop secret_number

let rec play_loop () =
  let a = Random.int 10 + 1 in
  let b = Random.int 10 + 1 in
  
  (* %! forces stdout to flush immediately *)
  Printf.printf "What is %d + %d? %!" a b;
  
  let input = read_line () in
  if input = "quit" then
    print_endline "Thanks for playing!"
  else
    let correct_answer = a + b in
    
    (* 'when' adds a guard condition to a match case *)
    (match int_of_string_opt input with
     | Some ans when ans = correct_answer -> 
         print_endline "Correct!"
     | Some _ -> 
         Printf.printf "Wrong! It was %d\n" correct_answer
     | None -> 
         print_endline "Please enter a number or 'quit'.");
         
    play_loop ()

let () =
  Random.self_init ();
  print_endline "Solve the addition problems! Type 'quit' to exit.";
  play_loop ()

(* Variants form the backbone of safe State Machines *)
type operation = Add | Multiply
type app_state = Menu | Playing | Quit

(* Record syntax allows us to name fields in a complex structure *)
type settings = {
  min_val : int;
  max_val : int;
  op : operation;
}

let default_settings = { min_val = 1; max_val = 10; op = Add }

(* We pass the State and Settings explicitly. No global variables! *)
let rec run_machine state settings =
  match state with
  | Quit -> ()
  | Menu ->
      Printf.printf "1. Play  2. Set Multiply  3. Quit\n> %!";
      (match read_line () with
       | "1" -> run_machine Playing settings
       (* We use 'with' to create a new copy of settings, updating only 'op' *)
       | "2" -> 
           print_endline "Operation set to Multiplication.";
           run_machine Menu { settings with op = Multiply }
       | "3" -> run_machine Quit settings
       | _   -> 
           print_endline "Invalid option.";
           run_machine Menu settings)

  | Playing ->
      let a = Random.int (settings.max_val - settings.min_val + 1) + settings.min_val in
      let b = Random.int (settings.max_val - settings.min_val + 1) + settings.min_val in
      
      let symbol, correct = 
        match settings.op with
        | Add      -> ("+", a + b)
        | Multiply -> ("*", a * b)
      in

      Printf.printf "What is %d %s %d? ('menu' to go back) %!" a symbol b;
      let input = read_line () in
      
      if input = "menu" then
        run_machine Menu settings
      else begin
        (match int_of_string_opt input with
         | Some ans when ans = correct -> print_endline "Correct!"
         | Some _ -> Printf.printf "Wrong, it was %d\n" correct
         | None -> print_endline "Not a number.");
        run_machine Playing settings
      end

let () =
  Random.self_init ();
  run_machine Menu default_settings

type flashcard = { question : string; answer : string }

let ask_card card =
  Printf.printf "Q: %s (Press Enter)%!" card.question;
  let _ = read_line () in
  Printf.printf "A: %s\n\n" card.answer

let () =
  let deck = [
    { question = "Capital of France?"; answer = "Paris" };
    { question = "2 ** 8?"; answer = "256" };
    { question = "OCaml build tool?"; answer = "Dune" }
  ] in

  (* Instead of `for` loops, we use `List.iter` to run an action over a list *)
  List.iter ask_card deck;
  
  print_endline "Deck completed!"

open! Core
open! Bonsai_web

(* A Bonsai component is purely functional and incremental *)
let counter_component =
  (* Create a piece of state. It returns a 'value' and an 'inject' function to update it *)
  let%sub state, set_state = Bonsai.state (module Int) ~default_model:0 in
  
  (* We map over the state to return a Virtual DOM node *)
  return
    (let%map state = state and set_state = set_state in
     Vdom.Node.div
       [ Vdom.Node.button
           ~attr:(Vdom.Attr.on_click (fun _ -> set_state (state + 1)))
           [ Vdom.Node.text "Increment" ]
       ; Vdom.Node.text (sprintf " Count: %d" state)
       ])

let () =
  (* Mount the app to the DOM *)
  Bonsai_web.Start.start counter_component