HAMA 블로그

while

스칼라에서 While,For 문은 없다로 생각하는게 좋습니다. 

개인적으론 Java 8 이상에서도 while 문은 없다라고 생각하는게 좋지 않나 합니다. 

아래와 같이 다른 방법 

Stream API

LINQ 

STL algorithm

컬렉션의 고차함수(map , flatmap,  filter, zip, fold, foreach, reduce, collect, partition, scan, groupBy 등) 

 

을 먼저 생각하는게 좋습니다. 

* 스칼라의 while 은 다른 언어와 마찬가지로 동작합니다.

* if 나 for 가 표현"식" 인 반면에 while 은  "식" 이 아닙니다. 그냥 루프입니다.  즉 값을 내어 놓지 않습니다.

  예를들어 if 표현식의 경우 값을 내놓기 때문에 아래와 같이 코딩이 가능합니다.

  val filename = if (!args.isEmpty) args(0) else "default.txt"         

예제 

// 20 번 돌겠군요.  

var a = 0;

while( a < 20 ){

  a = a + 1;

}

 보통 while 문들 처럼  조건을 검사하고 조건이 참일때까지는 계속 반복 수행을 합니다. 

do while 루프도 있습니다.

var a = 0;
do { 
	a = a + 1; 
} while( a < 20 )

조건에 상관 없이 적어도 한번은 실행 할 수 있겠네요. ( 위의 코드에서는 20번 )

Unit 타입

루프의 결과는 그 타입이 Unit 입니다. 이 타입은 유니트 값 밖에 없으며 빈 괄호 () 로 표시합니다.

() 란 값이 존재한다는 점에서 자바의 void 와 다릅니다. 

def greet() { println ("hi")} 를 실행하면 () 이며  var 변수에 대한 재 할당도 () 가 결과가 됩니다. 

var line = 0;

while ((line = readLine()) != "") // 제대로 작동하지 않음 !!

println ("Read: " + line)

( line = readLine() )  를 평가하면 () 가 나오는데  != "" 이런식으로 비교하면 언제나 참입니다.

자바의 경우 할당받은 결과 값이겠지만,  스칼라에서 할당의 결과는 유니트 값인 () 이기 때문입니다.

따라서 

import java.io.File import scala.io.Source  

Source.fromFile(new File("myfile.txt")).getLines.foreach { 
	line => println(line) 
}

이런 방법을 고려해야 합니다. 사고 방식이 바뀌어야 한다는 말입니다.
이런식의 해결은 지양하고 있습니다.

while( {line = reader.readLine();  line!= null} ) { .... }

While 에서 탈출하기 

 2.8 버전부터 Breaks 가 생겼네요.

import scala.util.control.Breaks._ 

var largest = 0 // pass a function to the breakable method breakable 
{      
	for (i<-999 to 1  by -1; j <- i to 1 by -1) {         
    	val product = i * j         
        if (largest > product) {             
        		break  // BREAK!!        
        }        
        else if (product.toString.equals(product.toString.reverse)) {             
        	largest = largest max product         
         }     
     } 
 }

순수 함수형 언어에서 while

순수 함수형 언어에서는 while 의 결과가 특정 값을 내보내는게 아니기 때문에 종종 제외합니다. 그런 언어에서 "루프" 는 없습니다.하지만  스칼라에서는 존재하는데 때로는 명령형의 해법이 가독성이 더 뛰어나다고 믿기 때문입니다. 

재귀를 통한 while의 대체 

재귀와 while 은 공통점이 몇가지 있습니다.둘다 body 를 반복한다는 점이구요. 콘디션을 점검해서 순회의 종료를 알린다는 점입니다. 
위의 최대공약수 예제를 재귀로 바꾸어 보겠습니다.

// 최대 공약수 구하기
 

def gcd (x : Long, y :Long) : Long = 

if (y == 0) x else gcd (y, x%y) 

while 문의 컨디션 점검하는위치가 body 내부로 들어왔다는 점하고 

함수이름을 호출함으로써 순회가 돌아진다는 점이 조금 달라졌을 뿐입니다. 

* var 함수사용이 없어졌습니다.

일반적으로 while 루프틑 var 변수와 마찬가지로 적게 사용하기  위해 노력할것을 권장합니다.

while vs 재귀 vs 콜렉션 (고차함수) 

이 3가지에  관한 글을 링크했습니다.

 http://blog.richdougherty.com/2009/04/tail-calls-tailrec-and-trampolines.html

