Seven Languages In Seven Weeks: Scala - Day 2

// Use foldLeft to compute the total size of a list of strings.


// Define our list of strings.
val women = List(
	"Katie",
	"Sarah",
	"Joanna",
	"Libby"
)


// ---------------------------------------------------------- //
// ---------------------------------------------------------- //


// Now, use foldLeft, to get sum the length of each string.
val charLength = (0 /: women){ ( sum, woman ) =>

	// Add the length of the woman to the current sum of
	// character lengths. This result will be passed in as
	// the "sum" of the next block invocation (as it is applied
	// to the next woman).
	(sum + woman.size)

}

// Output the result.
println( "Total Length: " + charLength )


// ---------------------------------------------------------- //
// ---------------------------------------------------------- //


// Now, we are going to use the alternate foldLeft notation to
// accomplish the same thing. This approach using currying - the
// process by creating a function that implicity incorprates other
// parameters. In our case, we are currying the foldLeft concept,
// seeding it with the parameter "0".
val charLength2 = women.foldLeft( 0 )( ( sum, woman ) =>

	// The same exact code block logic aplied as above.
	(sum + woman.size)

)

// Output the result.
println( "Total Length: " + charLength2 )

// Write a Censor trait with a method that will replace the curse
// words Shoot and Darn with Pucky and Beans alternatives. Use a map
// to store the curse words and their alternatives.


// Define our Censor trait that can be used with any class. This
// contains a list of bad words, the good words they map to, and a
// censor() method which will sanitize any given input.
trait Censor {

	// Define our list of dirty words and the nice alternative
	// words that they map to.
	val censoredWords = Map(
		"Shoot" -> "Pucky",
		"Darn" -> "Beans"
	)


	// Define the method that will take a string and replace it with
	// the censored words. NOTE: This method will be a class method
	// of the class that inclused is.
	def censor( content: String ) = {

		// We can sanitize the content by folding it left accross the
		// the set of dirty words. Each given word will receive the
		// stantization of the word before it.
		censoredWords.foldLeft( content )(

			// Define the block signature. Note that in this parameter
			// list, mapping is a tuple ( goodWord, badWord ).
			( censoredContent, mapping ) =>

			// Clearn this bad word by replacing all word-boundary
			// instances with the good word. This result will be
			// passed to the next foldLeft operation.
			censoredContent.replaceAll(
				("(?i)\\b" + mapping._1 + "\\b"),
				mapping._2
			)

		)

	}

}


// ---------------------------------------------------------- //
// ---------------------------------------------------------- //


// Define the book class and extend our Censor trait.
class Book( val content: String ) extends Censor {

	// Define a generic getter for our content.
	def getContent() = this.content

	// Define a censored getter for our content. This will pass
	// the content through our censor trait method.
	def getCensoredContent() = this.censor( this.getContent )

}


// ---------------------------------------------------------- //
// ---------------------------------------------------------- //
// ---------------------------------------------------------- //
// ---------------------------------------------------------- //


// Create an instance of the book. Notice that this book has a
// few racy words within its content.
val book = new Book(
	"Well Shoot! If you're not the prettiest woman I've ever " +
	"seen, you can call me a monkey's uncle. Shoot! I wish " +
	"I had my camera handy."
)

// Print the content.
println( "Content:" )
println( book.getContent )

// Print the censored content.
println( "\nCensored Content:" )
println( book.getCensoredContent )

.foldLeft( content )( ( censoredContent, mapping ) => ....

.foldLeft( content )( ( censoredContent, ( goodWord, badWord ) ) => ....

// Load the curse words and alternatives from a file.


// Since we are loading the curse words from a file, I no longer
// want to treat the Censor concept as a trait. Rather, I'd like to
// define it as a class that can be configured and passed around as
// a behavior.
class Censor( val definitionFilePath: String ){

	// Get a handle on the file that contains are our mappings.
	val definitions = io.Source.fromFile( definitionFilePath )


	// Define our list of dirty words and the nice alternative
	// words that they map to. This will start out empty and then
	// get populated by the definition file.
	var censoredWords = Map[ String, String ]()

	// Now, overwrite the censored map with the mappings contained
	// within the lines of the dictionary file.
	censoredWords = definitions.getLines.foldLeft( censoredWords ){

		// Define the signature of our code block.
		( mappings, data ) =>

		// Each line of the file contains a single mapping, separated
		// by "::". Example: Darn::Beans.
		val terms = data.split( "::" )

		// Add the current mapping to the aggregate mappings. This
		// will create a new Map and pass it to the next iteration
		// of the foldLeft().
		(mappings + (terms( 0 ) -> terms( 1 )))

	}


	// Define the method that will take a string and replace it with
	// the censored words.
	def sanitize( content: String ) = {

		// We can sanitize the content by folding it left accross the
		// the set of dirty words. Each given word will receive the
		// stantization of the word before it.
		censoredWords.foldLeft( content )(

			// Define the block signature. Note that in this parameter
			// list, mapping is a tuple ( goodWord, badWord ).
			( censoredContent, mapping ) =>

			// Clearn this bad word by replacing all word-boundary
			// instances with the good word. This result will be
			// passed to the next foldLeft operation.
			censoredContent.replaceAll(
				("(?i)\\b" + mapping._1 + "\\b"),
				mapping._2
			)

		)

	}

}


// ---------------------------------------------------------- //
// ---------------------------------------------------------- //


// Define the book class. This time, we are passing in both our
// content as well as a behavior for censoring.
class Book( val content: String, val censor: Censor ){

	// Define a generic getter for our content.
	def getContent() = this.content

	// Define a censored getter for our content. This will pass
	// the content through our censor behavior.
	def getCensoredContent() = this.censor.sanitize( this.getContent )

}


// ---------------------------------------------------------- //
// ---------------------------------------------------------- //
// ---------------------------------------------------------- //
// ---------------------------------------------------------- //


// Create an instance of the book. Notice that this book has a
// few racy words within its content.
val book = new Book(
	"Well Shoot! If you're not the prettiest woman I've ever " +
	"seen, you can call me a monkey's uncle. Shoot! I wish " +
	"I had my camera handy.",

	// Pass in the censor behavior based on the given dictionary.
	new Censor( "./dictionary.txt" )
)

// Print the content.
println( "Content:" )
println( book.getContent )

// Print the censored content.
println( "\nCensored Content:" )
println( book.getCensoredContent )