Please enable JavaScript.

Coggle requires JavaScript to display documents.

Scala Applied (Basics (Type (Sequences (List (Nil (Nil.::(1).::(2) (List(2…

- - - - Evaluate
        
        Print
        
        Loop
        
        Valid
  - - - No reassignment :forbidden:
      - Hiding
        
        Other val
    - - Reassignmment :green_cross:
        
        Same Type :warning:
      - var a: Int = 10
  - - - Array
        
        Mutable
        
        new Array[String] (3)
      - List
        
        List[Int]
        
        Required in Method
        
        Nil
        
        Empty list
        
        Nil.::(1).::(2)
        
        List(2,1)
        
        2 :: 1 :: Nil
        
        Concatenate
        
        list1 ::: list2
        
        Immutable
        
        Seq(1,2,3)
        
        List(1,2,3)
        
        (1 to 5).toList
      - Vector
        
        Immutable array
      - Ordered collection
    - - Unordered
      - Uniqueness
      - Implementations
        
        val mutable.Set(1,2,3)
        
        var immutable.Set(1,2,3)
        
        import scala.collection_
    - - Immutable / Mutable
      - val m1 = mutable.Map ('a' -> 1,...)
      - for ((key,value) <- m1) {...}
  - - - Return Type
        
        def add(x: Int, y : Int): Int = x + y
        
        add(2,3)
      - No Return Type
        
        : Unit =
    - - "Hello" -> 88
        
        (String,Int) = (Hello,88)
        
        ArrowAssoc("Hello").->(88)
  - - - Ignore
        
        if (a>b) { m = a} else { m = b }
      - Functional style
        
        Avoid return
      - Last expression
  - - - Error
        
        =>
    - - Always run
        
        Not return
  - - - No return
        
        :Unit
    - - At least once
  - - - val (a,b,c,d,e) = tup5
    - - ith element
    - - < 22 items
  - - - 1 + 2
        
        1.+(2)
        
        Method
        
        Item
        
        Argument
    - - Array("Jane","John")
        
        Array.apply(...)
      - args(0)
        
        args.apply(0)
    - - args(1) = "John"
        
        args.update(1,"John") =
      - Mutable only
- - - - Variables public by default
  - - - name_variable.method1(...)
  - - - External access
  - - - Start of the class
      - IllegalArgumentException thrown
  - - - Replace initial one
      - Constructor based on another
  - - - Same source file
      - Same name of the class
      - Alternative to Static
    - - More flexible
        
        Than auxiliary construtor
      - No new
        
        With class_name
  - - - Different inputs
- - - - No "private"
      - Scoping
        
        Variables not repeated
  - - - In Python
  - - - Function
  - - - One variable
  - - - As input
  - - - nums.filter(x => x < 4)
    - - Used once
  - - - _ Placeholder
        
        As remaining
        
        ( _ : Int)
  - - - Parameters
        
        Defined outside
        
        Avoid var
  - - - {case x =:...}
  - - - NameList :_*
- - - - fluent API
        
        Successive
  - - - var
    - - recursive function
  - - - Return unit
    - - Return unit
    - - for (i <- 1 to 10) yield(i)
        
        Return collection
      - if(1 to 10).map(i => i * i)
        
        Return collection
        
        flatmap
        
        Except the last map
    - - Generator
        
        Guard
        
        Assignment
        
        Give
    - - Programming
  - - - match{case v if v is... => ...}
  - - - escape \
- - - - 1.8