How to retrieve the head and tail of a tuple in F# - f#

Question

How do I retrieve the head and tail of a tuple in F#?
For example Conj (a, b), the head is Conj, tail is (a, b).
I want to recursively run buildtree function on each parameters, put the head as Node's element, where is the map in F#?
let rec getparams = map List.head (List.tail getparams);
type Elem = Prop
type Tree = E | T of Elem * Tree * Tree
let rec buildtree vars = function
| E = head vars
| T = buildtree (getparams vars)
After updated:
open System
open Microsoft.FSharp.Reflection
// Learn more about F# at http://fsharp.net
//type Prop = {a: string; b: string}
//let Prop a b = (a, b)
type Op = Prop
type tree = E | T of Op * tree * tree
let tree x y z = (x, y, z)
type binOp = Conj | Disj | Impl
type expr =
| Prop of string
| BinOp of binOp * expr * expr
| Conj of expr * expr
| Disj of expr * expr
| Impl of expr * expr
type Prop = {a: string}
let Prop a = (a)
//type Conj = {a : Prop; b : Prop}
let Conj a b = (a, b)
//type Conj_Int = {a : Prop; b : Prop}
let Conj_Int a b = Conj a b
//type Conj_Elmin1 = {a : Conj}
let Conj_Elmin1 a = fst a
//type Conj_Elmin2 = {a : Conj}
let Conj_Elmin2 a = snd a
//type Impl = {a : Prop; b : Prop}
let Impl a b = (a b)
//type Impl_Int = {assume : Prop; b : Prop}
let Impl_Int assume b = Impl assume b
//type Impl_Elmin = {a :string; b : Impl}
let Impl_Elmin a b = if a = fst b then snd b
type Neg = {a : Prop;}
let Neg a = (a)
//type Double_Neg_Int = {a : Prop;}
let Double_Neg_Int a = Neg(Neg(a))
//type Double_Neg_Elmin = {a : Prop}
let Double_Neg_Elmin a = fst(fst(a))
//type Disj = {a : Prop; b : Prop}
let Disj a b = (a,b)
//type Disj_Int1 = {a : Prop; b : Prop}
let Disj_Int1 a b = (a b)
//type Disj_Int2 = {a : Prop; b : Prop}
let Disj_Int2 a b = (a b)
//type Disj_Elmin1 = {a : Disj}
let Disj_Elmin1 a = fst(a)
//type Disj_Elmin2 = {a : Disj}
let Disj_Elmin2 a = snd(a)
type TupleSplitter = static member splitTuple (a,b,c) = (a,(b,c))
let tupleToList t = if Microsoft.FSharp.Reflection.FSharpType.IsTuple(t.GetType()) then Some (Microsoft.FSharp.Reflection.FSharpValue.GetTupleFields t |> Array.toList) else None
let operation x = List.head(List.ofSeq(FSharpValue.GetTupleFields(x)))
let parameters x = List.tail(List.ofSeq(FSharpValue.GetTupleFields(x)))
let rec map f = function | Prop _ as t -> f t | BinOp(op, a, b) -> f(BinOp(op, map f a, map f b))
(*
let rec map f = function
| Prop _ as t -> f t | Conj(a, b) -> f(Conj(map f a, map f b))
| Disj(a, b) -> f(Disj(map f a, map f b))
| Impl(a, b) -> f(Impl(map f a, map f b))
*)
let buildtree vars expr = map (function Prop v -> Map.find v vars | expr -> expr) expr
let t = buildtree(Conj("a","b"))
how to have two type of expression Op*Tree*Tree and Op*Tree?

Answer 1

As Ankur said, you can't get head and tail of a tuple - these operations are designed for processing functional lists that have arbitrary length and cannot be define for tuples that have a length known at compile time. If you want data with arbitrary length, you should probably use tuples and pattern matching (or List.head and List.tail).
If you really need to process tuples dynamically, you can use F# reflection:
open Microsoft.FSharp.Reflection
(1,2,3)
|> FSharpValue.GetTupleFields // Get fields of tuple as an array
|> List.ofSeq // Convert array to a list
|> List.tail // Now you can process list using head/tail
However, note that reflection is generally a bit slow and it should only be used when you need it (i.e. when writing some code that is dynamic and can't be written in any other way).

Answer 2

You seem to be trying to replicate Haskell syntax and semantics in F#. Don't do that. Look at existing ML code and learn how to solve your problem idiomatically. In other words, your question is an XY problem: you're asking the wrong question.
Without knowing what problem you are trying to solve, it is difficult to answer your question but my best guess is:
type Expr =
| Prop of string
| Conj of Expr * Expr
| Disj of Expr * Expr
| Impl of Expr * Expr
let deConj = function
| Conj(a, b) -> a, b
| _ -> invalidArg "expr" "deConj"
Perhaps you want to write a map over your expr type:
let rec map f = function
| Prop _ as t -> f t
| Conj(a, b) -> f(Conj(map f a, map f b))
| Disj(a, b) -> f(Disj(map f a, map f b))
| Impl(a, b) -> f(Impl(map f a, map f b))
Another solution is to rewrite your type to factor out the operators:
type binOp = Conj | Disj | Impl
type expr =
| Prop of string
| BinOp of binOp * expr * expr
let rec map f = function
| Prop _ as t -> f t
| BinOp(op, a, b) -> f(BinOp(op, map f a, map f b))
EDIT
I am not sure what your buildtree function is supposed to do but if it is evaluating expressions then perhaps you want something like this:
let buildtree vars expr =
map (function Proj v -> Map.find v vars | expr -> expr) expr
This will map one expression to another, replacing Proj v with the corresponding expression (i.e. value of the variable v) given by vars.

Answer 3

A tuple is defined as (exp1,exp2, ... ,expn) for example (1,"2",'3').
I can't see this pattern in your code.
If you use (exp1 exp2) it means function application (apply exp2 as first argument to function exp1).
The error you see on your code is because you defined Conj as a function accepting a function as first paramenter and you passed a string ("a") instead of a function.
If your question is how to split a tuple in head and tail you can go for the dynamic approach Tomas just explained, it will work for any n-tuple but you'll lose type information.
Otherwise the strong type solution is simply based on pattern matching:
let splitTuple (a,b,c) = (a,(b,c))
// Usage
let (head,tail) = splitTuple (1,"2",'3')
And if you want to make it work for n-tuples you'll have to define one overload for each n:
type TupleSplitter =
static member splitTuple (a,b,c) = (a,(b,c))
static member splitTuple (a,b,c,d) = (a,(b,c,d))
static member splitTuple (a,b,c,d,e) = (a,(b,c,d,e))
// ... more overloads, as much as you need
// Usage
let (head,tail) = TupleSplitter.splitTuple (1,"2",'3',4.0)
// val tail : string * char * float = ("2", '3', 4.0)
// val head : int = 1