Ocaml

utop # #utop_help;;
If you can't see the prompt properly try: #utop_prompt_simple                                                                                                                               utop defines the following directives:

#utop_bindings   : list all the current key bindings
#utop_macro      : display the currently recorded macro
#topfind_log     : display messages recorded from findlib since the beginning of the session
#topfind_verbose : enable/disable topfind verbosity
For a complete description of utop, look at the utop(1) manual page.

utop # #use "topfind";;
- : unit = ()                                                                                 Findlib has been successfully loaded. Additional directives:                                    #require "package";;      to load a package
  #list;;                   to list the available packages
  #camlp4o;;                to load camlp4 (standard syntax)
  #camlp4r;;                to load camlp4 (revised syntax)
  #predicates "p,q,...";;   to set these predicates
  Topfind.reset();;         to force that packages will be reloaded
  #thread;;                 to enable threads

- : unit = ()

utop # #list ;;
archimedes          (version: 0.4.17) archimedes.graphics (version: 0.4.17)                                  archimedes.internals (version: 0.4.17)
archimedes.top      (version: 0.4.17)
batteries           (version: 2.3)
bigarray            (version: [distributed with Ocaml])
bin_prot            (version: 111.03.00)
...

utop # #utop_bindings;;
enter       : accept                        -> accept the current input.                                  escape      : cancel-search                 -> cancel search mode.                                        tab         : complete                      -> complete current input.
up          : history-prev                  -> go to the previous entry of the history.
down        : history-next                  -> go to the next entry of the history.
...

# #use "text.ml" ;;
val split_lines : string -> string list = <fun>
val split_space : string -> string list = <fun>
val split_delim : string -> string -> string list = <fun>
val add_prefix : string -> string -> string = <fun>
val add_suffix : string -> string -> string = <fun>
# 

#  split_space "Hello world ocaml" ;; 
- : string list = ["Hello"; "world"; "ocaml"]
#

# #mod_use "text.ml" ;;
  module Text :
    sig
      val split_lines : string -> string list
      val split_space : string -> string list
      val split_delim : string -> string -> string list
      val add_prefix : string -> string -> string
      val add_suffix : string -> string -> string
    end
  # 

  #  Text.split_space "Hello world ocaml" ;;
  - : string list = ["Hello"; "world"; "ocaml"]
  #

# #show Filename ;;
module Filename :
  sig
    val current_dir_name : string
    val parent_dir_name : string
    val dir_sep : string
    val concat : string -> string -> string
    val is_relative : string -> bool
    val is_implicit : string -> bool
    val check_suffix : string -> string -> bool
    val chop_suffix : string -> string -> string
    val chop_extension : string -> string
    val basename : string -> string
    val dirname : string -> string
    val temp_file : ?temp_dir:string -> string -> string -> string
    val open_temp_file :
      ?mode:open_flag list ->
      ?temp_dir:string -> string -> string -> string * out_channel
    val get_temp_dir_name : unit -> string
    val set_temp_dir_name : string -> unit
    val temp_dir_name : string
    val quote : string -> string
  end
#

$ ocaml -version
The OCaml toplevel, version 4.01.0

$ opam --version
1.2.2

$ ocamlc -v
The OCaml compiler, version 4.01.0
Standard library directory: /usr/lib/ocaml

$ ocamlopt -v
The OCaml native-code compiler, version 4.01.0
Standard library directory: /usr/lib/ocaml

$ utop -version
The universal toplevel for OCaml, version 1.17, compiled for OCaml version 4.01.0

$ opam config list
 # Global OPAM configuration variables

user                 tux
group                tux
make                 make
os                   linux
root                 /home/tux/.opam
prefix               /home/tux/.opam/system
lib                  /home/tux/.opam/system/lib
bin                  /home/tux/.opam/system/bin
sbin                 /home/tux/.opam/system/sbin
doc                  /home/tux/.opam/system/doc
stublibs             /home/tux/.opam/system/lib/stublibs
toplevel             /home/tux/.opam/system/lib/toplevel
man                  /home/tux/.opam/system/man
share                /home/tux/.opam/system/share
etc                  /home/tux/.opam/system/etc

 # Global variables from the environment

ocaml-version        4.01.0     # The version of the currently used OCaml compiler
opam-version         1.2.2      # The currently running OPAM version
compiler             system     # The name of the current OCaml compiler (may be more specific than the version, eg: "4.01.0+fp", or "system")
preinstalled         true       # Whether the compiler was preinstalled on the system, or installed by OPAM
switch               system     # The local name (alias) of the current switch
jobs                 1          # The number of parallel jobs set up in OPAM configuration
ocaml-native         true       # Whether the OCaml native compilers are available
ocaml-native-tools   false      # Whether the native ".opt" version of the OCaml toolchain is available
ocaml-native-dynlink true       # Whether native dynlink is available on this installation
arch                 i686       # The current arch, as returned by "uname -m"

 # Package variables ('opam config list PKG' to show)

PKG:name         # Name of the package
PKG:version      # Version of the package
PKG:depends      # Resolved direct dependencies of the package
PKG:installed    # Whether the package is installed
PKG:enable       # Takes the value "enable" or "disable" depending on whether the package is installed
PKG:pinned       # Whether the package is pinned
PKG:bin          # Binary directory for this package
PKG:sbin         # System binary directory for this package
PKG:lib          # Library directory for this package
PKG:man          # Man directory for this package
PKG:doc          # Doc directory for this package
PKG:share        # Share directory for this package
PKG:etc          # Etc directory for this package
PKG:build        # Directory where the package was built
PKG:hash         # Hash of the package archive

