Welcome to utop version 2.8.0 (using OCaml version 4.08.1)!

utop[0]> let time f =
  let start = Sys.time() in
  let _ = f () in
  Sys.time() -. start

let rec bad_reverse l =
  match l with
    [] -> []
  | h :: t -> bad_reverse t @ [h]

let reverse l =
  let rec aux l rl =
    match l with
      [] -> rl
    | h :: t -> aux t (h :: rl)
  in aux l []

let iota n =  List.init n (fun x -> x)

let l = iota 10000

(* time (fun () -> reverse1 l) *)

(*      
let rec f_gen l =
  match l with
    [] -> a
  | h :: t -> op h f_gen l

List.fold_right
                
let f_gen l =
  let rec aux l acc =
    match l with
      [] -> acc
    | h :: t -> aux t (op h acc)
in aux (List.rev l) b
 *)
;;
val time : (unit -> 'a) -> float = <fun>
val bad_reverse : 'a list -> 'a list = <fun>
val reverse : 'a list -> 'a list = <fun>
val iota : int -> int list = <fun>
val l : int list =
  [0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15; 16; 17; 18; 19; 20;
   21; 22; 23; 24; 25; 26; 27; 28; 29; 30; 31; 32; 33; 34; 35; 36; 37; 38;
   39; 40; 41; 42; 43; 44; 45; 46; 47; 48; 49; 50; 51; 52; 53; 54; 55; 56;
   57; 58; 59; 60; 61; 62; 63; 64; 65; 66; 67; 68; 69; 70; 71; 72; 73; 74;
   75; 76; 77; 78; 79; 80; 81; 82; 83; 84; 85; 86; 87; 88; 89; 90; 91; 92;
   93; 94; 95; 96; 97; 98; 99; 100; 101; 102; 103; 104; 105; 106; 107; 108;
   109; 110; 111; 112; 113; 114; 115; 116; 117; 118; 119; 120; 121; 122; 123;
   124; 125; 126; 127; 128; 129; 130; 131; 132; 133; 134; 135; 136; 137; 138;
   139; 140; 141; 142; 143; 144; 145; 146; 147; 148; 149; 150; 151; 152; 153;
   154; 155; 156; 157; 158; 159; 160; 161; 162; 163; 164; 165; 166; 167; 168;
   169; 170; 171; 172; 173; 174; 175; 176; 177; 178; 179; 180; 181; 182; 183;
   184; 185; 186; 187; 188; 189; 190; 191; 192; 193; 194; 195; 196; 197; 198;
   199; 200; 201; 202; 203; 204; 205; 206; 207; 208; 209; 210; 211; 212; 213;
   214; 215; 216; 217; 218; 219; 220; 221; 222; 223; 224; 225; 226; 227; 228;
   229; 230; 231; 232; 233; 234; 235; 236; 237; 238; 239; 240; 241; 242; 243;
   244; 245; 246; 247; 248; 249; 250; 251; 252; 253; 254; 255; 256; 257; 258;
   259; 260; 261; 262; 263; 264; 265; 266; 267; 268; 269; 270; 271; 272; 273;
   274; 275; 276; 277; 278; 279; 280; 281; 282; 283; 284; 285; 286; 287; 288;
   289; 290; 291; 292; 293; 294; 295; 296; 297; 298; ...]
utop[1]> iota 10;;
- : int list = [0; 1; 2; 3; 4; 5; 6; 7; 8; 9]
utop[2]> time (fun () -> reverse l);;
- : float = 0.000758000000000008667
utop[3]> time (fun () -> bad_reverse l);;
- : float = 0.843769
utop[4]> List.length l;;
- : int = 10000
utop[5]> let l = iota 100000

(* time (fun () -> reverse1 l) *)

(*      
let rec f_gen l =
  match l with
    [] -> a
  | h :: t -> op h f_gen l

List.fold_right
                
let f_gen l =
  let rec aux l acc =
    match l with
      [] -> acc
    | h :: t -> aux t (op h acc)
in aux (List.rev l) b
 *)
;;
val l : int list =
  [0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15; 16; 17; 18; 19; 20;
   21; 22; 23; 24; 25; 26; 27; 28; 29; 30; 31; 32; 33; 34; 35; 36; 37; 38;
   39; 40; 41; 42; 43; 44; 45; 46; 47; 48; 49; 50; 51; 52; 53; 54; 55; 56;
   57; 58; 59; 60; 61; 62; 63; 64; 65; 66; 67; 68; 69; 70; 71; 72; 73; 74;
   75; 76; 77; 78; 79; 80; 81; 82; 83; 84; 85; 86; 87; 88; 89; 90; 91; 92;
   93; 94; 95; 96; 97; 98; 99; 100; 101; 102; 103; 104; 105; 106; 107; 108;
   109; 110; 111; 112; 113; 114; 115; 116; 117; 118; 119; 120; 121; 122; 123;
   124; 125; 126; 127; 128; 129; 130; 131; 132; 133; 134; 135; 136; 137; 138;
   139; 140; 141; 142; 143; 144; 145; 146; 147; 148; 149; 150; 151; 152; 153;
   154; 155; 156; 157; 158; 159; 160; 161; 162; 163; 164; 165; 166; 167; 168;
   169; 170; 171; 172; 173; 174; 175; 176; 177; 178; 179; 180; 181; 182; 183;
   184; 185; 186; 187; 188; 189; 190; 191; 192; 193; 194; 195; 196; 197; 198;
   199; 200; 201; 202; 203; 204; 205; 206; 207; 208; 209; 210; 211; 212; 213;
   214; 215; 216; 217; 218; 219; 220; 221; 222; 223; 224; 225; 226; 227; 228;
   229; 230; 231; 232; 233; 234; 235; 236; 237; 238; 239; 240; 241; 242; 243;
   244; 245; 246; 247; 248; 249; 250; 251; 252; 253; 254; 255; 256; 257; 258;
   259; 260; 261; 262; 263; 264; 265; 266; 267; 268; 269; 270; 271; 272; 273;
   274; 275; 276; 277; 278; 279; 280; 281; 282; 283; 284; 285; 286; 287; 288;
   289; 290; 291; 292; 293; 294; 295; 296; 297; 298; ...]
utop[6]> time (fun () -> bad_reverse l);;
Interrupted.
utop[7]> let l = iota 50000

(* time (fun () -> reverse1 l) *)

(*      
let rec f_gen l =
  match l with
    [] -> a
  | h :: t -> op h f_gen l

List.fold_right
                
let f_gen l =
  let rec aux l acc =
    match l with
      [] -> acc
    | h :: t -> aux t (op h acc)
in aux (List.rev l) b
 *)
;;
val l : int list =
  [0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15; 16; 17; 18; 19; 20;
   21; 22; 23; 24; 25; 26; 27; 28; 29; 30; 31; 32; 33; 34; 35; 36; 37; 38;
   39; 40; 41; 42; 43; 44; 45; 46; 47; 48; 49; 50; 51; 52; 53; 54; 55; 56;
   57; 58; 59; 60; 61; 62; 63; 64; 65; 66; 67; 68; 69; 70; 71; 72; 73; 74;
   75; 76; 77; 78; 79; 80; 81; 82; 83; 84; 85; 86; 87; 88; 89; 90; 91; 92;
   93; 94; 95; 96; 97; 98; 99; 100; 101; 102; 103; 104; 105; 106; 107; 108;
   109; 110; 111; 112; 113; 114; 115; 116; 117; 118; 119; 120; 121; 122; 123;
   124; 125; 126; 127; 128; 129; 130; 131; 132; 133; 134; 135; 136; 137; 138;
   139; 140; 141; 142; 143; 144; 145; 146; 147; 148; 149; 150; 151; 152; 153;
   154; 155; 156; 157; 158; 159; 160; 161; 162; 163; 164; 165; 166; 167; 168;
   169; 170; 171; 172; 173; 174; 175; 176; 177; 178; 179; 180; 181; 182; 183;
   184; 185; 186; 187; 188; 189; 190; 191; 192; 193; 194; 195; 196; 197; 198;
   199; 200; 201; 202; 203; 204; 205; 206; 207; 208; 209; 210; 211; 212; 213;
   214; 215; 216; 217; 218; 219; 220; 221; 222; 223; 224; 225; 226; 227; 228;
   229; 230; 231; 232; 233; 234; 235; 236; 237; 238; 239; 240; 241; 242; 243;
   244; 245; 246; 247; 248; 249; 250; 251; 252; 253; 254; 255; 256; 257; 258;
   259; 260; 261; 262; 263; 264; 265; 266; 267; 268; 269; 270; 271; 272; 273;
   274; 275; 276; 277; 278; 279; 280; 281; 282; 283; 284; 285; 286; 287; 288;
   289; 290; 291; 292; 293; 294; 295; 296; 297; 298; ...]
utop[8]> time (fun () -> bad_reverse l);;
Interrupted.
utop[9]> let l = iota 20000

(* time (fun () -> reverse1 l) *)

(*      
let rec f_gen l =
  match l with
    [] -> a
  | h :: t -> op h f_gen l

List.fold_right
                
let f_gen l =
  let rec aux l acc =
    match l with
      [] -> acc
    | h :: t -> aux t (op h acc)
in aux (List.rev l) b
 *)
;;
val l : int list =
  [0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15; 16; 17; 18; 19; 20;
   21; 22; 23; 24; 25; 26; 27; 28; 29; 30; 31; 32; 33; 34; 35; 36; 37; 38;
   39; 40; 41; 42; 43; 44; 45; 46; 47; 48; 49; 50; 51; 52; 53; 54; 55; 56;
   57; 58; 59; 60; 61; 62; 63; 64; 65; 66; 67; 68; 69; 70; 71; 72; 73; 74;
   75; 76; 77; 78; 79; 80; 81; 82; 83; 84; 85; 86; 87; 88; 89; 90; 91; 92;
   93; 94; 95; 96; 97; 98; 99; 100; 101; 102; 103; 104; 105; 106; 107; 108;
   109; 110; 111; 112; 113; 114; 115; 116; 117; 118; 119; 120; 121; 122; 123;
   124; 125; 126; 127; 128; 129; 130; 131; 132; 133; 134; 135; 136; 137; 138;
   139; 140; 141; 142; 143; 144; 145; 146; 147; 148; 149; 150; 151; 152; 153;
   154; 155; 156; 157; 158; 159; 160; 161; 162; 163; 164; 165; 166; 167; 168;
   169; 170; 171; 172; 173; 174; 175; 176; 177; 178; 179; 180; 181; 182; 183;
   184; 185; 186; 187; 188; 189; 190; 191; 192; 193; 194; 195; 196; 197; 198;
   199; 200; 201; 202; 203; 204; 205; 206; 207; 208; 209; 210; 211; 212; 213;
   214; 215; 216; 217; 218; 219; 220; 221; 222; 223; 224; 225; 226; 227; 228;
   229; 230; 231; 232; 233; 234; 235; 236; 237; 238; 239; 240; 241; 242; 243;
   244; 245; 246; 247; 248; 249; 250; 251; 252; 253; 254; 255; 256; 257; 258;
   259; 260; 261; 262; 263; 264; 265; 266; 267; 268; 269; 270; 271; 272; 273;
   274; 275; 276; 277; 278; 279; 280; 281; 282; 283; 284; 285; 286; 287; 288;
   289; 290; 291; 292; 293; 294; 295; 296; 297; 298; ...]
utop[10]> List.length l;;
- : int = 20000
utop[11]> time (fun () -> bad_reverse l);;
- : float = 4.02715099999999637
utop[12]> time (fun () -> reverse l);;
- : float = 0.000450000000000727596
utop[13]> time (fun () -> List.rev l);;
- : float = 0.000419000000000835371
utop[14]> 














;
;
;
;;
Error: Syntax error
utop[15]> ;;
utop[16]> ;;
utop[17]> let time f =
  let start = Sys.time() in
  let _ = f () in
  Sys.time() -. start

let rec bad_reverse l =
  match l with
    [] -> []
  | h :: t -> bad_reverse t @ [h]

let reverse l =
  let rec aux l rl =
    match l with
      [] -> rl
    | h :: t -> aux t (h :: rl)
  in aux l []

let iota n =  List.init n (fun x -> x)

let l = iota 20000

(* time (fun () -> reverse1 l) *)

(*      
let rec f_gen l =
  match l with
    [] -> a
  | h :: t -> op h f_gen l

List.fold_right
                
let f_gen l =
  let rec aux l acc =
    match l with
      [] -> acc
    | h :: t -> aux t (op h acc)
in aux (List.rev l) b
 *)
;;
val time : (unit -> 'a) -> float = <fun>
val bad_reverse : 'a list -> 'a list = <fun>
val reverse : 'a list -> 'a list = <fun>
val iota : int -> int list = <fun>
val l : int list =
  [0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15; 16; 17; 18; 19; 20;
   21; 22; 23; 24; 25; 26; 27; 28; 29; 30; 31; 32; 33; 34; 35; 36; 37; 38;
   39; 40; 41; 42; 43; 44; 45; 46; 47; 48; 49; 50; 51; 52; 53; 54; 55; 56;
   57; 58; 59; 60; 61; 62; 63; 64; 65; 66; 67; 68; 69; 70; 71; 72; 73; 74;
   75; 76; 77; 78; 79; 80; 81; 82; 83; 84; 85; 86; 87; 88; 89; 90; 91; 92;
   93; 94; 95; 96; 97; 98; 99; 100; 101; 102; 103; 104; 105; 106; 107; 108;
   109; 110; 111; 112; 113; 114; 115; 116; 117; 118; 119; 120; 121; 122; 123;
   124; 125; 126; 127; 128; 129; 130; 131; 132; 133; 134; 135; 136; 137; 138;
   139; 140; 141; 142; 143; 144; 145; 146; 147; 148; 149; 150; 151; 152; 153;
   154; 155; 156; 157; 158; 159; 160; 161; 162; 163; 164; 165; 166; 167; 168;
   169; 170; 171; 172; 173; 174; 175; 176; 177; 178; 179; 180; 181; 182; 183;
   184; 185; 186; 187; 188; 189; 190; 191; 192; 193; 194; 195; 196; 197; 198;
   199; 200; 201; 202; 203; 204; 205; 206; 207; 208; 209; 210; 211; 212; 213;
   214; 215; 216; 217; 218; 219; 220; 221; 222; 223; 224; 225; 226; 227; 228;
   229; 230; 231; 232; 233; 234; 235; 236; 237; 238; 239; 240; 241; 242; 243;
   244; 245; 246; 247; 248; 249; 250; 251; 252; 253; 254; 255; 256; 257; 258;
   259; 260; 261; 262; 263; 264; 265; 266; 267; 268; 269; 270; 271; 272; 273;
   274; 275; 276; 277; 278; 279; 280; 281; 282; 283; 284; 285; 286; 287; 288;
   289; 290; 291; 292; 293; 294; 295; 296; 297; 298; ...]
utop[18]> iota 9;;
- : int list = [0; 1; 2; 3; 4; 5; 6; 7; 8]
utop[19]> List.length l;;
- : int = 20000
utop[20]> time (fun () -> bad_reverse l)
;;
- : float = 4.00694899999999876
utop[21]> time (fun () -> reverse l);;
- : float = 0.00213499999999555712
utop[22]> List.fold_left;;
- : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a = <fun>
utop[23]> (+);;
- : int -> int -> int = <fun>
utop[24]> (+) 2 3;;
- : int = 5
utop[25]> let sum_list l =
  match l with
    [] -> 0
  | h :: l -> h + sum_list t
                    
(* time (fun () -> reverse1 l) *)

(*      
let rec f_gen l =
  match l with
    [] -> a
  | h :: t -> op h f_gen l

List.fold_right
                
let f_gen l =
  let rec aux l acc =
    match l with
      [] -> acc
    | h :: t -> aux t (op h acc)
in aux (List.rev l) b
 *)
;;
Error: Unbound value sum_list
Hint: If this is a recursive definition,
you should add the 'rec' keyword on line 1
utop[26]> let rec sum_list l =
  match l with
    [] -> 0
  | h :: l -> h + sum_list t
                    
(* time (fun () -> reverse1 l) *)

(*      
let rec f_gen l =
  match l with
    [] -> a
  | h :: t -> op h f_gen l

List.fold_right
                
let f_gen l =
  let rec aux l acc =
    match l with
      [] -> acc
    | h :: t -> aux t (op h acc)
in aux (List.rev l) b
 *)
;;
Error: Unbound value t
utop[27]> let rec sum_list l =
  match l with
    [] -> 0
  | h :: t -> h + sum_list t
                    
(* time (fun () -> reverse1 l) *)

(*      
let rec f_gen l =
  match l with
    [] -> a
  | h :: t -> op h f_gen l

List.fold_right
                
let f_gen l =
  let rec aux l acc =
    match l with
      [] -> acc
    | h :: t -> aux t (op h acc)
in aux (List.rev l) b
 *)
;;
val sum_list : int list -> int = <fun>
utop[28]> List.fold_right;;
- : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b = <fun>
utop[29]> List.fold_left;;
- : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a = <fun>
utop[30]> let rec sum_list l =
  match l with
    [] -> 0
  | h :: t -> (+) h (sum_list t);;
val sum_list : int list -> int = <fun>
utop[31]> sum_list [1;2;3;4;5];;
- : int = 15
utop[32]> let sum_list_fold l =
  List.fold_right (+) l 0 
                    
(* time (fun () -> reverse1 l) *)

(*      
let rec f_gen l =
  match l with
    [] -> a
  | h :: t -> op h (f_gen l)

List.fold_right
                
let f_gen l =
  let rec aux l acc =
    match l with
      [] -> acc
    | h :: t -> aux t (op h acc)
in aux (List.rev l) b
 *)
;;
val sum_list_fold : int list -> int = <fun>
utop[33]> sum_list_fold [1;2;3;4;5];;
- : int = 15
utop[34]> fun x -> x;;
- : 'a -> 'a = <fun>
utop[35]> fun x -> 2 * x;;
- : int -> int = <fun>
utop[36]>  fun c1 c2-> fst c1 = snd c2 && snd c1 = fst c2;;
- : 'a * 'b -> 'b * 'a -> bool = <fun>
utop[37]>  fun c1 c2-> fst c1 = fst c2 && snd c1 = snd c2;;
- : 'a * 'b -> 'a * 'b -> bool = <fun>
utop[38]> List.fold_left;;
- : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a = <fun>
utop[39]>