Easiest way of defining and using of Global Variable

Question

"first part" &&&& fun _ ->
 let ident
"second part" &&&& fun _ ->
 ident ....

I need to use variable "ident".

I just need to pass value of variable from first part of test to second one...

I want to ask you if there is any easy way how to define and use global variable or even if you have better (and easy) idea of doing that

Keep in mind, please, that I am a beginner, so I would prefer easier ones.

Answer 1

Since this was getting out of hand for comments this is how I would do it for an example

let mutable t = 0

let first =
    t <- 1 + 1
    //other stuff

let second = 
    //can use t here and it will have a value of 2

In some cases you have to use a ref:

let t = ref 0

let first =
    t := 1 + 1
    //other stuff

let second = 
    //can use t here and it will have a value of 2 - 
    // you use "!t" to get the value

Answer 2

If you define ident at the top of your file like this :

let ident = "foo" 

// rest of your code using ident 

ident are global and you can use in the next part of your file.

EDIT :

If ident wil change in the next part of your code, use this :

let ident = ref "foo"

Answer 3

Global variables will often make your code difficult to work with - particularly if they are mutable.

Instead, consider returning the values you need to keep track of as composite values. An easy data type to start with would be a tuple:

let ``first part`` id =
    let someOtherValue = "Foo"
    someOtherValue, id + 1

This function takes an int (the current ID) as input, and returns string * int (a tuple where the first element is a string, and the second element and int) as output.

You can call it like this:

> let other, newId = ``first part`` 42;;

val other : string = "Foo"
val newId : int = 43

Notice that you can use pattern matching to immediately destructure the values into two named symbols: other and newId.

Your second function could also take an ID as input:

let ``second part`` id otherArgument =
    // use id here, if you need it
    "Bar"

You can call it like this, with the newId value from above:

> let result = ``second part`` newId "Baz";;

val result : string = "Bar"

---

If you find yourself doing this a lot, you can define a record for the purpose:

type Identifiable<'a> = { Id : int; Value : 'a }

Now you can begin to define higher-order functions to deal with such a type, such as e.g. a map function:

module Identifiable =
    let map f x = { Id = x.Id; Value = f x.Value }

    // Other functions go here...

This is a function that maps the Value of an Identifiable from one value to another, but preserves the identity.

Here's a simple example of using it:

> let original = { Id = 42; Value = "1337" };;

val original : Identifiable<string> = {Id = 42;
                                       Value = "1337";}

> let result' = original |> Identifiable.map System.Int32.Parse;;

val result' : Identifiable<int> = {Id = 42;
                                   Value = 1337;}

As you can see, it preserves the value 42, but changes the Value from a string to an int.

You can still change the ID explicitly, if you want to do that:

> let result'' = { result' with Id = 7 };;

val result'' : Identifiable<int> = {Id = 7;
                                    Value = 1337;}