$ ocaml
        OCaml version 4.01.0

    (* Boolean          *)
    (*------------------*)

    # true ;;
    - : bool = true
    # false ;;
    - : bool = false
    #

    (* Int              *)
    (*--------------------
     *      32 bits  signed int in 32 bits machines
     *      64 bits  signed int in 64 bits machines
     *)
    # 1000 ;;
    - : int = 1000

    (* Binary  int *)
    # 0b1000111011 ;;
    - : int = 571

    (* Hexadecimal int *)
    # 0xf0057a3 ;;
    - : int = 251680675

    (* octal int *)
    # 0o73456 ;;
    - : int = 30510

    (* Floats                   *)
    (* ------------------------ *)
    # 3.23e3 ;;
    - : float = 3230.
    # 34.2E-5 ;;
    - : float = 0.000342
    # 232. ;;
    - : float = 232.
    #

    (* Char                     *)
    (* ------------------------ *)

    # 'a' ;;
    - : char = 'a'
    # '\n' ;;
    - : char = '\n'
    # '\232' ;;
    - : char = '\232'


    (* String                         *)
    (* ------------------------------- *)

    # "Hello world OCaml" ;;
    - : string = "Hello world OCaml"
    #

    (* Tuples                            *)
    (* ----------------------------------*)
    # "Hello world OCaml" ;;
    - : string = "Hello world OCaml"
    # (10, 203.2322) ;;
    - : int * float = (10, 203.2322)
    # ("hello", 'w', 10 ) ;;
    - : string * char * int = ("hello", 'w', 10)
    #

    (* Lists / Are immutable data structure   *)
    (*----------------------------------------*)

    # [10; 20; 30; 40; 1; 3] ;;
    - : int list = [10; 20; 30; 40; 1; 3]

    # ["hello" ; "world" ; "ocaml" ; "F#" ; "Haskell" ] ;;
    - : string list = ["hello"; "world"; "ocaml"; "F#"; "Haskell"]
    #

    # [10. ; 2.323 ; 29.232 ; 100.597 ; -23.3 ] ;;
    - : float list = [10.; 2.323; 29.232; 100.597; -23.3]
    #

    # [(1, 'a') ; (2, 'b') ; (3, 'c')] ;;
    - : (int * char) list = [(1, 'a'); (2, 'b'); (3, 'c')]
    #

    (* Arrays / Mutable data structures  *)
    (* --------------------------------- *)

    # [|23; 100; 50; 80; 30; 50 |] ;;
    - : int array = [|23; 100; 50; 80; 30; 50|]

     # [|123.23; 10.23; 50.53; -80.23; 30.9734; 50.25 |] ;;
    - : float array = [|123.23; 10.23; 50.53; -80.23; 30.9734; 50.25|]

     # [|'o'; 'c'; 'a' ; 'm' ; 'l' |] ;;
    - : char array = [|'o'; 'c'; 'a'; 'm'; 'l'|]

    (* Unit / Represents side effects (Similar to Haskell IO ()*)
    (*-------------------------------------------------------- *)

    # ();;
    - : unit = ()
    #

    # print_string ;;
    - : string -> unit = <fun>

    # read_line ;;
    - : unit -> string = <fun>

    # let read_two_lines () = read_line (); read_line (); print_string "two lines" ;;
    val read_two_lines : unit -> unit = <fun>

    # read_two_lines () ;;
    2323
    5353535
    two lines- : unit = ()


    (* Option Type / Equivalent to Haskell Maybe *)

    # None ;;
    - : 'a option = None
    # Some 10 ;;
    - : int option = Some 10
    # Some 'a' ;;
    - : char option = Some 'a'
    # Some "OCaml" ;;
    - : string option = Some "OCaml"
    #

(* NOT                  *)
(*----------------------*)

# not ;;
- : bool -> bool = <fun>
#

# not false ;;
- : bool = true
# not true ;;
- : bool = false

(* AND                  *)
(*----------------------*)

# (&&) ;;
- : bool -> bool -> bool = <fun>

# (&&) true false ;;
- : bool = false
#


# true && true ;;
- : bool = true
# true && false ;;
- : bool = false
#

(* OR                   *)
(*----------------------*)

# (||) ;;
- : bool -> bool -> bool = <fun>

# (||) false true ;;
- : bool = true
#

# true || true ;;
- : bool = true
# true || false ;;
- : bool = true
# false || false ;;
- : bool = false
#

(* Equality *)
# (=) ;;
- : 'a -> 'a -> bool = <fun>
# (==) ;;
- : 'a -> 'a -> bool = <fun>

(* Inequality *)
# (<>) ;;
- : 'a -> 'a -> bool = <fun>
# (!=) ;;
- : 'a -> 'a -> bool = <fun>
#


# (<) ;;
- : 'a -> 'a -> bool = <fun>
# (<=) ;;
- : 'a -> 'a -> bool = <fun>
# (>=) ;;
- : 'a -> 'a -> bool = <fun>
# (>) ;;
- : 'a -> 'a -> bool = <fun>
#

# max ;;
- : 'a -> 'a -> 'a = <fun>
# min ;;
- : 'a -> 'a -> 'a = <fun>


# compare ;;
- : 'a -> 'a -> int = <fun>
#

# 2 <> 4 ;;
- : bool = true
# 2 <> 2 ;;
- : bool = false
#
# 3 != 4 ;;
- : bool = true
# 3 != 3 ;;
- : bool = false
#


# max 3 100 ;;
- : int = 100
# min 2.323 100.33 ;;
- : float = 2.323
#

 # (+) ;;
- : int -> int -> int = <fun>

 # (-) ;;
- : int -> int -> int = <fun>

 # (+.) ;;
- : float -> float -> float = <fun>

 (-.) ;;
- : float -> float -> float = <fun>


(* Interger Operators *)
(*--------------------*)
# 23 + 234 ;;
- : int = 257
# 1000 / 4 ;;
- : int = 250
#

# 1005 mod 10 ;;
- : int = 5
#

# abs (-10) ;;
- : int = 10
# abs 10 ;;
- : int = 10
#
# pred 100 ;;
- : int = 99
# pred 99 ;;
- : int = 98
# succ 100 ;;
- : int = 101
# succ 101 ;;
- : int = 102
#

(* Float Point *)
(*-------------*)

# 100. +. 23.23 ;;
- : float = 123.23
#
# 0.545 *. 100. ;;
- : float = 54.5000000000000071
#
# 1000. /. 4. ;;
- : float = 250.
#
# 1000.0 -. 4.0 ;;
- : float = 996.
#

(* Pow function 2^4 = 16 / only works for float points *)
# 2.0 ** 4. ;;
- : float = 16.
#
# ( **) ;;
- : float -> float -> float = <fun>
#

> let x = 2 ;;
val x : int = 2

(* Declaration with Type *)
> let a : float  = 2.323 ;;
val a : float = 2.323

(* Characters and String *)

> 'a' ;;
- : char = 'a'
> "hello world" ;;
- : string = "hello world"

(* Lists *)

> [1; 2; 3; 4 ; 5; 6] ;;
- : int list = [1; 2; 3; 4; 5; 6]


> [2.323; 534.23; 83.434; 54.3323 ] ;;
- : float list = [2.323; 534.23; 83.434; 54.3323]


> ["hello"; "world"; "ocaml"; "amazing" ] ;;
- : string list = ["hello"; "world"; "ocaml"; "amazing"]



(****** Tuples ***********)

>  (90, 100 ) ;;
- : int * int = (90, 100)

>  (232, 23.232, "hello ", 'c' ) ;;
- : int * float * string * char = (232, 23.232, "hello ", 'c')
>


>  ("hello", 23.23 ) ;;
- : string * float = ("hello", 23.23)

# let  x = 10 in 
  let  y = 3  in
  let  z = 4  in 
  (x, y, z)
  ;;
- : int * int * int = (10, 3, 4)

# x ;;
Error: Unbound value x
# y ;;
Error: Unbound value y
# z ;;
Error: Unbound value z
# 

(**********************)

# let z = 
    let x = 10 in
    let y = 20 in
    x + 2*y
  ;;
val z : int = 50
# z ;;
- : int = 50
# x ;;
Error: Unbound value x
# y ;;
Error: Unbound value y
# 

(**********************)

# let a = 
    let f1 x = 10 *x in
    let fxy x y = 3*x + 4*y in 
    let z = 3 in
    f1 z + fxy 3 4 + f1 6 ;;
val a : int = 115

# a ;;
- : int = 115
# 

# f1 ;;
Error: Unbound value f1
# fxy ;;
Error: Unbound value fxy


(**********************)

# let a, b, c = 
     let f1 x  = 3 * x in 
     let f2 x y = 5 * x - 3 * y in
     let a = 3 in
     let b = 4 in 
     let c = a + b in 
     (f1 a, f2 a b, a + b + c)
  ;;
val a : int = 9
val b : int = 3
val c : int = 14
# 

# f1 ;;
Error: Unbound value f1
# f2 ;;
Error: Unbound value f2
#

> let id = fun x -> x ;;
val id : 'a -> 'a = <fun>

>  id 10.23 ;;
- : float = 10.23
>  id 100  ;;
- : int = 100
>  id "Hello world" ;;
- : string = "Hello world"
>

(* 31 bits signed int, since this machine has 32 bits word lenght*)

    # Pervasives.min_int ;;
    - : int = -1073741824
    # Pervasives.max_int ;;
    - : int = 1073741823

(* 32 bits signed int *)

    # Int32.max_int ;;
    - : int32 = 2147483647l
    # Int32.min_int ;;
    - : int32 = -2147483648l

(* 64 bits signed int *)
    # Int64.min_int ;;
    - : int64 = -9223372036854775808L
    # Int64.max_int ;;
    - : int64 = 9223372036854775807L

(* IEEE.754 - 64 bits double precision - float point *)

    # Pervasives.min_float ;;
    - : float = 2.22507385850720138e-308
    # Pervasives.max_float ;;
    - : float = 1.79769313486231571e+308

(* Default - Pervasives 31 bit signed int (32 bits machine) *)

    # 23213 ;;
    - : int = 23213

    # 0xf43aaec ;;
    - : int = 256092908

    # 0b10001110011 ;;
    - : int = 1139

(* 32 bits signed int *)

    # 23213l ;;
    - : int32 = 23213l

    # 0xf4123l ;;
    - : int32 = 999715l

    # 0b1111100011110011l ;;
    - : int32 = 63731l

(* 64 bits signed int *)

    # 1000000L ;;
    - : int64 = 1000000L

     # 0xff2562abcL ;;
    - : int64 = 68490242748L

    # 0b11111000111100110011111101L ;;
    - : int64 = 65260797L

# Int32.of_int 10002373 ;;
- : int32 = 10002373l
# Int32.of_float 232322.323 ;;
- : int32 = 232322l
# Int32.of_string "98232376" ;;
- : int32 = 98232376l

# Int32.to_int 100033l ;;
- : int = 100033


# Int64.of_int 100 ;;
- : int64 = 100L
# Int64.of_float 1000239823.2323 ;;
- : int64 = 1000239823L
# Int64.of_string "34234912" ;;
- : int64 = 34234912L

# Int64.to_int 2323884L ;;
- : int = 2323884


 # int_of_float (-1235.34083402321) ;;
- : int = -1235
# Pervasives.int_of_float (-1235.34083402321) ;;
- : int = -1235
 # int_of_string "9123" ;;
- : int = 9123

# float_of_int 1000 ;;
- : float = 1000.

    # (+) ;;
    - : int -> int -> int = <fun>

    # (+.) ;;
    - : float -> float -> float = <fun>

    # Int32.add ;;
    - : int32 -> int32 -> int32 = <fun>

    # Int64.add ;;
    - : int64 -> int64 -> int64 = <fun>

    # Big_int.add_big_int ;;
    - : Big_int.big_int -> Big_int.big_int -> Big_int.big_int = <fun>

    # 23423 + 1212 ;;
    - : int = 24635

    # 32.34 +. 232.22 ;;
    - : float = 264.56

    # Int32.add 2323l 6023l ;;
    - : int32 = 8346l

    # Int64.add 232L 3434L ;;
    - : int64 = 3666L

    (* Simplifying Number Operators *)

    # let fun1 x y = 10 * x - 4 * y ;;
    val fun1 : int -> int -> int = <fun>

    # fun1 45 23 ;;
    - : int = 358

    # fun1 45L 23L ;;
    Error: This expression has type int64 but an expression was expected of type int

    (* Defining the function to 64 bits *)

     # let fun1L x y =
                 let (-) = Int64.sub in
                 let ( * ) = Int64.mul in
                 10L * x - 4L * y
        ;;val fun1L : int64 -> int64 -> int64 = <fun>

    # fun1L 45L 23L ;;
    - : int64 = 358L

    (* Trick Creating an Operator Module *)

    # module OP =
    struct
        module FL =
        struct
            let (+) = (+.)
            let (-) = (-.)
            let ( * ) = ( *. )
            let (/) = (/.)
        end

        module I32 =
        struct
            let (+) = Int32.add
            let (-) = Int32.sub
            let (/) = Int32.div
            let ( * ) = Int32.mul
        end

        module I64 =
        struct
            let (+) = Int64.add
            let (-) = Int64.sub
            let ( * ) = Int64.mul
            let (/) = Int64.div
        end

    end
      ;;
    module OP :
      sig
        module FL :
          sig
            val ( + ) : float -> float -> float
            val ( - ) : float -> float -> float
            val ( * ) : float -> float -> float
            val ( / ) : float -> float -> float
          end
        module I32 :
          sig
            val ( + ) : int32 -> int32 -> int32
            val ( - ) : int32 -> int32 -> int32
            val ( / ) : int32 -> int32 -> int32
            val ( * ) : int32 -> int32 -> int32
          end
        module I64 :
          sig
            val ( + ) : int64 -> int64 -> int64
            val ( - ) : int64 -> int64 -> int64
            val ( * ) : int64 -> int64 -> int64
            val ( / ) : int64 -> int64 -> int64
          end
      end
    #

(* Defined for int *)

    # let fun1 x y = 10 * x - 4 * y ;;
    val fun1 : int -> int -> int = <fun>

    # fun1 100 20 ;;
    - : int = 920

(* Defined for Int32 *)

    # let fun1_int32 x y  =
        let open OP.I32 in
        10l * x - 4l * y
    ;;
    val fun1_int32 : int32 -> int32 -> int32 = <fun>

    # fun1_int32 100l 20l ;;
    - : int32 = 920l

    (* OR for short *)

    # let fun1_int32_ x y  = OP.I32.(10l  * x - 4l * y) ;;
    val fun1_int32_ : int32 -> int32 -> int32 = <fun>

    # fun1_int32_ 100l 20l ;;
    - : int32 = 920l

(* Defined for Int64 *)

    # let fun1_int64 x y  =
            let open OP.I64 in
            10L * x - 4L * y
        ;;
    val fun1_int64 : int64 -> int64 -> int64 = <fun>

    # fun1_int64 100L 20L ;;
    - : int64 = 920L

    (* OR *)

    # let fun1_int64_ x y = OP.I64.(10L * x - 4L * y) ;;
    val fun1_int64_ : int64 -> int64 -> int64 = <fun>

(* Defined for Float *)

    # let fun1_float x y  =
                let open OP.FL in
                10. * x - 4. * y
            ;;
    val fun1_float : float -> float -> float = <fun>

    # fun1_float 100. 20. ;;
    - : float = 920.

    (* OR *)

    # let fun1_float_ x y  = OP.FL.(10.  * x - 4. * y) ;;
    val fun1_float_ : float -> float -> float = <fun>

    # fun1_float_ 100. 20. ;;
    - : float = 920.

(* Operators *)

    # (+.) ;;
    - : float -> float -> float = <fun>
    # (-.) ;;
    - : float -> float -> float = <fun>
    # (/.) ;;
    - : float -> float -> float = <fun>
    # ( *. ) ;;
    - : float -> float -> float = <fun>

     (* Power operator/ Exponentiation *)
     # ( ** ) ;;
    - : float -> float -> float = <fun>

    # List.map ( (+.) 2.323) [10.23; 3.4; 30. ; 12. ] ;;
    - : float list = [12.553; 5.723; 32.323; 14.323]

    # List.map ( ( *. ) 3.) [10.23; 3.4; 30. ; 12. ] ;;
    - : float list = [30.69; 10.2; 90.; 36.]

    # List.map (fun x -> 2. ** x ) [1. ; 2.; 3.; 4.; 5.; 6.; 7.; 8.] ;;
    - : float list = [2.; 4.; 8.; 16.; 32.; 64.; 128.; 256.]

(* Absolute Value *)

    # abs_float ;;
    - : float -> float = <fun>
    #

(* Square Root *)

    # sqrt ;;
    - : float -> float = <fun>

(* Trigonometric *)

    # sin ;;
    - : float -> float = <fun>
    # cos ;;
    - : float -> float = <fun>
    # tan ;;
    - : float -> float = <fun>
    # atan ;;
    - : float -> float = <fun>
    # atan2 ;;
    - : float -> float -> float = <fun>
    #
    # acos ;;
    - : float -> float = <fun>
    # asin ;;
    - : float -> float = <fun>
    #

(* Hyperbolic Functions *)
    # cosh ;;
    - : float -> float = <fun>
    # sinh ;;
    - : float -> float = <fun>
    # tanh ;;
    - : float -> float = <fun>
    #


(* Logarithm and exp *)
    # log ;;
    - : float -> float = <fun>
    # log10 ;;
    - : float -> float = <fun>
    # exp ;;
    - : float -> float = <fun>

    (* exp x -. 1.0, *)
    # expm1 ;;
    - : float -> float = <fun>

    (*  log(1.0 +. x)  *)
    # log1p ;;
- : float -> float = <fun>


(* Remove Decimal Part *)
    # floor ;;
    - : float -> float = <fun>
    # ceil ;;
    - : float -> float = <fun>
    # truncate ;;
    - : float -> int = <fun>
    #
    # int_of_float ;;
    - : float -> int = <fun>
    #


(* Float Constants *)

    # infinity ;;
    - : float = infinity
    #
    # neg_infinity ;;
    - : float = neg_infinity
    #

    # max_float ;;
    - : float = 1.79769313486231571e+308
    # min_float ;;
    - : float = 2.22507385850720138e-308


    # nan ;;
    - : float = nan
    #

    # 1. /. 0. ;;
    - : float = infinity
    #
    # -1. /. 0. ;;
    - : float = neg_infinity
    #

> let x = 34 ;;
val x : int = 34

> x ;;
- : int = 34

> let x = 10 in
  let y = 20 in
  let z = x*y in
  z - x - y
;;
- : int = 170

> let x = 10.25 in
  let y = 30.   in
  x *. y
;;
- : float = 307.5

>  let f x = 10 * x + 4 ;;
val f : int -> int = <fun>

>  f 4 ;;
- : int = 44

>  f 5 ;;
- : int = 54
>

> let f (x, y) = x +  y ;;
val f : int * int -> int = <fun>

> f (2, 5) ;;
- : int = 7

> f (10, 5) ;;
- : int = 15


> let add_floats x y = x +. y ;;
val add_floats : float -> float -> float = <fun>

> add_floats 10. 50.343 ;;
- : float = 60.343


> let a_complex_function x y =
    let a = 10 * x in
    let b = 5 * y + x in
    a + b
;;
val a_complex_function : int -> int -> int = <fun>

(*
    a_complex_function 2 3
        a = 10 * x -->  a = 10*2 = 20
        b = 5 * 3  -->  b = 5*3 + 2 = 17
        a + b      -->  20 + 17 = 37
*)
> a_complex_function 2 3 ;;
- : int = 37


(* Function Inside functions *)

> let func1 x y =
    let ft1 x y = 10*x + y in
    let ft2 x y z = x + y - 4 * z in
    let ft3 x y = x - y in
    let z = 10 in
    (ft1 x y) + (ft2 x y z) - (ft3 x y)
;;

> func1 4 5 ;;
- : int = 15

> func1 14 5 ;;
- : int = 115

> func1 20 (-10) ;;
- : int = 130

(* Returning More than one value *)

> let g x y =  (10* x, x + y) ;;

> g 4 5 ;;
- : int * int = (40, 9)

> let func1 (x:int) (y:float) : float = (float_of_int x) +. y ;;
val func1 : int -> float -> float = <fun>

> func1 10 2.334 ;;
- : float = 12.334


> let func2 (xy: (int * int)) : int  = (fst xy) + (snd xy) ;;
val func2 : int * int -> int = <fun

> func2 (5, 6) ;;
- : int = 11

> let show (x:float) = Printf.printf "%.3f" x ;;
val show : float -> unit = <fun>

> show 3.232 ;;
3.232- : unit = ()


> let showxy (x, y) : unit = Printf.printf "%.3f\n" (x +. y) ;;
val showxy : float * float -> unit = <fun

> showxy (32.323, 100.232) ;;
132.555
- : unit = ()


> let double_list (list_of_floats : float list) : float list =
    List.map (fun x -> 2.0 *. x) list_of_floats ;;
val double_list : float list -> float list = <fun>

> double_list [1. ; 2. ; 3. ; 4. ; 5. ] ;;
- : float list = [2.; 4.; 6.; 8.; 10.]

> let func2' : (int * int) -> int = fun (a, b) -> a + b ;;
val func2' : int * int -> int = <fun>

> func2' (5, 6) ;;
- : int = 11

> let showxy' : float * float -> unit = fun (x, y) ->
   Printf.printf "%.3f\n" (x +. y) ;;

> showxy' (23.3, 5.342021321) ;;
28.642
- : unit = ()

> let apply_to_fst f (x, y) = (f x, y) ;;
val apply_to_fst : ('a -> 'b) -> 'a * 'c -> 'b * 'c = <fun>

let apply_to_fst2 : ('a -> 'c) -> 'a * 'b  -> 'c * 'b =
    fun f (x, y) ->  (f x, y)

> let f x = x + 10 ;;
val f : int -> int = <fun>

> apply_to_fst f (10, "hello world") ;;
- : int * string = (20, "hello world")

> apply_to_fst2 f (10, "hello world") ;;
- : int * string = (20, "hello world")

> type tuple_of_int = int * int ;;
type tuple_of_int = int * int

> type func_float_to_string = float -> string ;;
type func_float_to_string = float -> string


> type func_tuple_of_ints_to_float = int * int -> float ;;
type func_tuple_of_ints_to_float = int * int -> float

> let x: tuple_of_int = (10, 4) ;;
val x : tuple_of_int = (10, 4)

> let f : func_float_to_string = fun x -> "x = " ^ (string_of_float x) ;;
val f : func_float_to_string = <fun>

> f 2.23 ;;
- : string = "x = 2.23"

> let funct : tuple_of_int -> int = fun (x, y) -> x + y ;;
val funct : tuple_of_int -> int = <fun>

> funct (10, 100) ;;
- : int = 11

> let fxy : func_tuple_of_ints_to_float =
    fun (x, y) -> 10.4 *. (float_of_int x) -. 3.5 *. (float_of_int y) ;;
val fxy : func_tuple_of_ints_to_float = <fun>

> fxy ;;
- : func_tuple_of_ints_to_float = <fun>

> fxy (10, 5) ;;
- : float = 86.5


> type list_of_float = float list ;;
type list_of_float = float list

> let double (xs: list_of_float) : list_of_float = List.map (fun x -> 2.0 *. x) xs ;;
val double : list_of_float -> list_of_float = <fun>

> double [1. ; 2. ; 3. ; 4. ; 5. ] ;;
- : list_of_float = [2.; 4.; 6.; 8.; 10.]

> double ;;
- : list_of_float -> list_of_float = <fun>

> let double2 : list_of_float -> list_of_float =
  fun xs -> List.map (fun x -> 2.0 *. x) xs ;;
val double2 : list_of_float -> list_of_float = <fun>

> double2 ;;
- : list_of_float -> list_of_float = <fun>

> double2 [1. ; 2. ; 3. ; 4. ; 5. ] ;;
- : list_of_float = [2.; 4.; 6.; 8.; 10.]

> let f1 ~x ~y = 10* x - y ;;
val f1 : x:int -> y:int -> int = <fun>

> f1 ;;
- : x:int -> y:int -> int = <fun>

> f1 4 5 ;;
- : int = 35

> f1 20 15 ;;
- : int = 185

(* Currying Funcctions with named parameters *)
> f1 20 ;;
Error: The function applied to this argument has type x:int -> y:int -> int                      This argument cannot be applied without label

> f1 ~x:20 ;;
- : y:int -> int = <fun>

> let f1_20 = f1 ~x:20 ;;
val f1_20 : y:int -> int = <fun>

> f1_20 10 ;;
- : int = 190

> f1_20 40 ;;
- : int = 160

> List.map f1_20 [1; 2; 10; 20; 30] ;;
Error: This expression has type y:int -> int but an expression was expected of type 'a -> 'b

> List.map (fun y -> f1_20 y) [1; 2; 10; 20; 30] ;;
- : int list = [199; 198; 190; 180; 170]

> let show_msg x ~msg () = Printf.printf "%s = %d" msg x ;;
val show_msg : int -> msg:string -> unit -> unit = <fun>

> show_msg 2 "Hello world" () ;;
Hello world = 2- : unit = ()

> show_msg 20  ;;
- : msg:string -> unit -> unit = <fun>

> let f = show_msg 20 ;;
val f : msg:string -> unit -> unit = <fun>

> f "x" ();;
x = 20- : unit = ()

> f "y" () ;;
y = 20- : unit = ()

> List.iter f ["x" ; "y" ; "z" ; "w"] ;;
Error: This expression has type msg:string -> unit -> unit
but an expression was expected of type 'a -> unit

> List.iter (fun msg -> f msg ()) ["x" ; "y" ; "z" ; "w"] ;;
x = 20y = 20z = 20w = 20- : unit = ()

(*
    If the parameter x is not given, x will be set to 100
*)
> let f ?(x = 100)  y = 10*x - 5*y ;;
val add : ?x:int -> int -> int = <fun>

> f ;;
- : ?x:int -> int -> int = <fun>

(*
    f 20 ==> (10*x - 5*y) 100 20
             (10 * 10 - 5 * 20 )
             (1000 - 100)
             900
 *)
> f 20 ;;
- : int = 900


(*
    f 60 ==> (10*x - 5*y) 100 60
             (10*100 - 5*60)
             (1000 - 300)
             700
*)
> f 60 ;;
- : int = 700

> List.map f [10; 20; 30; 40; 50] ;;
- : int list = [950; 900; 850; 800; 750]


> f ~x:40 20 ;;
- : int = 300


> f ~x:50 20 ;;
- : int = 400

> f ~x:40 ;;
- : int -> int = <fun>

> let f_x40  = f ~x:40 ;;
val f_x40 : int -> int = <fun>

> List.map f_x40 [10; 20; 30; 40; 50] ;;
- : int list = [350; 300; 250; 200; 150]

> List.map (f ~x: 40) [10; 20; 30; 40; 50] ;;
- : int list = [350; 300; 250; 200; 150]


> let rectangle_area ?(width = 30) ~height = width*height ;;
val rectangle_area : ?width:int -> height:int -> int = <fun>

> rectangle_area 20 ;;
- : int = 600

> rectangle_area 30 ;;
- : int = 900

> List.map rectangle_area [10; 20; 30; 40; 50] ;;
Error: This expression has type ?width:int -> height:int -> int
but an expression was expected of type 'a -> 'b

> List.map (fun h -> rectangle_area h ) [10; 20; 30; 40; 50] ;;
- : int list = [300; 600; 900; 1200; 1500]

> rectangle_area ~width: 200 ;;
- : height:int -> int = <fun>

>: rectangle_area ~width: 200 ~height: 20 ;;
- : int = 4000

> List.map (fun h -> rectangle_area ~height:h ~width:30 )
[10; 20; 30; 40; 50] ;;
- : int list = [300; 600; 900; 1200; 1500]

(* Composition Operator *)
let (<<) f g x = f (g x) ;;

(* F# Piping Composition Operator *)
let (>>) f g x = g( f x) ;;

(* F# Piping Operator *)
let (|>) x f  = f x ;;

let (<|) f x = f x ;;

>  let f1 x = 10 + x ;;
val f1 : int -> int = <fun>

>  let f2 x = 2 * x ;;
val f2 : int -> int = <fun>

>  let f3 x = x - 8 ;;
val f3 : int -> int = <fun>

>  f1( f2 (f3 10)) ;;
- : int = 14
>

>  (f1 << f2 << f3) 10 ;;
- : int = 14
>


>  let f = f1 << f2 << f3 ;;
val f : int -> int = <fun>
>  f 10 ;;
- : int = 14
>  f 20 ;;
- : int = 34
>

>
  10 |> f3 |> f2 |> f1 ;;
- : int = 14

>
  10 |> f3 ;;
- : int = 2

>  2 |> f2 ;;
- : int = 4

>  4 |> f1 ;;
- : int = 14
>


> 10 |> (f3 >> f2 >> f1) ;;
- : int = 14

> f3 >> f2 >> f1  <| 10 ;;
- : int = 14


> let f = f3 >> f2 >> f1 ;;
val f : int -> int = <fun>

> f 10 ;;
- : int = 14

fun x -> x+1                       : int -> int
fun x -> x +. 1.0                  : float -> float
fun x -> x ^ x                     : string -> string
fun (x,y) -> x + y                 : (int * int) -> int
fun (x,y) -> (y,x)                 : ('a*'b) -> ('b*'a)
fun x y -> (x,y)                   : 'a -> 'b -> ('a*'b)
fun x y z -> (x,y,z)               : 'a -> 'b -> 'c -> ('a*'b*'c)

> fun x -> x+1  ;;
- : int -> int = <fun>

> (fun x -> x+1) 10 ;;
- : int = 11

> let f = fun x -> x+1 ;;
val f : int -> int = <fun>

> f 10 ;;
- : int = 11

> List.map (fun x -> x+1) [1; 2; 3; 4; 5 ] ;;
- : int list = [2; 3; 4; 5; 6]

> 


> (fun x y z ->  10 * x + 4 * z - 3 * x * y) 1 ;;
- : int -> int -> int = <fun>

(* x = 1 *) 
> (fun x y z ->  10 * x + 4 * z - 3 * x * y) 1 ;; 
- : int -> int -> int = <fun>

(* x = 1 y = 2 *) 
> (fun x y z ->  10 * x + 4 * z - 3 * x * y) 1 2 ;;  
- : int -> int = <fun>

(* x = 1 y = 2  z = 3 *) 
> (fun x y z ->  10 * x + 4 * z - 3 * x * y) 1 2 3 ;; 
- : int = 16 

(* Partial Evaluation *)
(*----------------------*)

> let f = fun x y z ->  10 * x + 4 * z - 3 * x * y ;;
val f : int -> int -> int -> int = <fun>

> (f 1) ;;
- : int -> int -> int = <fun>

> ((f 1) 2) ;;
- : int -> int = <fun>

> (((f 1) 2) 3) ;;
- : int = 16

> f 1 2 3 ;;
- : int = 16


(* x= ?, y=?, z=3 The variables x and y varies *)
> List.map (fun (x, y) -> f x y 3) [(1, 2); (3, 4); (5, 6)]  ;;
- : int list = [16; 6; -28]


(* x= ?, y=2, z=? The variables x and z varies *) 
> List.map (fun (x, z) -> f x 2 z) [(1, 2); (3, 4); (5, 6)]  ;;
- : int list = [12; 28; 44]


(* All variables varies *)
> List.map (fun (x, y, z) -> f x y z) [(1, 2, 3); (2, 3, 1); (3, 4, 5)] ;;
- : int list = [16; 6; 14]

(** Filtering                      *)
(**--------------------------------*)

> List.filter (fun x -> x > 5) [1; 2; 3; -3; 10; 4; 50] ;;
- : int list = [10; 50]

> List.filter (fun (x, y) -> x + y > 10) [(-10, 30); (5, 4); (12, -8); (9, 8)] ;;
- : (int * int) list = [(-10, 30); (9, 8)]


> [(-10, 30); (5, 4); (12, -8); (9, 8)]
|> List.filter (fun (x, y) -> x + y > 10)
;;
- : (int * int) list = [(-10, 30); (9, 8)]

(** Filters and maps be combined with the (|>) pipelining operator to process data *)

> [(-10, 30); (5, 4); (12, -8); (9, 8)]
|> List.filter (fun (x, y) -> x + y > 10)
|> List.map (fun (x, y) -> 4 * x + 3 * y) 
;;
- : int list = [50; 60]

    # let rec factorial1 n =
        match n with
        | 0 -> 1
        | 1 -> 0
        | k -> k * factorial1 (k - 1)
    ;;
    val factorial1 : int -> int = <fun>

    # let rec factorial2 = function
        | 0     -> 1
        | 1     -> 1
        | n     -> n * factorial2 (n - 1)
    ;;
    val factorial2 : int -> int = <fun>

    # factorial1 5 ;;
    - : int = 120

     # factorial2 5 ;;
    - : int = 120

    # let rec map f xs =   match xs with
        | []        ->  []
        | h::tl     ->  (f h)::(map f tl)
    ;;
    val map : ('a -> 'b) -> 'a list -> 'b list = <fun>

    # map ((+) 5) [10; 20; 25 ; 9] ;;
    - : int list = [15; 25; 30; 14]

    # let rec sumlist = function
        | []        -> 0
        | [a]       -> a
        | (hd::tl)  -> hd + sumlist tl
    ;;
    val sumlist : int list -> int = <fun>

    # sumlist [1; 2; 4; 5; 6; 7; 8; 9] ;;
    - : int = 42

    # let rec prodlist = function
        | []        -> 1
        | [a]       -> a
        | (hd::tl)  -> hd * prodlist tl
    ;;
    val prodlist : int list -> int = <fun>

    # prodlist [1 ; 2; 3; 4; 5; 6 ] ;;
    - : int = 720

    # let rec filter f xs = match xs with
        | []        -> []
        | h::tl     -> if f h
                       then h::(filter f tl)
                       else filter f tl

    ;;

     # filter (fun x -> x < 10) [1; 2; 10; 20; 4; 6; 15] ;;
    - : int list = [1; 2; 4; 6]


    # let rec take n xs =
        match (n, xs) with
        | (0, _    ) -> []
        | (_, []   ) -> []
        | (k, h::tl) -> k::(take (n-1) tl)
    ;;val take : int -> 'a list -> int list = <fun>

    # take 3 [1; 2; 10; 20; 4; 6; 15] ;;
    - : int list = [3; 2; 1]
    # take 20 [1; 2; 10; 20; 4; 6; 15] ;;
    - : int list = [20; 19; 18; 17; 16; 15; 14]


    # let rec drop n xs =
        if n < 0 then failwith "n negative"
        else
            match (n, xs) with
            | (0, _ )    ->  xs
            | (_, [])    ->  []
            | (k, h::tl) ->  drop (k-1) tl
    ;;val drop : int -> 'a list -> 'a list = <fun>

    # drop (-10)  [1; 2; 10; 20; 4; 6; 15] ;;
    Exception: Failure "n negative".

    # drop 10 [] ;;
    - : 'a list = []

    # drop 0 [1; 2; 10; 20; 4; 6; 15] ;;
    - : int list = [1; 2; 10; 20; 4; 6; 15]

    # drop 5 [1; 2; 10; 20; 4; 6; 15] ;;
    - : int list = [6; 15]

    # drop 25 [1; 2; 10; 20; 4; 6; 15] ;;
    - : int list = []

(*

    Haskell Function:
    foldl1 : ( a -> a -> a ) -> [a] -> [a]

    > foldl1 (\x y -> 10*x + y) [1, 2, 3, 4, 5]
    12345

    foldl1 f  [1, 2, 3, 4, 5]  =
    f 5 (f 4 (f 3 (f 1 2)))

    foldl f [x0, x1, x2, x3, x4, x5 ... ] =

    f xn (f xn-1 (f xn-2 ... (f x3 (f x2 (f x1 x0))))) ....

    From: http://en.wikipedia.org/wiki/Fold_%28higher-order_function%29
*)

    let rec foldl1 f xs =
        match xs with
        | []            -> failwith "Empty list"
        | [x]           -> x
        | (x::y::tl)    -> foldl1 f (f x y :: tl)
    ;;

    # foldl1 (fun x y -> 10*x + y) [1; 2; 3; 4; 5] ;;
    - : int = 12345


    # let rec foldr1 f xs =
        match xs with
        | []        -> failwith "Empty list"
        | [x]       -> x
        | x::tl     -> f x (foldr1 f tl)
    ;;
    val foldr1 : ('a -> 'a -> 'a) -> 'a list -> 'a = <fun>

    # foldr1 (fun x y -> x + 10*y) [1; 2; 3; 4; 5; 6] ;;
    - : int = 654321

    # let rec foldl f acc xs =
        match xs with
        | []     -> acc
        | x::tl  -> foldl f (f acc x) tl
    ;;

    # foldl (fun x y -> 10*x + y) 0  [1; 2; 3; 4; 5; 6] ;;
    - : int = 123456

    # let rec foldr f acc xs =
        match xs with
        | []    -> acc
        | x::tl -> f x (foldr f acc tl)
    ;;
    val foldr : ('a -> 'b -> 'b) -> 'b -> 'a list -> 'b = <fun>

    # foldr (fun x y -> x + 10*y) 0  [1; 2; 3; 4; 5; 6] ;;
    - : int = 654321


    # let rec range start stop step =
        if start > stop
        then []
        else start::(range  (start + step) stop step )
    ;;
    val range : int -> int -> int -> int list = <fun>

    # range 0 30 1 ;;
    - : 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]

    # range 0 100 10 ;;
    - : int list = [0; 10; 20; 30; 40; 50; 60; 70; 80; 90; 100]

    # range (-100) 100 10 ;;
    - : int list = [-100; -90; -80; -70; -60; -50; -40; -30; -20;
    -10; 0; 10; 20; 30; 40; 50; 60; 70; 80; 90; 100]

(** Declare a reference *)

    #  let x = ref 0 ;;
    val x : int ref = {contents = 0}
    # 

(** Get the value of a reference *)

    # !x ;;
    - : int = 0
    # 

(** Set the value of a reference *)

    # (:=) ;;
    - : 'a ref -> 'a -> unit = <fun>
    # 

    # x := 100 ;;
    - : unit = ()
    # 

(** Update a reference *)

    #  x:= !x + 100 ;;
    - : unit = ()

    # x ;;
    - : int ref = {contents = 100}
    # 

(** A reference can be accessed inside a function *)


    # let x = ref 10 ;;
    val x : int ref = {contents = 10}
    # 

    let add_10_to_x () = 
              x := !x + 10 
            ;;
    val add_10_to_x : unit -> unit = <fun>
    # 

    #  add_10_to_x () ;;
    - : unit = ()
    # x ;;
    - : int ref = {contents = 20}

    # add_10_to_x () ;;
    - : unit = ()
    # x ;;
    - : int ref = {contents = 30}
    # 

(** Functions that operates references *)

    # let y = ref 10 ;;
    val y : int ref = {contents = 10}
    # 

    #  let get_ref x = !x ;;
    val get_ref : 'a ref -> 'a = <fun>

    #  get_ref y ;;
    - : int = 10
    #     

    # let set_ref r new_value = 
          r := new_value 
      ;;
    val set_ref : 'a ref -> 'a -> unit = <fun>
    # 

    #  set_ref y 100 ;;
    - : unit = ()
    # y ;;
    - : int ref = {contents = 100}
    # 

    #  let add_x_to_ref r x = 
         r := !r + x 
      ;;
    val add_x_to_ref : int ref -> int -> unit = <fun>
    # 


    #  add_x_to_ref y 200 ;;
    - : unit = ()

    # y ;;
    - : int ref = {contents = 300}
    # 

    (* 
        y <-- y + 1 + 2 + 3 + 4 + 5 + 6 
    *)
    # List.iter (add_x_to_ref y) [1; 2; 3; 4; 5; 6] ;;
    - : unit = ()
    # y ;;
    - : int ref = {contents = 321}
    # 


    (*******************)

    # let y = ref 10 ;;
    val y : int ref = {contents = 10}
    #     

    #  let add_10_to_ref r =
         r := !r + 10 
      ;;
    val add_10_to_ref : int ref -> unit = <fun>
    # 

    # add_10_to_ref y ;;
    - : unit = ()
    # y ;;
    - : int ref = {contents = 20}
    # 

    #  add_10_to_ref y ;;
    - : unit = ()
    # y ;;
    - : int ref = {contents = 30}
    # 

    (*********************************)

    #  let swap_ref a b = 
          let c = !a in
            a := !b ;
            b := c
      ;;
    val swap_ref : 'a ref -> 'a ref -> unit = <fun>
    # 

    #  let x = ref 10 ;;
    val x : int ref = {contents = 10}
    # let y = ref 20 ;;
    val y : int ref = {contents = 20}
    # 
      swap_ref x y ;;
    - : unit = ()
    # x ;;
    - : int ref = {contents = 20}
    # y ;;
    - : int ref = {contents = 10}
    # 

(** Capturing references with closures *)


    let make_counter () = 
              let i = ref 0 in
              fun () ->
                i:= !i + 1 ;
                !i
                ;;
    val make_counter : unit -> unit -> int = <fun>
    # 


    # let counter1 = make_counter () ;;
    val counter1 : unit -> int = <fun>
    # 
      counter1 () ;;
    - : int = 1
    # counter1 () ;;
    - : int = 2
    # counter1 () ;;
    - : int = 3
    # counter1 () ;;
    - : int = 4
    # 

    #  let counter2 = make_counter () ;;
    val counter2 : unit -> int = <fun>
    # counter2 () ;;
    - : int = 1
    # counter2 () ;;
    - : int = 2
    # counter1 () ;;
    - : int = 5
    #         

(** Miscellaneous *)


    # let lst = ref [1.0; 2.0; 3.0] ;;
    val lst : float list ref = {contents = [1.; 2.; 3.]}

    # !lst ;;
    - : float list = [1.; 2.; 3.]

    # List.nth (!lst) 0 ;;
    - : float = 1.
    # List.nth (!lst) 2 ;;
    - : float = 3.
    # 

    # List.map (fun x -> x *. 2.) !lst ;;
    - : float list = [2.; 4.; 6.]
    # 

    # lst := List.map (fun x -> x *. 2.) !lst ;;
    - : unit = ()
    # lst ;;
    - : float list ref = {contents = [2.; 4.; 6.]}
    # 

    #  lst := !lst @ [3.23; 832.23; 90.23] ;;
    - : unit = ()
    # lst ;;
    - : float list ref = {contents = [2.; 4.; 6.; 3.23; 832.23; 90.23]}
    #

let test x =
if x > 0
then print_string "x is positive"
else print_string "x is negative"
;;


val test : int -> unit = <fun>

> test 10 ;;
x is positive- : unit = ()

> test (-10) ;;
x is negative- : unit = ()


> let sign x =
  if x = 0
    then 0
  else if x > 0
       then 1
       else (-1)
;;
val sign : int -> int = <fun>

> List.map sign [1; -1; 0; 2; 3] ;;
- : int list = [1; -1; 0; 1; 1]

>

> for i = 0 to 5 do Printf.printf "= %i\n" i  done ;;
= 0
= 1
= 2
= 3
= 4
= 5
- : unit = ()

> for i = 10 downto 1 do
  Printf.printf "%d .. " i
done;
  ;;
10 .. 9 .. 8 .. 7 .. 6 .. 5 .. 4 .. 3 .. 2 .. 1 .. - : unit = ()

> let j = ref 5 ;;
val j : int ref = {contents = 5}

> while !j > 0 do Printf.printf "x = %d\n" !j ; j := !j -1 done ;;
x = 5
x = 4
x = 3
x = 2
x = 1
- : unit = ()

[] : 'a list                    (*     Nil *)
:: : 'a -> 'a list -> 'a list   (* :: Cons *)

>   23::[] ;;
- : int list = [23]
>  12::23::[] ;;
- : int list = [12; 23]
>  34::12::23::[] ;;
- : int list = [34; 12; 23]

>  1::[2; 34; 55] ;;
- : int list = [1; 2; 34; 55]
>

>  []::[] ;;
- : 'a list list = [[]]
>  []::[]::[] ;;
- : 'a list list = [[]; []]

(* Concatenate Lists *)
> (@) ;;
- : 'a list -> 'a list -> 'a list = <fun>
> [1; 2; 3; 4; 5] @ [5; 6; 8] ;;
- : int list = [1; 2; 3; 4; 5; 5; 6; 8]
>

(* First element of a list / head of the list *)
> List.hd [1 ; 2; 3; 4 ; 6 ; 9] ;;
- : int = 1

(* Remove first Element of a list/ tail of the list *)
  List.tl [1 ; 2; 3; 4; 5; 6; 9] ;;
- : int list = [2; 3; 4; 5; 6; 9]

>  sum [1 ; 2; 3; 4; 5; 6; 7] ;;
- : int = 28

(* Reverse List *)
>  List.rev [1; 2; 3; 4] ;;
- : int list = [4; 3; 2; 1]

(* Pick Element *)
> List.nth [0; 1; 2; 3; 4 ] 0 ;;
- : int = 0
> List.nth [0; 1; 2; 3; 4 ] 1 ;;
- : int = 1
> List.nth [0; 1; 2; 3; 4 ] 2 ;;
- : int = 2
> List.nth [0; 1; 2; 3; 4 ] 3 ;;
- : int = 3

(* List Lenght *)
> List.length [0; 1; 2; 3; 4 ] ;;
- : int = 5
> List.length [0; 1; 2] ;;
- : int = 3

(* Combine - Equivalent to Haskell zip *)
> List.combine ;;
- : 'a list -> 'b list -> ('a * 'b) list = <fun>

> List.combine [1; 2; 3] ['a'; 'b'; 'c' ] ;;
- : (int * char) list = [(1, 'a'); (2, 'b'); (3, 'c')]

> List.combine [1; 2; 3; 5 ] ['a'; 'b'; 'c' ] ;;
Exception: Invalid_argument "List.combine".
>

(* Split - Equivalent to Haskell unzip *)

> List.split  [(1, 'a'); (2, 'b'); (3, 'c')] ;;
- : int list * char list = ([1; 2; 3], ['a'; 'b'; 'c'])
>

>  List.split  [(1, 'a'); (2, 'b'); (3, 'c')] ;;
- : int list * char list = ([1; 2; 3], ['a'; 'b'; 'c'])
>


(* Equivalent to Haskell (++) *)

> List.append [0; 2; 3; 5; 6 ] [1; 2; 6] ;;
- : int list = [0; 2; 3; 5; 6; 1; 2; 6]

(* Find *)

> List.find  (fun x -> x < 10) [1; 2 ; 3; 45] ;;
- : int = 1

> List.find  (fun x -> x > 10) [1; 2 ; 3; 45] ;;
- : int = 45

>
> List.find  (fun x -> x > 10) [1; 2 ; 3] ;;
Exception: Not_found.
>

> List.find  (fun x -> x > 100) [1; 2 ; 3; 45] ;;
Exception: Not_found.


> List.find_all  (fun x -> x > 10) [-10; 20 ; 3; 12; 100; 4; 35] ;;
- : int list = [20; 12; 100; 35]

> List.exists ;;
- : ('a -> bool) -> 'a list -> bool = <fun>
> List.exists ((==) 10) [1; 2; 30; 50 ; 3];;
- : bool = false
> List.exists ((==) 10) [1; 2; 30; 10 ; 50 ; 3];;
- : bool = true

> List.for_all2 (>=) [1;2;3] [2;3;4];;
- : bool = false
> List.exists2 (<) [1;2;3] [1;2;3] ;;
- : bool = false
>  List.exists2 (<) [1;2;0] [1;2;3] ;;
- : bool = true
>  List.exists2 (<) [1;2;0] [1;2];;
Exception: Invalid_argument "List.exists2".
>

> List.assoc 3 [(0, "a"); (1, "b"); (2, "c"); (3, "d")] ;;
- : string = "d"
> List.assoc 0 [(0, "a"); (1, "b"); (2, "c"); (3, "d")] ;;
- : string = "a"
> List.assoc 5 [(0, "a"); (1, "b"); (2, "c"); (3, "d")] ;;
Exception: Not_found.
>

> List.mem_assoc 5 [(0, "a"); (1, "b"); (2, "c"); (3, "d")] ;;
- : bool = false
> List.mem_assoc 3 [(0, "a"); (1, "b"); (2, "c"); (3, "d")] ;;
- : bool = true
> List.mem_assoc 2 [(0, "a"); (1, "b"); (2, "c"); (3, "d")] ;;
- : bool = true
>

> List.remove_assoc 0 [0,"a"; 1,"b"; 2,"c"; 3,"d"];;
- : (int * string) list = [(1, "b"); (2, "c"); (3, "d")]



(* Partition *)

> List.partition ;;
- : ('a -> bool) -> 'a list -> 'a list * 'a list = <fun>
>
> List.partition   (fun x -> x > 10) [-10; 20 ; 3; 12; 100; 4; 35] ;;
- : int list * int list = ([20; 12; 100; 35], [-10; 3; 4])


(* Flatten  *)

> List.flatten ;;
- : 'a list list -> 'a list = <fun>
>

> List.flatten [[1]; [2; 4] ; [6; 90; 100] ; []] ;;
- : int list = [1; 2; 4; 6; 90; 100]
>


(*      MAP         *)
(*------------------*)

> List.map ;;
- : ('a -> 'b) -> 'a list -> 'b list = <fun>
>
> List.map (( *) 10 )  [-10 ; 20 ; 5 ; 50; 100; 3 ] ;;
- : int list = [-100; 200; 50; 500; 1000; 30]

> List.map ((+) 10) [-10 ; 20 ; 5 ; 50; 100; 3 ] ;;
- : int list = [0; 30; 15; 60; 110; 13]
>

> let f x = 10 * x - 5 ;;
val f : int -> int = <fun>
> List.map f  [-10 ; 20 ; 5 ; 50; 100; 3 ] ;;
- : int list = [-105; 195; 45; 495; 995; 25]
>

> List.map (fun x -> 10.5 *. x -. 4. ) [2. ; 3. ; 5. ; 10. ; 20. ];;
- : float list = [17.; 27.5; 48.5; 101.; 206.]
>

(*      MAPI        *)
(*------------------*)
> List.mapi ;;
- : (int -> 'a -> 'b) -> 'a list -> 'b list = <fun>

> List.mapi (fun  index element -> index, element) [17.; 27.5; 48.5; 101.; 206.] ;;
- : (int * float) list = [(0, 17.); (1, 27.5); (2, 48.5); (3, 101.); (4, 206.)]


(* MAP2 / Haskell zipWith *)

> List.map2 ;;
- : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list = <fun>
>

> List.map2 (+) [10; 20; 30; 100] [15; 35; 25; 80] ;;
- : int list = [25; 55; 55; 180]

> List.map2 ( *) [10; 20; 30; 100] [15; 35; 25; 80] ;;
Warning 2: this is not the end of a comment.
- : int list = [150; 700; 750; 8000]

> List.map2 (fun x y -> (x, y)) [10; 20; 30; 100] [15; 35; 25; 80] ;;
- : (int * int) list = [(10, 15); (20, 35); (30, 25); (100, 80)]

> List.map2 (fun x y -> (x, y)) [10; 20; 30; 100] [15; 35; 25] ;;
Exception: Invalid_argument "List.map2".
>


> let fxy x y = 10*x - 4*y ;;
val fxy : int -> int -> int = <fun>
>
> List.map2 fxy [10; 20; 30; 100] [15; 35; 25; 80] ;;
- : int list = [40; 60; 200; 680]
>


(*      FILTER      *)
(*------------------*)
> List.filter ;;
- : ('a -> bool) -> 'a list -> 'a list = <fun>
>
>  List.filter ((<) 10) [-10 ; 20 ; 5 ; 50; 100; 3 ] ;;
- : int list = [20; 50; 100]
>

(*  FOLFR and FOLDL - Equivalent to Haskell foldr and foldl
 *   The fold functions are known as reduce. (i.e Python reduce (left fold))
 *)

> List.fold_right ;;
- : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b = <fun>

    (*
        f x y = x + 10* y
        foldr  f [1; 2; 3; 5; 6] 0

    Evaluation:

    (f 1 (f 2 (f 3  (f 5 (f 6 0)))))    f 6   0  = 6 + 10*0    =     6
    (f 1 (f 2 (f 3  (f 5 6))))          f 5   6  = 5 + 10*6    =     65
    (f 1 (f 2 (f 3  65)))               f 3  65  = 3 + 10*65   =    653
    (f 1 (f 2 653))                     f 2 653  = 2 + 10*653  =    6532
    (f 1 6532)                          f 1 6532 = 1 + 10*6532 =   65321
    65321
    *)
> List.fold_right (fun x y -> x + 10*y) [1; 2; 3; 5; 6] 0 ;;
- : int = 65321
>

> List.fold_left ;;
- : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a = <fun>
>
    (*
        f x y = 10*x + y
        flodl f 0 [1; 2; 3; 5; 6]

    Evaluation:

    (f (f (f ( f (f 0 1) 2 ) 3) 5) 6)     f 0    1 = 10*0    + 1   =    1
    (f (f (f ( f 1 2 ) 3) 5) 6)           f 1    2 = 10*1    + 2   =   12
    (f (f (f 12 3) 5) 6)                  f 12   3 = 10*12   + 3   =   123
    (f (f 123 5) 6)                       f 123  5 = 10*123  + 5   =  1235
    (f 1235 6)                            f 1235 6 = 10*1235 + 5   = 12356
    12356
    *)

> List.fold_left (fun x y -> 10*x +  y) 0 [1; 2; 3; 5; 6]  ;;
- : int = 12356
>

> List.fold_left (+) 0 [ 1; 2; 3; 4; 5; 6 ] ;;
- : int = 21

> List.fold_left ( *) 1 [ 1; 2; 3; 4; 5 ] ;;
Warning 2: this is not the end of a comment.
- : int = 120



(*    ITER / MAP Non Pure Functions  *)
(*-----------------------------------*)

> List.iter ;;
- : ('a -> unit) -> 'a list -> unit = <fun>
>

> List.iter (Printf.printf "= %d \n") [-10; 3; 100; 50; 5; 20] ;;
= -10
= 3
= 100
= 50
= 5
= 20
- : unit = ()
>

(* ITERI    *)

> List.iteri ;;
- : (int -> 'a -> unit) -> 'a list -> unit = <fun>

> List.iteri (Printf.printf "idendx = %d element = %d\n") [-10; 3; 100; 50; 5; 20] ;;
idendx = 0 element = -10
idendx = 1 element = 3
idendx = 2 element = 100
idendx = 3 element = 50
idendx = 4 element = 5
idendx = 5 element = 20
- : unit = ()


(* ITER2    *)
> List.iter2 ;;
- : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit = <fun>
>
> List.iter2 (Printf.printf "%s = %d\n") ["x"; "y"; "z"] [1; 2; 3 ] ;;
x = 1
y = 2
z = 3
- : unit = ()
>