👶

Author: Alejandro Gómez

.gitignore

@@ -0,0 +1,32 @@
+project/project
+project/target
+target
+.idea
+.tmp
+
+*.iml
+/out
+.idea_modules
+.classpath
+.project
+/RUNNING_PID
+.settings
+.sass-cache
+scalajvm/upload/*
+
+# temp files
+.~*
+*~
+*.orig
+
+# eclipse
+.scala_dependencies
+.buildpath
+.cache
+.target
+bin/
+.ensime
+.ensime_cache
+
+# OSX
+.DS_Store

.travis.yml

@@ -0,0 +1,5 @@
+language: scala
+scala:
+  - 2.11.7
+jdk:
+  - oraclejdk8

build.sbt

@@ -0,0 +1,19 @@
+lazy val stdlib = (project in file("."))
+.enablePlugins(ExerciseCompilerPlugin)
+.settings(
+  organization := "org.scalaexercises",
+  name            := "content-stdlib",
+  scalaVersion := "2.11.7",
+  version := "0.0.0-SNAPSHOT",
+  resolvers ++= Seq(
+    Resolver.sonatypeRepo("snapshots")
+  ),
+  libraryDependencies ++= Seq(
+    "com.chuusai" %% "shapeless" % "2.2.5",
+    "org.scalatest" %% "scalatest" % "2.2.4",
+    "org.scalaexercises" %% "runtime" % "0.0.0-SNAPSHOT" changing(),
+    "org.scalaexercises" %% "definitions" % "0.0.0-SNAPSHOT" changing(),
+    "org.scalacheck" %% "scalacheck" % "1.12.5",
+    "com.github.alexarchambault" %% "scalacheck-shapeless_1.12" % "0.3.1"
+  )
+)

project/build.properties

@@ -0,0 +1 @@
+sbt.version=0.13.9

project/plugins.sbt

@@ -0,0 +1 @@
+addSbtPlugin("org.scalaexercises" % "sbt-exercise" % "0.0.0-SNAPSHOT", "0.13", "2.10")

src/main/resources/scala-exercises/library.47

@@ -0,0 +1,3 @@
+defaultLib.Library_cats$1$
+defaultLib.Library_shapeless$1$
+defaultLib.Library_stdlib$1$

src/main/scala/stdlib/Asserts.scala

@@ -0,0 +1,61 @@
+package stdlib
+
+import org.scalatest._
+
+/** @param name asserts
+  */
+object Asserts extends FlatSpec with Matchers with exercise.Section {
+
+  /** ScalaTest makes three assertions available by default in any style trait. You can use:
+    *
+    * - `assert` for general assertions;
+    * - `assertResult` to differentiate expected from actual values;
+    * - `intercept` to ensure a bit of code throws an expected exception.
+    *
+    * In any Scala program, you can write assertions by invoking `assert` and passing in a `Boolean` expression:
+    *
+    * {{{
+    * val left = 2
+    * val right = 1
+    * assert(left == right)
+    * }}}
+    *
+    * If the passed expression is `true`, `assert` will return normally. If `false`,
+    * Scala's `assert` will complete abruptly with an `AssertionError`. This behavior is provided by
+    * the `assert` method defined in object `Predef`, whose members are implicitly imported into every Scala source file.
+    *
+    *
+    * ScalaTest provides a domain specific language (DSL) for expressing assertions in tests
+    * using the word `should`. ScalaTest matchers provides five different ways to check equality, each designed to address a different need. They are:
+    *
+    * {{{
+    * result should equal (3) // can customize equality
+    * result should === (3)   // can customize equality and enforce type constraints
+    * result should be (3)    // cannot customize equality, so fastest to compile
+    * result shouldEqual 3    // can customize equality, no parentheses required
+    * result shouldBe 3       // cannot customize equality, so fastest to compile, no parentheses required
+    * }}}
+    *
+    * Come on, your turn: true and false values can be compared with should matchers
+    */
+  def scalaTestAsserts(res0: Boolean) {
+    true should be(res0)
+  }
+
+  /** Booleans in asserts can test equality.
+    */
+  def booleansAsserts(res0: String) {
+    val v1 = 4
+    val v2 = 4
+    v1 === res0
+
+    /** `===` is an assert. It is from ScalaTest, not from the Scala language. */
+  }
+
+  /** Sometimes we expect you to fill in the values
+    */
+  def valuesAsserts(res0: Int) {
+    assert(res0 == 1 + 1)
+  }
+
+}

src/main/scala/stdlib/ByNameParameter.scala

@@ -0,0 +1,65 @@
+package stdlib
+
+import org.scalatest._
+
+/** @param name byname_parameter
+  */
+object ByNameParameter extends FlatSpec with Matchers with exercise.Section {
+
+  /** `() => Int` is a Function type that takes a `Unit` type. `Unit` is known as `void` to a Java programmer. The function returns an `Int`. You can place this as a method parameter so that you can you use it as a block, but still it doesn't look quite right.
+    */
+  def takesUnitByNameParameter(res0: Either[Throwable, Int]) {
+    def calc(x: () ⇒ Int): Either[Throwable, Int] = {
+      try {
+        Right(x()) //An explicit call the x function
+      } catch {
+        case b: Throwable ⇒ Left(b)
+      }
+    }
+
+    val y = calc { () ⇒ //Having explicitly declaring that Unit is a parameter with ()
+      14 + 15
+    }
+
+    y should be(res0)
+  }
+
+  /** A by-name parameter does the same thing as the previous koan but there is no need to explicitly handle `Unit` or `()`. This is used extensively in scala to create blocks.
+    */
+  def byNameParameter(res0: Either[Throwable, Int]) {
+    def calc(x: ⇒ Int): Either[Throwable, Int] = {
+      //x is a call by name parameter
+      try {
+        Right(x)
+      } catch {
+        case b: Throwable ⇒ Left(b)
+      }
+    }
+
+    val y = calc {
+      //This looks like a natural block
+      println("Here we go!") //Some superfluous call
+      val z = List(1, 2, 3, 4) //Another superfluous call
+      49 + 20
+    }
+
+    y should be(res0)
+  }
+
+  /** By name parameters can also be used with an *Object* and apply to make interesting block-like calls
+    */
+  def withApplyByNameParameter(res0: String) {
+    object PigLatinizer {
+      def apply(x: ⇒ String) = x.tail + x.head + "ay"
+    }
+
+    val result = PigLatinizer {
+      val x = "pret"
+      val z = "zel"
+      x ++ z //concatenate the strings
+    }
+
+    result should be(res0)
+  }
+
+}