logo Use SA10RAM to get 10%* Discount.
Order Now logo

Ask This Question To Be Solved By Our ExpertsGet A+ Grade Solution Guaranteed

expert
Julian RichardsonnEconomics
(5/5)

534 Answers

Hire Me
expert
Peter EllisAccounting
(5/5)

818 Answers

Hire Me
expert
StatAnalytica ExpertEducation
(5/5)

823 Answers

Hire Me
expert
Noel HaywardGeneral article writing
(5/5)

951 Answers

Hire Me
Others

you will extend the railway programming example from lecture to incorporate more validation functions and other patterns in functional design.

INSTRUCTIONS TO CANDIDATES
ANSWER ALL QUESTIONS

Overview

In this lab you will extend the railway programming example from lecture to incorporate more validation functions and other patterns in functional design.

Railway Terminology

Recall the following terms from the Railway Programming lecture:

  1. Two-track function: a two-track  function accepts a ValidationResult object as its input (which  has two tracks : Success and Failure), and produces a ValidationResult as its output. Two-track functions can be composed, because the output type of one matches the input type of

  2. Switch function: a switch function accepts a RegistrationAttempt object as input and produces a ValidationResult It is like a railroad switch : one track comes in, two tracks go out. A switch function cannot be composed with other switch functions, because its output type (two-track) does not match its input type (one-track).

  3. Bind function: the bind function wraps a switch function which normally expects a ValidationResult

  inside of a two-track function called the bind. The bind accepts a two-track ValidationResult and if

the input is on the Success track, invokes the wrapped switch function and returns its ValidationResult (which could result in either Success or Failure). If the two-track input is on the Failure track, the bind just returns Failure. Binding a switch function produces a new function that can be composed with other two-track functions, because its two-track output type now matches its two-track input.

Figure 1: Example tracks. From left to right: a two-track function; a switch function; a binding over a switch function. In each, the upper track is success and the lower is failure. The gray concrete box encapsulates the function's body .

Extensions:

We will extend these function types with new track types:

  1. One-track function: a one-track function accepts a RegistrationAttempt and returns a RegistrationAttempt. It does not do any validation; its purpose is to transform the input in some way, perhaps by lower-

casing the email address or otherwise manipulating the data to make it easier to validate later. These functions do not know how to handle Failure inputs; they can only be invoked on successful attempts. They can be composed with each other since the output type matches the input type but not with two-track functions.

  1. Bypass function: a bypass function is a switch function that wraps a one-track function. The single- track input to the switch is passed to the one-track function, and the result is reported as Success. A

dummy Failure output track is never actually used, but gives the one-track function the same shape as a swich function, so it can then be binded into a two-track function.

  1. Terminal function: a terminal function is a switch-type function that needs more parameters than just a RegistrationAttempt to do its validation. For example, to validate that an email address has not been used before, a function would need a parameter representing an existing set of user emails. A normal switch function can only take a single parameter (the registration attempt input); how then can we provide extra parameters to a switch function?

Lucky for us, F# makes this easy. If we write our terminal function such that the last  parameter is the RegistrationAttempt input expected of a switch function, then we can wrap a binding around a partial invocation of the terminal, in which we call the terminal function and provide all but the last parameter. (Therefore passing the extra information needed by the terminal.) Such a partial terminal function call can be placed into a bind operation, including the >=> operator.

 

 

Figure 2: More track types. A bypass function over a single-track function; a terminal function with an extra parameter; a binding over the same terminal function, making it two-track.

 

 

Assignment

Starting with the code given to you in the F# repository (RailwayProgramming), extend the registration validation example by following these instructions:

  1. Create a list of strings named existingAccounts containing ve distinct (but fake) email addresses, none of which contains a period or

  2. Create another list of strings named blacklistedDomains containing the values org  and throwawaymail.com .

  3. Write these validation functions:

    • A terminal function uniqueEmail, which takes a list of strings and a RegistrationAttempt as parameters, and validates that the attempt's email address is not in the list of strings. You cannot access the global list you created in step (1); you must use the parameter to the

    • A terminal function emailNotBlacklisted, which takes a list of strings and a RegistrationAttempt and validates that the domain of the email address (following the @) is not in the list of

Same rule as (a).

Both of these terminal functions can be added to your validation chain using partial invocation; simply adding >=> uniqueEmail myListOfEmails should do the trick.

  1. Write helper functions to create a bypass over a single-track function:

    • Write the function bypass, which takes a single-track function and a RegistrationAttempt as parameters, invokes the single-track function on the RegistrationAttempt, and returns the result as a Success.

 

  • Write an operator >-> by mimicking the >=> operator, except that:

    1. the second parameter is not a switch function, but a bypassFunction.

    2. the bypassFunction needs to be promoted to switch using bypass before passing it to bind. Everything else in the operator stays the same.

Related Questions

. The fundamental operations of create, read, update, and delete (CRUD) in either Python or Java

CS 340 Milestone One Guidelines and Rubric  Overview: For this assignment, you will implement the fundamental operations of create, read, update,

. Develop a program to emulate a purchase transaction at a retail store. This  program will have two classes, a LineItem class and a Transaction class

Retail Transaction Programming Project  Project Requirements:  Develop a program to emulate a purchase transaction at a retail store. This

. The following program contains five errors. Identify the errors and fix them

7COM1028   Secure Systems Programming   Referral Coursework: Secure

. Accepts the following from a user: Item Name Item Quantity Item Price Allows the user to create a file to store the sales receipt contents

Create a GUI program that:Accepts the following from a user:Item NameItem QuantityItem PriceAllows the user to create a file to store the sales receip

. The final project will encompass developing a web service using a software stack and implementing an industry-standard interface. Regardless of whether you choose to pursue application development goals as a pure developer or as a software engineer

CS 340 Final Project Guidelines and Rubric  Overview The final project will encompass developing a web service using a software stack and impleme

Get Free Quote!

288 Experts Online