Question: Consider this type definition:

```
type ChoiceOne =
  | A 
  | B 

```

and this binding

```
let c1 = A

```

I assume the correct way to translate this into natural language would be *"the value A of type ChoiceOne is constructed and bound to the name c1"*.

Now take a look at this next type definition and binding:

```
type ChoiceTwo =
  | A of int
  | B of float

let c1 = A 1

```

I now see several ways of describing what is going on here:

1. *"the value A of type ChoiceTwo is constructed ..."* ( and what about the 1 ? )
2. *"the value 1 of type ChoiceTwo is constructed ..."* ( and what about the A ? )
3. *"the value A of type ChoiceTwo with the ( inner value ? associated value ? ... ) 1 is constructed ..."*

I guess option 3 describes the situation best, but how can I correctly designate the value 1 with respect to the (other?) value A of type ChoiceTwo ?

Answer: 
This is all splitting hairs. Nobody really cares about how exactly to say these things outside of a quiz in college, and even then, I would recommend maybe transferring to a different college :-)

But if you really want to split hairs, here we go.

In your very first example, the value `A` is not "constructed". Since it doesn't have parameters, there can be only one instance of it, and that instance always exists, so there is no need to "construct" it.
To be sure, `A` may still be referred to as a "constructor", but it's also a "value" at the same time.

In the second example, it is sometimes said that "*a value `A 1` was constructed*", but more often "*a value `A` constructed with parameter `1`*"
Here's the terminology that I use, which I believe is widely accepted, using my own example:

```ml
type MyDU =
    | A of int
    | B

```

* `A` is a case
* `A` is also a function that takes an `int` and returns a value of type `MyDU`
* Therefore, `A 1` is a value of type `MyDU`
* `B` is a case
* `B` is also a value of type `MyDU`

The only words needed here are "case", "value", "function" and "type". Don't use the word "construct". In general, when talking about F# code, if you can accurately replace any words that you use with the ones that I recommend, then do so!