F# DAP

Steps2.fsx

// 1 step.
type Order with
    static member NewOrder = fun orderRef -> Order.Empty (NoItems orderRef)
    
// 2 step replace "=" with "with" in the first step
type Order =
    | Empty of EmptyState
    | PaymentExpected
    | Payed
    | Cancelled
    | Completed
    
// 3 add state
type EmptyState = NoItems of OrderRef

// 4 add order Ref
type OrderRef = string

// test
> let order = Order.NewOrder "item1234";;

//5 add below first order Declaration
let addToEmptyState orderRef orderItem =
    Order.PaymentExpected {OrderRef = orderRef; UnpaidItems = [orderItem]}
    
// 6 evaluate
> let order = addToEmptyState "1234" (OrderItem "itemA");;
    
// 7 modify order
type Order =
    | Empty of EmptyState
    | PaymentExpected of PaymentExpectedState
    | Payed
    | Cancelled
    | Completed

//7 add state
type PaymentExpectedState = {OrderRef : OrderRef; UnpaidItems : OrderItem list}

//9 add OrderItem
type OrderItem = OrderItem of string

//10 Modify EmptyState type
type EmptyState with
    member x.Add = addToEmptyState

// 11 add general add method
let addOrderItemToOrder order orderItem =
    match order with
        | Empty state -> let (NoItems orderRef) = state
                         state.Add orderRef orderItem
        | PaymentExpected state -> failwith "Not implemented"

// 12 test
> let order = Order.NewOrder "1234";;
> let order = addOrderItemToOrder order (OrderItem "itemA");;

// 13 add to paymentExpected
let addToPaymentExpectedState state orderItem =
    Order.PaymentExpected {state with UnpaidItems = orderItem :: state.UnpaidItems}
    
// 14 test
> let order = Order.NewOrder "1234";;
> let order = addOrderItemToOrder order (OrderItem "itemA");;
> let (PaymentExpected s) = order;;
> let order = addToPaymentExpectedState s (OrderItem "itemB");;

// 15 augment type Payment expected
type PaymentExpectedState with
    member x.Add = addToPaymentExpectedState x

// 16 augment Add orderItem to Order
let addOrderItemToOrder order orderItem =
    match order with
        | Empty state -> let (NoItems orderRef) = state
                         state.Add orderRef orderItem
        | PaymentExpected state -> state.Add orderItem
        
// 17 add other cases not handled
 | Payed _ -> printfn "ERROR: The order is paid for"
                     order
        | Cancelled _ -> printfn "ERROR: The order is cancelled"
                         order
        | Completed _ -> printfn "ERROR: The order is completed"
                         order

// 18 attach to OrderType
type Order with
    static member NewOrder = fun orderRef -> Order.Empty (NoItems orderRef)
    member x.Add = addOrderItemToOrder x
    
    
// 19 test
> let order = Order.NewOrder "1234";;
> let order = order.Add (OrderItem "itemA");;
> let order = order.Add (OrderItem "itemB");;

// 20 remove action
let removeFromPaymentExpectedState state orderItem =
    let removedList = state.UnpaidItems |> List.filter (fun i -> i <> orderItem)
    match removedList with
        | [] -> Order.Empty (NoItems state.OrderRef)
        | _ -> Order.PaymentExpected {state with UnpaidItems = removedList}
        
// 21 modify payment expected state
type PaymentExpectedState with
    member x.Add = addToPaymentExpectedState x
    member x.Remove = removeFromPaymentExpectedState x

// 22 add helper general method remove
let removeOrderItemFromOrder order orderItem =
    match order with
        | Empty _ -> printfn "ERROR: The order is empty"
                     order
        | PaymentExpected state -> state.Remove orderItem
        | _ -> printfn "ERROR: Not applicable"
               order

// 23 modify OrderType
type Order with
    static member NewOrder = fun orderRef -> Order.Empty (NoItems orderRef)
    member x.Add = addOrderItemToOrder x
    member x.Remove = removeOrderItemFromOrder x


// 24 test
> let order = Order.NewOrder "1234";;
> let order = order.Add (OrderItem "itemA");;
> let order = order.Add (OrderItem "itemB");;
> let order = order.Remove (OrderItem "itemB");;
> let order = order.Remove (OrderItem "itemB");;
> let order = order.Remove (OrderItem "itemA");;
> let order = order.Remove (OrderItem "itemA");;

// 25 cancell
let cancelEmptyOrder (NoItems orderRef) =
    Order.Cancelled (NoAction orderRef)
 
let cancelPaymentExpectedOrder {OrderRef = orderRef; UnpaidItems = _ } =
    Order.Cancelled (NoAction orderRef)

// 26  add cancelled state
type CancelledState = NoAction of OrderRef

// 27 attach cancel methods

type EmptyState with
    member x.Add = addToEmptyState
    member x.Cancel = cancelEmptyOrder x
 
type PaymentExpectedState with
    member x.Add = addToPaymentExpectedState x
    member x.Remove = removeFromActiveState x
    member x.Cancel = cancelPaymentExpectedOrder x
    
// 28   add Cancel Order
let cancelOrder order =
    match order with
        | Empty state -> state.Cancel
        | PaymentExpected state -> state.Cancel
        | _ -> printfn "ERROR: You can cancel only Empty or Payment expected state"
               order
               
// 29 add to order type
type Order with
    static member NewOrder = fun orderRef -> Order.Empty (NoItems orderRef)
    member x.Add = addOrderItemToOrder x
    member x.Remove = removeOrderItemFromOrder x
    member x.Cancel = cancelOrder x
    
    
    
    

type Tree =
    | Tip
    | Node of int * Tree * Tree

let rec sumTree tree =
    match tree with
    | Tip -> 0
    | Node(value, left, right) ->
        value + sumTree(left) + sumTree(right)
let myTree = Node(0, Node(1, Node(2, Tip, Tip), Node(3, Tip, Tip)), Node(4, Tip, Tip))
let resultSumTree = sumTree myTree


type Expression = 
    | Number of int
    | Add of Expression * Expression
    | Multiply of Expression * Expression
    | Variable of string

let rec Evaluate (env:Map<string,int>) exp = 
    match exp with
    | Number n -> n
    | Add (x, y) -> Evaluate env x + Evaluate env y
    | Multiply (x, y) -> Evaluate env x * Evaluate env y
    | Variable id    -> env.[id]

let environment = Map.ofList [ "a", 1 ;
                               "b", 2 ;
                               "c", 3 ]

// Create an expression tree that represents
// the expression: a + 2 * b.
let expressionTree1 = Add(Variable "a", Multiply(Number 2, Variable "b"))

// Evaluate the expression a + 2 * b, given the
// table of values for the variables.
let result = Evaluate environment expressionTree1



// FSI declaration
val function1 : int -> int