http://www.scala-lang.org/old/node/8113.html

http://alvinalexander.com/scala/scala-recursion-examples-recursive-programming

http://stackoverflow.com/questions/12496959/summing-values-in-a-list

http://stackoverflow.com/questions/18674743/is-there-any-advantage-to-avoiding-while-loops-in-scala

http://stackoverflow.com/questions/15138624/scala-recursion-vs-loop-performance-and-runtime-considerations

http://stackoverflow.com/questions/18645936/is-recursion-in-scala-very-necessary

공변성,불변성,역공변성

백그라운드

Object <- Number <- Integer or Double  같이 차례로 상속받는 타입이 있다고 가정할때 

Object <- Animal <- Cat or Dog 도 괜찮습니다.

공변성  (covarience, out, producer : 즉 get만 가능)
List<? extends Number>  란 Number 를 상속받는 타입으로 이루어진 리스트란 말이구요.
즉 List<? extends Number> 로 선언되어 있다면  List<Integer> 이나 List<Double> 를 사용할 수 있다라는 말로 공변성(covariance) 지원한다라고 하구요. (자식 타입으로 치환가능)

역공변성(contravarience, in, consumer : 즉 add, put, set 가능 get 불가 ) 
List<? super Number> 란 Number 의 부모타입으로 이루어진 리스트란 말입니다. 
즉 List<? super Number> 로 선언되어있다면 List<Object> 를 사용 할 수 있다라는 말로
역공변성(Contravarience) 지원한다라고 합니다. (부모 타입으로 치환 가능) 

불변성

둘다 지원안하면 불변성(invarience) 입니다. (타입전환 불가) 

예제로 이해하자

자 다음 예제를 보시죠.

public static void copy(List<? extends Number> source, List<? super Number> destiny) {   
	for(Number number : source) {     
    		destiny.add(number);   
    } 
}  

* source 로는 Number 를 상속한 타입의 리스트를 받을 수 있다. (Covariance 가능하다)  
* destiny 로는 Number 의 부모타입의 리스트를 받을 수 있다. (Contravarience 가능하다)    

List<Integer> myInts = Arrays.asList(1,2,3,4);  // Integer 의 리스트  
List<Double> myDoubles = Arrays.asList(3.14, 6.28); // Double 의 리스트 
List<Object> myObjs = new ArrayList<Object>();  // Object 리스트  
copy(myInts, myObjs);   // Integer 의 리스트에서 get 해서 Object 의 리스트로 put 하라  
copy(myDoubles, myObjs);// Double 의 리스트에서 get 해서 Object 의 리스트로 put 하라   

결과: myObjs ->  [1, 2, 3, 4, 3.14, 6.28]

보통  Covariance 을 허락 하는곳은 get 이며 , Contravarience 는 put 입니다. 

PUT / ADD

put 이란 값을 넣는다는건데 ,부모가 자식들의 형태를 모두 취하는건 일리가 있지만 

같은 부모의 A 자식이 B 자식을 취하는건 좀 넌센스죠. (개가 고양이를 취함, Integer 가 Double 을 취함)

* 사실 put,add 처럼 먼가 변경하는것은 invariance, immutable이 아니면  위험요소가 항상 있다. 그래서 순수함수형언어에서는 covariance 성질을 가져도 ㅇㅋ 지만 , 스칼라나 자바에서는 주의를 해야한다. 

* 다음 예를 보면 제너릭이 아닌 일반 배열에서도 covariance 는 위험하다는걸 보여준다.

void put(Object[] list) {    list[0]=10;}

put(new String[1]);

GET 

 get 은 값을 꺼내는건데, 자식들의 값을 꺼내는건 일리가 있지만 , 어떤 타입이 들어 있을지 모를 부모의 리스트에서 값을 꺼내어 사용한다는것은 안개속을 시속 300km 로 달리는 위험한 것 이다.

코틀린으로 설명 

개인적으로 이 설명이 가장 쉽게 써져 있는거 같습니다. (초반엔 자바로도 설명함)

https://kotlinlang.org/docs/generics.html 

스칼라로 설명

https://twitter.github.io/scala_school/ko/type-basics.html

ArrayBuffer

* 자바의 ArrayList 는 C++ 의 vector 와 유사하다. (즉 링크드리스트로 구현되지 않았다. 자바는 LinkedList 가 있고 C++ STL 에서는 list 가 있음)
* ListBuffer 는 링크드 리스트 역할이다.

