Home

The Methods of a Class

   

Introduction

One of the most important aspects of a class is to perform actions. An action is performed using a  function created in the body of a class. Such a function is called a member function or method.  The fundamental formula to create a method is:

member [ this | self-identifier ].method-name([parameter(s)) = body

The creation of a method starts with member. The role of the [ this | self-identifier ] section follows the decription we gave for member variables. That section is followed by a period and the name of the method. The name should start in uppercase. If the method doesn't take parameters, add the parentheses to it. The parentheses are followed by = and the body of the method. The body is used to define what the method does.

As seen previously, to access a method outside the class, declare a variable based on the class, using a let keyword, and initialize it using the name of the class. Here are two examples:

open System
open System.Windows.Forms

type Hexagon(side) =
    let sd = side

    member this.CalculatePerimeter() = sd * 6.00
    member this.CalculateArea() = sd * sd * 3.00 * (sqrt 3.00) / 2.00

// Form: Regular Hexagon
let regularHexagon = new Form()
regularHexagon.Width  <- 260
regularHexagon.Height <- 140
regularHexagon.Text <- "Regular Hexagon"

// Label: Side
let lblSide = new Label()
lblSide.Left   <- 18
lblSide.Top    <- 19
lblSide.Width  <- 40
lblSide.Text   <- "Side:"
regularHexagon.Controls.Add lblSide

// Text Box: Side
let txtSide = new TextBox()
txtSide.Left  <- 80
txtSide.Top   <- 16
txtSide.Width <- 54
regularHexagon.Controls.Add txtSide

// Button: Calculate
let btnCalculate = new Button()
btnCalculate.Left <- 166
btnCalculate.Top  <-  16
btnCalculate.Text <- "Calculate"

// Label: Perimeter
let lblPerimeter = new Label()
lblPerimeter.Left <- 18
lblPerimeter.Top <- 48
lblPerimeter.Width <- 55
lblPerimeter.Text <- "Perimeter:"
regularHexagon.Controls.Add lblPerimeter

// Text Box: Perimeter
let txtPerimeter = new TextBox()
txtPerimeter.Left  <- 80
txtPerimeter.Top   <- 43
txtPerimeter.Width <- 80
regularHexagon.Controls.Add txtPerimeter

// Label: Area
let lblArea = new Label()
lblArea.Left  <- 18
lblArea.Top   <- 78
lblArea.Width <- 40
lblArea.Text  <- "Area:"
regularHexagon.Controls.Add lblArea

// Text Box: Area
let txtArea = new TextBox()
txtArea.Left  <- 80
txtArea.Top   <- 75
txtArea.Width <- 80
regularHexagon.Controls.Add txtArea

let btnCalculateClick e =
    let side = float txtSide.Text

    let hex = Hexagon(side)
    let perimeter = hex.CalculatePerimeter()
    let area = hex.CalculateArea()
    
    let strPerimeter = sprintf "%f" perimeter
    let strArea = sprintf "%f" area

    txtPerimeter.Text <- strPerimeter
    txtArea.Text <- strArea

btnCalculate.Click.Add btnCalculateClick
regularHexagon.Controls.Add btnCalculate

// Button: Close
let btnClose = new Button()
btnClose.Left <- 166
btnClose.Top  <- 72
btnClose.Text <- "Close"
let btnCloseClick e = regularHexagon.Close()
btnClose.Click.Add btnCloseClick
regularHexagon.Controls.Add btnClose

do
    Application.Run regularHexagon

Here is an example of executing the program:

Introduction to the Methods of a Class

Introduction to the Methods of a Class

When creating an object, you can also precede the name of the class with the new operator. Here is an example:

let btnCalculateClick e =
    let side = float txtSide.Text

    let hex = new Hexagon(side)
    let perimeter = hex.CalculatePerimeter()
    let area = hex.CalculateArea()
    
    let strPerimeter = sprintf "%0f" perimeter
    let strArea = sprintf "%f" area

    txtPerimeter.Text <- strPerimeter
    txtArea.Text <- strArea

A Method With Parameters

To perform its operation(s), a method may require one or more values that would be supplied from outside the class. As done for functions, if you are passing just one parameter, write after the name of the method. Then, in the body of the method, use the parameter as you see fit. When calling the method outside the class, make sure you specify its object and pass the appropriate number and type(s) or argument(s). Here is an example:

type HotelRoom(number, roomType, rate) =
    member this.RoomNumber = number
    member this.RoomType = roomType
    member this.DailyRate = rate
    member this.CalculateInvoice days =
        float days * rate

let room = HotelRoom(104, "Bedroom", 95.50)
let days = 3
let total = room.CalculateInvoice days

If you want to indicate the type of the parameter, include it in parentheses with : and its type. Here is an example:

type HotelRoom(number, roomType, rate) =
    member this.RoomNumber = number
    member this.RoomType = roomType
    member this.DailyRate = rate
    member this.CalculateInvoice (days : int) =
        float days * rate

let room = HotelRoom(104, "Bedroom", 95.50)
let days = 3
let total = room.CalculateInvoice days

A method can also take more than one parameter. As done for functions, make the list of parameters separated by empty spaces after the name of the method. Here is an example:

open System
open System.Windows.Forms

type HotelRoom(number, roomType, rate) =
    member this.RoomNumber = number
    member this.RoomType = roomType
    member this.DailyRate = rate
    member this.CalculateInvoice days phoneCharge discount =
        let rateByDays = (float days) * rate
        let subTotal = (float days) * rate * discount / 100.00
        rateByDays + phoneCharge + subTotal

// Form: Hotel Management
let hotelManagement = new Form()
hotelManagement.Width  <- 265
hotelManagement.Height <- 215
hotelManagement.Text <- "Hotel Management"

// Label: Room Number
let lblRoomNumber = new Label()
lblRoomNumber.Left   <- 18
lblRoomNumber.Top    <- 21
lblRoomNumber.Width  <- 80
lblRoomNumber.Text   <- "Room #:"
hotelManagement.Controls.Add lblRoomNumber

// Text Box: Room Number
let txtRoomNumber = new TextBox()
txtRoomNumber.Left  <- 105
txtRoomNumber.Top   <-  18
txtRoomNumber.Width <-  46
hotelManagement.Controls.Add txtRoomNumber

// Label: Daily Rate
let lblDailyRate = new Label()
lblDailyRate.Left   <- 18
lblDailyRate.Top    <- 47
lblDailyRate.Width  <- 80
lblDailyRate.Text   <- "Daily Rate:"
hotelManagement.Controls.Add lblDailyRate

// Text Box: Daily Rate
let txtDailyRate = new TextBox()
txtDailyRate.Left  <- 105
txtDailyRate.Top   <-  45
txtDailyRate.Width <-  75
hotelManagement.Controls.Add txtDailyRate

// Label: Days Occupied
let lblDaysOccupied = new Label()
lblDaysOccupied.Left  <- 18
lblDaysOccupied.Top   <- 73
lblDaysOccupied.Width <- 85
lblDaysOccupied.Text  <- "Days Occupied:"
hotelManagement.Controls.Add lblDaysOccupied

// Text Box: Days Occupied
let txtDaysOccupied = new TextBox()
txtDaysOccupied.Left  <- 105
txtDaysOccupied.Top   <-  70
txtDaysOccupied.Width <-  75
hotelManagement.Controls.Add txtDaysOccupied

// Label: Phone Use
let lblPhoneUse = new Label()
lblPhoneUse.Left  <-  18
lblPhoneUse.Top   <- 100
lblPhoneUse.Width <-  80
lblPhoneUse.Text  <- "Phone Use:"
hotelManagement.Controls.Add lblPhoneUse

// Text Box: Phone Use
let txtPhoneUse = new TextBox()
txtPhoneUse.Left  <- 105
txtPhoneUse.Top   <-  96
txtPhoneUse.Width <-  75
hotelManagement.Controls.Add txtPhoneUse

// Label: Amount Owed
let lblAmountOwed = new Label()
lblAmountOwed.Left  <-  18
lblAmountOwed.Top   <- 154
lblAmountOwed.Width <-  80
lblAmountOwed.Text  <- "Amount Owed:"
hotelManagement.Controls.Add lblAmountOwed

// Text Box: Amount Owed
let txtAmountOwed = new TextBox()
txtAmountOwed.Left  <- 105
txtAmountOwed.Top   <- 151
txtAmountOwed.Width <-  75
hotelManagement.Controls.Add txtAmountOwed

// Button: Calculate
let btnCalculate = new Button()
btnCalculate.Left <- 105
btnCalculate.Top  <- 122
btnCalculate.Text <- "Calculate"

let btnCalculateClick e =
    let dailyRate = float txtDailyRate.Text
    let days = float txtDaysOccupied.Text
    let phone = float txtPhoneUse.Text

    let room = HotelRoom(int txtRoomNumber.Text, "Bedroom", dailyRate)
    let total = room.CalculateInvoice days phone 0.00
    
    let strAmountOwed = sprintf "%0.02f" total
    txtAmountOwed.Text <- strAmountOwed

btnCalculate.Click.Add btnCalculateClick
hotelManagement.Controls.Add btnCalculate

do Application.Run hotelManagement

Here is an example of executing the program:

A Method With Parameters

A Method With Parameters

Like a function, a method has a body. This stats with the begin keyword and and with the end keyword. Here is an example:

type HotelRoom(number, roomType, rate) =
    member this.RoomNumber = number
    member this.RoomType = roomType
    member this.DailyRate = rate
    member this.CalculateInvoice days phoneCharge discount =
        begin
            let rateByDays = (float days) * rate
            let subTotal = (float days) * rate * discount / 100.00
            rateByDays + phoneCharge + subTotal
        end

As done for a function, when creating a method, you can specify its return type either after its parentheses or after its list of arguments. Here is an example:

type HotelRoom(number, roomType, rate) =
    member this.RoomNumber = number
    member this.RoomType = roomType
    member this.DailyRate = rate
    member this.CalculateInvoice days phoneCharge discount : float =
        begin
            let rateByDays = (float days) * rate
            let subTotal = (float days) * rate * discount / 100.00
            rateByDays + phoneCharge + subTotal
        end
     
 

Named Arguments

When calling a method, you must provide the appropriate arguments in the order their parameters appear on the method. F# provides an alternative. When calling the method, you can specify the arguments in an order of your choice. To do that, when creating the method, include its parameters in the parentheses and separate them with commas. Here is an example:

type HotelRoom() =
    member this.CalculateInvoice(days, phoneCharge, discountApplied, discountRate) =
        (float days * rate) + phoneCharge - (float days * rate * discount / 100.00)

When calling the method, instead of simply listing the values of its arguments, add the parentheses to the method call. In the parentheses, type the name of a parameter, followed by =, and followed by its value; separate them with commas. Here is an example:

type HotelRoom(number, roomType, rate) =
    member this.RoomNumber = number
    member this.RoomType = roomType
    member this.DailyRate = rate
    member this.CalculateInvoice(days, phoneCharge, discountApplied, discountRate) =
        if discountApplied = true then
            (float days * rate) + phoneCharge - (float days * rate * discountRate / 100.00)
        else
            (float days * rate) + phoneCharge

let room = HotelRoom(104, "Bedroom", 95.50)
let days = 3
let phoneUse = 12.48
let total = room.CalculateInvoice(discountApplied = true, days = 3, discountRate = 20.00, phoneCharge = 12.48)

If you decide to simply provide the arguments to the method without using the names of the parameters, you must still use the parentheses and provide the argumens in the order of their parameters.

You can use the same technique of named arguments in the parentheses of the constructor used to create an object when declaring such a variable. Here is an example:

type HotelRoom(number, roomType, rate) =
    member this.RoomNumber = number
    member this.RoomType = roomType
    member this.DailyRate = rate
    member this.CalculateInvoice(days, phoneCharge, discountRate) =
        (float days * rate) + phoneCharge - (float days * rate * discountRate / 100.00)

let room = HotelRoom(roomType = "Conference Room", rate = 98.80, number = 110)
let days = 1
let phoneUse = 0.00
let total = room.CalculateInvoice(days = 3, discountRate = 0.00, phoneCharge = 12.48)

Type Definition of a Class

 

Introduction

Class type definition consists of creating a simple class that doesn't need to process anything. The class would need only simple properties. To create or start the type definition of a class, use the type keyword followed by the name of the class and =. Here is an example:

type Employee =

The type definition of a class can use properties but those properties are created using the val keyword. Besides the name of the property, you must specify its data type. Here is an example:

type Employee =
    val FirstName : string;

Of course, you can have as many properties as you need. Here are examples:

type Employee =
    val EmployeeNumber : string
    val FirstName      : string
    val LastName       : string
    val HourlySalary   : float

A property created with the val keyword doesn't have to be defined. for this reason, it is referred to as self-implementing.

Initializing the Properties of a Type Definition

After creating a class, you must be able to declare a variable from it and access its properties outside the class. The only way you can declare a variable for a class is if the class has a constructor. This also means that the only way you can use a type definition is to add at least one constructor to it. As you may know already, the constructor is created using the new keywork followed by parentheses. If you are creating a primary constructor, leave the parentheses empty.

A constuctor for a type definition class has a body delimited with curly brackets. That body must be assigned to the constructor using the = operator. Here is an example:

type Employee =
    val EmployeeNumber : int
    val FirstName      : string
    val LastName       : string
    val HourlySalary   : float

    new() = {}

If you do this, every property of the class must be initialized in the body of the constructor. This means that every property must receive a default value, which depends on the type of the property. Here is an example:

type Employee =
    val EmployeeNumber : int
    val FirstName      : string
    val LastName       : string
    val HourlySalary   : float

    new() = { EmployeeNumber = 0; FirstName = ""; LastName = ""; HourlySalary = 0.00 }

After doing this, you can declare a variable for the class and use it as you see fit. Here is an example:

type Employee =
    val EmployeeNumber : int
    val FirstName      : string
    val LastName       : string
    val HourlySalary   : float

    new() = { EmployeeNumber = 0; FirstName = ""; LastName = ""; HourlySalary = 0.00 }

let staff = new Employee()

In the class, you can create as many constructors as you want as long as they have different signatures. Each subsequent constructor must take a parameter that corresponds to a val member. When initializing the val member variable, assign the parameter to it. If a constructor takes fewer parameters than the number of properties, the properties that are not represented in the constructor should receive default values. Here is an example:

type Employee =
    val EmployeeNumber : int
    val FirstName      : string
    val LastName       : string
    val HourlySalary   : float

    new() = { EmployeeNumber = 0; FirstName = "";
              LastName = ""; HourlySalary = 0.00 }
    new(emplNbr) = { EmployeeNumber = emplNbr; FirstName = "";
                     LastName = ""; HourlySalary = 0.00 }
    new(emplNbr, first, last, salary) = { EmployeeNumber = emplNbr; FirstName = first;
                                          LastName = last; HourlySalary = salary }

After doing this, you can access the properties outside the class after creating an object that uses the constructor that takes a value for each property. Here is an example:

type Employee =
    val EmployeeNumber : int
    val FirstName      : string
    val LastName       : string
    val HourlySalary   : float

    new() = { EmployeeNumber = 0; FirstName = "";
              LastName = ""; HourlySalary = 0.00 }
    new(emplNbr) = { EmployeeNumber = emplNbr; FirstName = "";
                     LastName = ""; HourlySalary = 0.00 }
    new(emplNbr, first, last, salary) = { EmployeeNumber = emplNbr; FirstName = first;
                                          LastName = last; HourlySalary = salary }

let staff = new Employee(972947, "William", "Snuffy", 24.75)

staff.LastName . . .

If you want to be able to change the value of a property from an inistance of the class, declare the property as mutable. Here are examples:

type Employee =
    val mutable EmployeeNumber : int
    val mutable FirstName      : string
    val mutable LastName       : string
    val mutable HourlySalary   : float

    new() = { EmployeeNumber = 0; FirstName = "";
              LastName = ""; HourlySalary = 0.00 }
    new(emplNbr) = { EmployeeNumber = emplNbr; FirstName = "";
                     LastName = ""; HourlySalary = 0.00 }
    new(emplNbr, first, last, salary) = { EmployeeNumber = emplNbr; FirstName = first;
                                          LastName = last; HourlySalary = salary }

let staff = new Employee()

staff.EmployeeNumber <- 204958
staff.FirstName <- "Jennifer"
staff.LastName <- "Jacobs"
staff.HourlySalary <- 18.85

Initializing With Default Values

An alternative to initialize a val member is to mark it as [<DefaultValue>]. The member must also be created as mutable and the class must have a primary constructor. Here is an example:

type Customer() =
    [<DefaultValue>]
    val mutable FullName : string;

You should also create a method that can be called to initialize the val member(s). Such a method should take a parameter for the (or each) val member. In the body of the method, assign the parameter to the (or each) corresponding val member. Outside the class, access the method and pass a value for the (or each) parameter(s). Here is an example:

type Customer() =
    [<DefaultValue>]
    val mutable FullName : string
    member this.Initializer(name : string) =
        this.FullName <- name

let client = new Customer()
client.Initializer("Robert Zachary Cox")
// Accessing the val member
client.FullName

In the same way, you can create as many val members as possible and include them in your method initializer.

Details on Using Classes

 

Introdudtion

The methods of a class use most of the same features as functions. For example, you can specify the data types of parameters of methods the same way. The same applies to parameters of the constructors. Here are examples:

Although the body of a method is delimited by indenting the lines of code after the = sign, you can also put the body between begin and end. Here is an example:

open System
open System.Windows.Forms

type Creator() =
    member this.Create(title) =
	begin
            let exercise = new Form()
            exercise.Text <- title

            Application.Run exercise
	end

let app = new Creator()

app.Create "Application Development Environment"

As done for a function, to specify the return type of a method, outside its parentheses, type  a colon followed by the data type. Here is an example:

type PortionDistribution(amount, ratio1, ratio2, ratio3) =
    let totalRatios = ratio1 + ratio2 + ratio3
    let eachPortion    = amount / totalRatios

    member this.GetPortion1() : float = eachPortion * ratio1

As seen for functions, if a method is not taking an argument, you can create it either with empty parentheses, the unit type inside the parentheses, or an underscore in place of the parentheses. Here are examples:

type PortionDistribution(amount, ratio1, ratio2, ratio3) =
    let totalRatios = ratio1 + ratio2 + ratio3
    let eachPortion    = amount / totalRatios

    member this.GetPortion1() : float = eachPortion * ratio1
    member this.GetPortion2 _ = eachPortion * ratio2
    member this.GetPortion3(unit) = eachPortion * ratio3

Like a function, a method has a signature, which is a combination of its name, the types of its parameters, and its return type, all separated by asterisks.

Using an Object to Produce Many Values

When you use a function that returns a value of a primitive type, the function returns a single regular value. One of the advantages of a class as opposed to a primitive type is that it can hold many values. Based on this, if a function returns an object, it makes it possible for the function to return many values. In the same way, when operations are performed on a variable that holds a primitive value, only one value can come from it. One of the advantages of a class is that an object can hold many values. Therefore, an object produced from a class makes it possible for a single object to produce many values.

In the following example, many values are passed to a constructor that behaves like a function and this causes the pseudo-function to return many values:

open System
open System.Windows.Forms

type PortionDistribution(amount, ratio1, ratio2, ratio3) =
    let totalRatios = ratio1 + ratio2 + ratio3
    let eachPortion    = amount / totalRatios

    member this.GetPortion1() : float = eachPortion * ratio1
    member this.GetPortion2() : float = eachPortion * ratio2
    member this.GetPortion3() : float = eachPortion * ratio3

// Form: Portion Distribution
let portionDistribution = new Form()
portionDistribution.Width  <- 232
portionDistribution.Height <- 268
portionDistribution.Text <- "Portion Distribution"

// Label: Allocate
let lblAllocate = new Label()
lblAllocate.Left <- 26
lblAllocate.Top  <- 21
lblAllocate.Width <- 60
lblAllocate.Text <- "Allocate:"
portionDistribution.Controls.Add(lblAllocate)

// Text Box: Amount to Allocate
let txtAmount = new TextBox()
txtAmount.Left <- 104
txtAmount.Top <- 18
txtAmount.Width <- 100
portionDistribution.Controls.Add(txtAmount)

// Label: In the ratio
let lblInTheRatio = new Label()
lblInTheRatio.Left <- 26
lblInTheRatio.Top <- 47
lblInTheRatio.Width <- 65
lblInTheRatio.Text <- "In the ratio:"
portionDistribution.Controls.Add(lblInTheRatio)

// Text Box: Ratio 1
let txtRatio1 = new TextBox()
txtRatio1.Left <- 105
txtRatio1.Top <- 44
txtRatio1.Width <- 22
portionDistribution.Controls.Add(txtRatio1)

// Label: Colon 1
let lblColon1 = new Label()
lblColon1.Left  <- 130
lblColon1.Top   <- 47
lblColon1.Width <- 10
lblColon1.Text  <- ":"
portionDistribution.Controls.Add(lblColon1)

// Text Box: Ratio 2
let txtRatio2 = new TextBox()
txtRatio2.Left  <- 142
txtRatio2.Top   <-  44
txtRatio2.Width <-  22
portionDistribution.Controls.Add(txtRatio2)

// Label: Colon 2
let lblColon2 = new Label()
lblColon2.Left  <- 168
lblColon2.Top   <- 47
lblColon2.Width <- 10
lblColon2.Text  <- ":"
portionDistribution.Controls.Add(lblColon2)

// Text Box: Ratio 3
let txtRatio3 = new TextBox()
txtRatio3.Left  <- 182
txtRatio3.Top   <-  44
txtRatio3.Width <-  22
portionDistribution.Controls.Add(txtRatio3)

// Button: Allocate
let btnAllocate = new Button()
btnAllocate.Left   <- 104
btnAllocate.Top    <-  76
btnAllocate.Width  <- 100
btnAllocate.Height <-  33
btnAllocate.Text   <- "Allocate"

// Label: Portion 1 Receives
let lblPortion1Receives = new Label()
lblPortion1Receives.Left  <-  26
lblPortion1Receives.Top   <- 124
lblPortion1Receives.Width <- 105
lblPortion1Receives.Text  <- "Portion 1 Receives:"
portionDistribution.Controls.Add(lblPortion1Receives)

// Text Box: Portion 1 Value
let txtPortion1Value = new TextBox()
txtPortion1Value.Left  <- 132
txtPortion1Value.Top   <- 121
txtPortion1Value.Width <-  72
portionDistribution.Controls.Add(txtPortion1Value)

// Label: Portion 2 Receives
let lblPortion2Receives = new Label()
lblPortion2Receives.Left  <-  26
lblPortion2Receives.Top   <- 150
lblPortion2Receives.Width <- 105
lblPortion2Receives.Text  <- "Portion 2 Receives:"
portionDistribution.Controls.Add(lblPortion2Receives)

let txtPortion2Value = new TextBox()
txtPortion2Value.Left  <- 132
txtPortion2Value.Top   <- 147
txtPortion2Value.Width <-  72
portionDistribution.Controls.Add(txtPortion2Value)

// Label: Portion 3 Receives
let lblPortion3Receives = new Label()
lblPortion3Receives.Left  <-  26
lblPortion3Receives.Top   <- 176
lblPortion3Receives.Width <- 105
lblPortion3Receives.Text  <- "Portion 3 Receives:"
portionDistribution.Controls.Add(lblPortion3Receives)

let txtPortion3Value = new TextBox()
txtPortion3Value.Left  <- 132
txtPortion3Value.Top   <- 173
txtPortion3Value.Width <-  72
portionDistribution.Controls.Add(txtPortion3Value)

// Button: Close
let btnClose = new Button()
btnClose.Left  <- 132
btnClose.Top   <- 206
btnClose.Width <- 72
btnClose.Text  <- "Close"

let btnAllocateClick e =
    let amount : float = float txtAmount.Text
    let ratio1 : float = float txtRatio1.Text
    let ratio2 : float = float txtRatio2.Text
    let ratio3 : float = float txtRatio3.Text

    let portions = new PortionDistribution(amount, ratio1, ratio2, ratio3)
    let portion1 = portions.GetPortion1()
    let portion2 = portions.GetPortion2()
    let portion3 = portions.GetPortion3()

    let strPortion1 = sprintf "%g" portion1
    let strPortion2 = sprintf "%g" portion2
    let strPortion3 = sprintf "%g" portion3

    txtPortion1Value.Text <- strPortion1
    txtPortion2Value.Text <- strPortion2
    txtPortion3Value.Text <- strPortion3
btnAllocate.Click.Add btnAllocateClick
portionDistribution.Controls.Add btnAllocate

let btnCloseClick(e) = portionDistribution.Close()
btnClose.Click.Add btnCloseClick
portionDistribution.Controls.Add btnClose

Application.Run portionDistribution

Here is an example of executing the program:

Using an Object to Produce Many Values Using an Object to Produce Many Values

Ignoring the Return Value of a Method

As seen with functions, if you have a method that returns a value, when calling the function, if you don't want to use the return value of the function, at the end of the function call, type |> ignore.

   
   
 

Home Copyright © 2012-2015, FunctionX Home