Scala

cotrConst

Scala Create Constant

val ${1:myConst} = $2

cotrInfo

Scala Info

// Typing: Statically typed
// Paradigm: Multi-paradigm: object-oriented, functional
// Compilation: Compiled to bytecode for the Java Virtual Machine (JVM)
// Concurrency: Supports multi-threading and concurrent programming with actors and futures

cotrTypesBool

Scala Boolean Type

Boolean

cotrVar

Scala Create Variable

var ${1:myVar}: ${2:Type} = $3

cotrForEachLoop

Scala For Each Loop

for (item <- ${1:iterable}) {
  // Your code here
}

cotrFuncLambda

Scala Lambda

(${1:parameters}) => ${2:expression}

cotrTypesList

Scala List Type

List[${1:type}]

cotrVarMap

Scala Create Map Variable

val ${1:myMap} = Map(${2:key} -> ${3:value})

cotrEntry

Scala Entry Point

// Scala Entry Point
// To run this program, use: `scala Main.scala`

object Main extends App {
  // Your code here
}

cotrOperatorsBool

Scala Boolean Operators

// Scala Boolean Operators
// Logical AND: &&
// Logical OR: ||
// Logical NOT: !
// Equality: ==
// Inequality: !=
// Greater than: >
// Less than: <
// Greater than or equal to: >=
// Less than or equal to: <=

cotrTypesMap

Scala Map Type

Map[${1:keyType}, ${2:valueType}]

cotrDynamic

Scala Dynamic Type

Any

cotrFunc

Scala Function