• java.lang.Object
• • java.util.AbstractCollection<E>
  • • java.util.AbstractList<E>
    • • java.util.ArrayList<E>

http://stackoverflow.com/questions/8287360/scala-equivalent-of-java-util-arraylist  참고

질문 : ArrayList 와 동등한 스칼라의 컬렉션은 무엇인지요? 

Array 와 ArrayBuffer 의 차이 

Array 와  ArrayBuffer 는 둘다 mutable 입니다. 따라서 다음이 가능하죠.

a(i) = 'hello' 

차이점은 

ArrayBuffer 는 사이즈 조정이 자동적이다라는 점입니다.

ArrayBuffer 에 요소를 추가하면 자동적으로 늘어난다는 것이죠

그럼 Array 에 변경이 아니라 추가를 하면?

새로 만들어진 Array 가 생겨납니다. 예를 들어 보면 

 var array = Array( 1, 2, 3 )  // 배열 생성

 array +:= 4   // 배열 앞에 4 추가한 새로운 배열 생성

 array :+= 0   // 배열 뒤에 4 추가한 새로운 배열 생성

val buf = mutable.ArrayBuffer.empty[Int]
buf += 1
buf += 10
val ar = buf.toArray
ar.foreach(println(_))

Vector
http://allaboutscala.com/tutorials/chapter-6-beginner-tutorial-using-scala-immutable-collection/scala-tutorial-learn-use-immutable-vector/

스칼라 컬렉션과 자바 

* 스칼라는 자바에 비해 변하지 않는 컬렉션을 강조하며, 한 컬렉션에서 새로운 것으로 변환하는 많은 연산 제공

* 스칼라 <-->자바 양방향 변환가능 타입 

Map

import scala.collection.mutable.Map

val m = Map[Int,String]()   // 다른것들과 마찬가지로 팩토리 메소드를 이용해 만들 수 있다.

// 튜플로 이루어진 List 를 이용 
val myList = List("England" -> "London", "Germany" -> "Berlin") 
// List 에 요소들이 Tuple 로  
val myMap = myList.groupBy(e => e._1).map(e => (e._1, e._2(0)._2)) 
val betterConversion = Map(myList:_*) 
val scala28Map = myList.toMap  // scala 2.8 version 에선 이렇게도 가능   
// map 메소드를 이용  
val myList = List("England" , "London", "Germany" ,  "Berlin") 
val map: Map[String,Int] = myList.map{ s => (s,s.length) }.toMap

추가

m.retain((k,v) => k < 2)  // key 가 2 보다 작은 요소들만 남겨두고 나머지 제거

스스로는 변화되지 않는데 , 변환된것을 리턴해준다.

filterKeys        ( immutable.Map  도 가능)

val m2 = m.filterKeys(_ > 1)    // key  가 1 보다 큰 요소들을 가지고  m2 를 만듬. 

mapValues     ( immutable.Map  도 가능)

val m2  = m.mapValues(_ * 5)  // 모든 value 에 * 5 를 한 요소를 가지고 m2 를 만듬 

변경 

transform   ( mutable.Map  일 경우만 ) 

m.transform( (k,v) => v * 5 )  // 모든 value 에 * 5 를 한 요소를 가지고 m2 를 만듬 

위의 mapValues 와 다른점은 transform 은 스스로도 변경된다는 점이다. 

Map -> mutable.Map 으로 변경 

val myImmutableMap = collection.immutable.Map(1->"one",2->"two") val myMutableMap = collection.mutable.Map() ++ myImmutableMap

Set

val s  = Set ("Hi" , "There") 

변경 불가능한 Set 객체를 만들어서 변경 불가능한 s 에 대입한다.

변경

import scala.collection.immutable.set

라고 하면 새로운 할당이 일어나지 않고  Set자체에 추가한다. 

Tuple

* 메소드에서 여러 다양한 객체를 리턴해야 하는 경우 유용하다. 

val p = ( 99, "High") 

('u','r',"the") 의 타입은  Tuple3[Char,Char,String]이다.

원소에 접근 

println(p._1)  

튜플의 첫번째 값에 접근할수있다.

마지막 

왜 튜플은 원소접근을 p(0) 즉 p.apply(0) 처럼 할 수 없을까?

-> 리스트의 apply 메소드는 항상 동일한 타입의 객체를 반환하는 반면, 튜플의 각 원소들은 타입이 각기 다를 수 있기 때문

* 주의 사항

튜플은 각 원소의 접근을 0 이 아니라 1 부터 시작한다.