Functions in scala can be declared in various syntax style

Author: CodeLab20

Functions/Functions_1.scala

@@ -0,0 +1,37 @@
+/**
+ *	 Functions declared with syntax style - 1
+ *	 Here same functions f0, f1, f2 are defined in different style.
+ *   Check other file Functions_2.scala, Functions_3.scala, Functions_4.scala	  		 		
+ */
+
+object Functions_1 extends App 
+{
+	val f1:Function1[Int, Int] = new Function1[Int, Int]
+    {
+  		def apply(x:Int):Int = x+1
+    }    
+
+val f0:Function0[Int] = new Function0[Int]
+  {
+    def apply() = 1
+  }
+
+
+	val f2:Function2[Int, String, String] = new Function2[Int, String, String]
+  {
+    def apply(x:Int, y:String) = y + x
+  }
+	
+	println("f0() :" + f0())
+	println("f1(3) :" + f1(3))
+	println("f2(3, cool) :" + f2(3, "Cool"))
+} 
+
+/**
+ Sample Output:
+
+f0() :1
+f1(3) :4
+f2(3, cool) :Cool3
+
+ */

Functions/Functions_2.scala

@@ -0,0 +1,35 @@
+/**
+ *	 Functions declared with syntax style - 2
+ **/
+
+object Functions_2 extends App 
+{
+	val f1:Int => Int = new Function1[Int, Int]
+    {
+  		def apply(x:Int):Int = x+1
+    }    
+
+val f0:() => Int = new Function0[Int]
+  {
+    def apply() = 1
+  }
+
+
+	val f2:(Int, String) => String = new Function2[Int, String, String]
+  {
+    def apply(x:Int, y:String) = y + x
+  }
+	
+	println("f0() :" + f0())
+	println("f1(3) :" + f1(3))
+	println("f2(3, cool) :" + f2(3, "Cool"))
+} 
+
+/**
+ Sample Output:
+
+f0() :1
+f1(3) :4
+f2(3, cool) :Cool3
+
+ */

Functions/Functions_3.scala

@@ -0,0 +1,25 @@
+/**
+ *	 Functions declared with syntax style - 3
+ **/
+
+object Functions_3 extends App 
+{
+	val f1:Int => Int = (x:Int) => x+1
+
+	val f0:() => Int = () => 1
+
+	val f2:(Int, String) => String = (x:Int, y:String) => y + x
+
+		println("f0() :" + f0())
+		println("f1(3) :" + f1(3))
+		println("f2(3, cool) :" + f2(3, "Cool"))
+} 
+
+/**
+ Sample Output:
+
+f0() :1
+f1(3) :4
+f2(3, cool) :Cool3
+
+ */

Functions/Functions_4.scala

@@ -0,0 +1,36 @@
+/**
+ *	 Functions declared with syntax style - 4
+ * 		1. Functions are a trait that is instantiated anonymously
+ * 		2. apply method in function in not needed to call explicitly
+ *    3. Using tuple ,you can return multiple items from a function
+ * 
+ **/
+
+object Functions_4 extends App 
+{
+	val f1 = (x:Int) => x+1
+
+	val f0 = () => 1
+
+	val f2 = (x:Int, y:String) => y + x
+
+	//here f3 returns a tuple of 2 elements
+	val f3 = (x:String) => (x, x.size)
+	
+		println("f0() :" + f0())
+		println("f1(3) :" + f1(3))
+		println("f2(3, cool) :" + f2(3, "Cool"))
+		println("f3(\"Spider\") :" + f3("Spider"))
+} 
+
+  
+
+/**
+ Sample Output:
+
+f0() :1
+f1(3) :4
+f2(3, cool) :Cool3
+f3("Spider") :(Spider,6)
+
+ */

Functions/MethodsOrFunctions.scala

@@ -0,0 +1,28 @@
+/**
+ * Functions are their own objects
+ * Methods are not Functions
+ * Methods belong to context
+ * 
+ */
+ 
+object MyObject
+{
+  val f = (x:Int) => x+1  
+  def g(x:Int) = x+1
+}
+
+object MethodsOrFunctions extends App   
+{
+  println("MyObject.f(4) :" + MyObject.f(4))
+  println("MyObject.f.apply(4) :" + MyObject.f.apply(4))
+  println("MyObject.g(4) :"  + MyObject.g(4))
+}
+
+/**
+  Sample Output
+MyObject.f(4) :5
+MyObject.f.apply(4) :5
+MyObject.g(4) :5
+
+
+*/