def ${2:myFunction}(${3:parameters}): ${1:Unit} = {
  ${4:// Your code here}
}

cotrEqual

Scala Equal To

==

cotrNotEqual

Scala Not Equal To

!=

cotrVarString

Scala Create String Variable

val ${1:myString} = "${2:Your string here}"

cotrIf

Scala If Statement

if (${1:condition}) {
  // Your code here
}

cotrTypeConvert

Scala Type Conversion

// Scala Type Conversion:

// Implicit conversions (compiler performs automatically):
// - Smaller numeric types to larger numeric types (e.g., Int to Double).

// Explicit conversions (using casts):
// - variable.asInstanceOf[Type]  // Type casting (can throw ClassCastException if conversion fails)
// - variable.toType  // Conversion methods (e.g., toInt, toDouble)

// Note:
// - Be cautious with explicit conversions, as they can lead to errors if the conversion is not valid.

cotrVarStringMulti

Scala Create Multi-Line String Variable

val ${1:myString} = """
${2:Line 1}
${3:Line 2}
${4:Line 3}
"""

cotrVarBool

Scala Create Boolean Variable

val ${1:myBool} = ${2:true}

cotrCommentMulti

Scala Multi-Line Comment

/*
 * ${1:Your comment here}
 */

cotrOperators

Scala Mathematical Operators

// Scala Mathematical Operators
// Addition: +
// Subtraction: -
// Multiplication: *
// Exponentiation: Math.pow(base, exponent)
// Division: /
// Modulus (Remainder): %
// Increment: Use += 1
// Decrement: Use -= 1
// Assignment: =
// Addition assignment: +=
// Subtraction assignment: -=
// Multiplication assignment: *=
// Division assignment: /=
// Modulus assignment: %=

cotrTypesBoolFalse

Scala Boolean False

false

cotrNull

Scala Null Type

null

cotrVarNullable

Scala Create Nullable Variable

var ${1:myVar}: Option[${2:Type}] = None

cotrComment

Scala Comment

// ${1:Your comment here}

cotrTypesString

Scala String Type

String

cotrTypesNumAlt

Scala Float Type

Float

cotrInterpolate

Scala Interpolate String

s"Your string here \${${1:variable}}"

cotrVarDouble

Scala Create Double Variable

val ${1:myDouble} = ${2:0.0}

cotrConcat

Scala Concatenate String

${1:"string1"} + ${2:"string2"}

cotrStructure

Scala Project Structure (High-Level)

// Recommended High-Level Scala Project Structure:

// - build.sbt: The build definition file for SBT (Scala Build Tool).
// - project/
//   - Contains build-related scripts and configurations for SBT.
// - src/
//   - main/
//     - scala/
//       - Contains Scala source files organized by package.
//     - java/
//       - Optional: Contains Java source files if the project mixes Scala and Java.
//     - resources/
//       - Contains non-compiled resources like configurations, JSON files, etc.
//   - test/
//     - scala/
//       - Contains Scala test files, typically using frameworks like ScalaTest or Specs2.
//     - java/
//       - Optional: Contains Java test files if the project mixes Scala and Java.
//     - resources/
//       - Test-specific resources.
// - lib/
//   - Optional: Contains unmanaged library dependencies (jars).
// - target/
//   - Contains compiled bytecode and other build artifacts.

// Note:
// - The structure is based on SBT's standard layout.
// - Use the 'lib' directory for unmanaged dependencies, although managed dependencies
//   in the build.sbt file are preferred.

cotrTypes

Scala Types

$BLOCK_COMMENT_START
Scala is a statically typed language.

Types in Scala include:
- Int: Integer
- Double: Double-precision floating-point number
- Float: Single-precision floating-point number
- Char: Character
- Boolean: Boolean
- String: String
- Array[T]: Array of type T
- List[T]: List of type T
- Set[T]: Set of unique elements of type T
- Map[K, V]: Map with key type K and value type V
- Any: Base type of all non-nullable types
- Unit: Type with only one value - Unit (similar to void)
- Nothing: Type with no values - used for functions that never return
- Option[T]: Type representing a value of type T or None
- Function types (e.g., (Int, Int) => Int): Types representing functions
- Case classes: Classes primarily used to hold data
- Sealed classes: Classes that restrict which other classes can inherit from them
- Enum classes: Enumeration classes
- Object: Singleton object
- Trait: Interface type
$BLOCK_COMMENT_END

cotrVarSyntax

Scala Variable Declaration Syntax

// Scala Variable Declaration Syntax:

// - var: (Scope: Block or Class)
//   - Can be reassigned.
//   - Use for variables that need to be changed.

// - val: (Scope: Block or Class)
//   - Cannot be reassigned after initialization.
//   - Preferred for values that should remain constant.

// Note:
// - Use 'val' by default for values that won't change.
// - Use 'var' only when you need to reassign the variable.

cotrVarTyped

Scala Create Typed Variable

var ${1:myVar}: ${2:Type} = $3

cotrForLoop

Scala For Loop

for (i <- ${1:0 until 10}) {
  // Your code here
}

cotrNow

Scala Date Now

// Use java.time or ScalaTime to get the current date and time.

cotrTernary

Ternary Operator (Alternative)

// Scala does not have a ternary operator.
// Use an if-else expression instead:

val result = if (${1:condition}) ${2:trueValue} else ${3:falseValue}

cotrFuncArgsNamed

Scala Function Named Args

def ${2:myFunction}(${3:arg1}: ${4:Type1} = ${5:defaultValue1}, ${6:arg2}: ${7:Type2} = ${8:defaultValue2}): ${1:Unit} = {
  ${9:// Your code here}
}

cotrTypeCompare

Scala Type Comparison

// Check if two variables have the same type:
if (${1:variable1}.getClass == ${2:variable2}.getClass) {
  // Your code here
}

cotrTypesDate

Scala Date Type

// Scala does not have a built-in Date type. Use the java.time package or libraries like ScalaTime for date and time operations.

cotrWhileLoop

Scala While Loop

while (${1:condition}) {
  // Your code here
}

cotrPrint

Scala Print

println(${1:'Your message here'})

cotrTypesInt

Scala Integer Type

Int

cotrTypesNum

Scala Double Type

Double

cotrTypesBoolTrue

Scala Boolean True

true

cotrVarInt

Scala Create Integer Variable

val ${1:myInt} = ${2:0}

cotrClass

Scala Class Syntax

class ${1:MyClass} {
  // Your code here
}

cotrVarList

Scala Create Array Variable

val ${1:myList} = List(${2:items})

cotrIfElse

Scala If Else Statement

if (${1:condition}) {
  // Your code here
} else {
  // Your code here
}

cotrFuncSyntax

Function Syntax

// Scala Function Syntax:

// Basic function:
// def functionName(parameters): ReturnType = { ... }

// Function with arguments:
// def functionName(arg1: Type1, arg2: Type2, ...): ReturnType = { ... }

// Function with named arguments and default values:
// def functionName(arg1: Type1 = defaultValue1, arg2: Type2 = defaultValue2, ...): ReturnType = { ... }

cotrFuncArgs

Scala Function Args

// In Scala, functions can have arguments with default values.
def ${2:myFunction}(${3:arg1}: ${4:Type1}, ${5:arg2}: ${6:Type2} = ${7:defaultValue}): ${1:Unit} = {
  ${8:// Your code here}
}

cotrTypeCheck

Scala Type Check

${1:variable}.getClass

cotrPrintMulti

Scala Print Multi

println("""
${1:Line 1}
${2:Line 2}
${3:Line 3}
""")