User Tools

Site Tools


lecture:4clojure:level-elementary-easy

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision
Previous revision
lecture:4clojure:level-elementary-easy [2015/12/03 06:06]
psk810
lecture:4clojure:level-elementary-easy [2019/02/04 14:26] (current)
Line 177: Line 177:
 ==== vec/vector ==== ==== vec/vector ====
  
-vec \\+**vec** \\
 리스트/​맵/​집합을 벡터로 바꾼다. 리스트/​맵/​집합을 벡터로 바꾼다.
  
Line 184: Line 184:
   (vec {:a 1 :b 2 :c 3}) ;=> [[:c 3] [:b 2] [:a 1]]   (vec {:a 1 :b 2 :c 3}) ;=> [[:c 3] [:b 2] [:a 1]]
  
-vector \\+**vector** \\
 인자들로 구성된 벡터를 만든다. 인자들로 구성된 벡터를 만든다.
   ​   ​
   (vector 1 2 3) ;=> [1 2 3]   (vector 1 2 3) ;=> [1 2 3]
 +  ​
 ==== 자료구조에 추가/​삭제 : cons/​conj/​pop/​disj/​assoc/​dissoc/​assoc-in ==== ==== 자료구조에 추가/​삭제 : cons/​conj/​pop/​disj/​assoc/​dissoc/​assoc-in ====
  
Line 200: Line 201:
 Clojure는 코딩시 (1 2 3) 하면 위에서 함수를 설명한 것처럼 괄호()의 첫 요소인 1을 함수로 평가하게 되는데, 1은 함수가 아니기 때문에 예외가 발생한다. Clojure 컴파일러가 괄호()를 평가하지 않고 그냥 리스트로 인식하게 하기 위해서는 '(1 2 3) 처럼 하면 된다. Clojure는 코딩시 (1 2 3) 하면 위에서 함수를 설명한 것처럼 괄호()의 첫 요소인 1을 함수로 평가하게 되는데, 1은 함수가 아니기 때문에 예외가 발생한다. Clojure 컴파일러가 괄호()를 평가하지 않고 그냥 리스트로 인식하게 하기 위해서는 '(1 2 3) 처럼 하면 된다.
  
-cons는 새로운 리스트를 만든다. 새로운 리스트의 첫 요소는 첫번째 파라미터이고,​ 나머지는 두번째 파라미터의 요소들이다. +cons는 새로운 리스트를 만든다. 새로운 리스트의 첫 요소는 첫번째 파라미터이고,​ 나머지는 두번째 파라미터의 요소들이다. ​\\
 conj(oin)는 리스트에 새 요소를 추가하는데,​ 리스트에 추가하는 가장 빠른 방법은 앞에 추가하는 것이다. ​ conj(oin)는 리스트에 새 요소를 추가하는데,​ 리스트에 추가하는 가장 빠른 방법은 앞에 추가하는 것이다. ​
  
Line 212: Line 212:
 </​code>​ </​code>​
  
-cons는 그 대상이 벡터여도 결과는 같다. 즉 맨 앞에 추가한 리스트를 리턴한다. +cons는 그 대상이 벡터여도 결과는 같다. 즉 맨 앞에 추가한 리스트를 리턴한다. ​\\
 conj는 벡터일 때는 맨 뒤에 추가한다. 벡터는 인덱스 접근이 가능하기 때문이다. conj는 벡터일 때는 맨 뒤에 추가한다. 벡터는 인덱스 접근이 가능하기 때문이다.
  
Line 272: Line 271:
 ==== seq / empty? ==== ==== seq / empty? ====
  
-(empty? coll) \\+**(empty? coll)** \\
 coll이 비었으면 true, 아니면 false를 반환한다. coll이 비었으면 true, 아니면 false를 반환한다.
  
Line 280: Line 279:
  
  
-(seq coll) \\+**(seq coll)** \\
 coll의 seq를 반환한다. coll의 seq를 반환한다.
  
Line 296: Line 295:
 ==== contains? ==== ==== contains? ====
  
-(contains? coll key) \\+**(contains? coll key)** \\
 컬렉션 coll에 key가 있는지 여부 판단. 컬렉션 coll에 key가 있는지 여부 판단.
  
Line 308: Line 307:
   (contains? #​{"​a"​ "​b"​ "​c"​} "​a"​) ;=> true   (contains? #​{"​a"​ "​b"​ "​c"​} "​a"​) ;=> true
   (contains? #​{"​a"​ "​b"​ "​c"​} "​z"​) ;=> false  ​   (contains? #​{"​a"​ "​b"​ "​c"​} "​z"​) ;=> false  ​
 +  ​
 +==== range ====
 +
 +** (range)(range end)(range start end)(range start end step) ** \\
 +[start end) 사이의 정수로 된 지연 시퀀스를 반환한다. setp만큼 건너뛴다.
 +
 +
 +  (range 10)
 +  ;=> (0 1 2 3 4 5 6 7 8 9)
 +  ​
 +0부터 시작해서 인수만큼의 정수의 리스트를 만든다.
 +
 +  (range -5 5)
 +  ;=> (-5 -4 -3 -2 -1 0 1 2 3 4)
 +  ​
 +  (range -0 100 10)
 +  ;=> (0 10 20 30 40 50 60 70 80 90)
 +  ​
 +  (range 100 0 -10)
 +  ;=> (100 90 80 70 60 50 40 30 20 10)
 +
 +시작과 끝, 그리고 step을 지정할 수 있다.
 +  ​
 +  (range) ​
 +  ;=> (0 1 2 3 4 5 6 7 8 9 10 ... 12770 12771 12772 12773 ... n
 +  ​
 +  (take 10 (range))
 +  ;=> (0 1 2 3 4 5 6 7 8 9)
 +  ​
 +(range)는 0을 포함한 자연수의 집합이라는 무한 지연 시퀀스를 만든다.\\
 +이것을 실행하면 무한 반복되어 그 스레드는 먹통이 된다. \\
 +그래서 take로 잡아주어야 한다.
 ==== if / when ==== ==== if / when ====
  
-if+**if**
  
   (if true 1 2)  ;=> 1   (if true 1 2)  ;=> 1
Line 316: Line 347:
   (if fasel 1)   ;​=>​ nil   (if fasel 1)   ;​=>​ nil
  
-when+**when**
  
   (when (= 1 1) true)    => true   (when (= 1 1) true)    => true
Line 323: Line 354:
 ==== cond / case / condp ==== ==== cond / case / condp ====
  
-cond \\ +**cond** \\ 
-조건절에 따라 분기+여러 ​조건절에 따라 분기
  
   (let [grade 85]   (let [grade 85]
Line 335: Line 366:
    ;​=>​ "​B"​    ;​=>​ "​B"​
  
-case \\+**case** \\
 경우에 따라 분기 경우에 따라 분기
  
Line 346: Line 377:
   ;=> 20   ;=> 20
  
-condp \\+**condp** \\
 pred 평가에 따른 분기 pred 평가에 따른 분기
  
Line 355: Line 386:
         3 "​three"​         3 "​three"​
         (str "​unexpected value, \""​ x \")))         (str "​unexpected value, \""​ x \")))
 +        ​
 +
 ==== reverse ==== ==== reverse ====
  
-(reverse coll) \\+**(reverse coll)** \\
 역전된 coll을 반환한다. 역전된 coll을 반환한다.
  
   (reverse '(1 2 3)) ;=> (3 2 1)   (reverse '(1 2 3)) ;=> (3 2 1)
 +  ​
 ==== take/drop ==== ==== take/drop ====
  
-(take n coll) \\+**(take n coll)** \\
 coll의 처음 n개의 요소로 된 lazy-seq를 리턴한다. coll의 처음 n개의 요소로 된 lazy-seq를 리턴한다.
  
Line 372: Line 406:
 </​code>​ </​code>​
  
-(drop n coll) \\+**(drop n coll)** \\
 coll의 처음 n개의 요소를 제외한 나머지로 된 lazy-seq를 리턴한다. coll의 처음 n개의 요소를 제외한 나머지로 된 lazy-seq를 리턴한다.
  
Line 383: Line 417:
 ==== take-while/​drop-while ==== ==== take-while/​drop-while ====
  
-(take-while pred coll) \\+**(take-while pred coll)** \\
 (pred el)이 참인 동안의 요소들로 된 lazy-seq를 리턴한다. 즉 처음 (pred el)이 거짓일 때까지의 요소로 된 lazy-seq. (pred el)이 참인 동안의 요소들로 된 lazy-seq를 리턴한다. 즉 처음 (pred el)이 거짓일 때까지의 요소로 된 lazy-seq.
  
Line 391: Line 425:
 </​code>​ </​code>​
  
-(drop-while pred coll) \\+**(drop-while pred coll)** \\
 (pred el)이 참인 동안의 요소들을 제외한 나머지 요소로 된 lazy-seq를 리턴한다. 즉 처음 (pred el)이 거짓일 때까지의 요소 제외한 lazy-seq. (pred el)이 참인 동안의 요소들을 제외한 나머지 요소로 된 lazy-seq를 리턴한다. 즉 처음 (pred el)이 거짓일 때까지의 요소 제외한 lazy-seq.
  
Line 400: Line 434:
 ==== map ==== ==== map ====
  
-(map f coll) \\+**(map f coll)** \\
 map 함수는 다음과 같이 수학에서 한 집합에서 다른 집합으로 바꾸는 작업을 한다. f는 coll의 각 요소에 적용된다. map 함수는 다음과 같이 수학에서 한 집합에서 다른 집합으로 바꾸는 작업을 한다. f는 coll의 각 요소에 적용된다.
  
Line 437: Line 471:
 ==== filter/​remove ==== ==== filter/​remove ====
  
-(filter pred coll) \\+**(filter pred coll)** \\
 filter 함수는 coll의 요소 el에 대해 (pred el)이 참인 el들로 된 lazy-seq를 리턴한다. filter 함수는 coll의 요소 el에 대해 (pred el)이 참인 el들로 된 lazy-seq를 리턴한다.
  
      ​X ​                             Y    ​      ​X ​                             Y    ​
    ​+----+ ​   (pred x1) = true     ​+----+    ​+----+ ​   (pred x1) = true     ​+----+
-   | x1 | ---------------------->​ | x1 |+   | x1 |------------------------>​| x1 |
    ​| ​   |    (pred x2) = false    |    |    ​| ​   |    (pred x2) = false    |    |
-   | x2 | ----------------------x |    |+   | x2 |-----------------------x |    |
    ​| ​   |    (pred x3) = true     ​| ​   |    ​| ​   |    (pred x3) = true     ​| ​   |
-   | x3 | ---------------------->​ | x2 |+   | x3 |------------------------>​| x2 |
    ​| ​   |    (pred x4) = false    |    |    ​| ​   |    (pred x4) = false    |    |
-   | x4 | ----------------------x |    |+   | x4 |-----------------------x |    |
    ​+----+ ​                        ​+----+    ​+----+ ​                        ​+----+
        
Line 464: Line 498:
 ==== keep ==== ==== keep ====
  
-(keep f coll) \\+**(keep f coll)** \\
 keep 함수는 coll의 요소 el에 대해 (f el)이 nil이 아닌 리턴값으로 된 lazy-seq를 리턴한다. keep 함수는 coll의 요소 el에 대해 (f el)이 nil이 아닌 리턴값으로 된 lazy-seq를 리턴한다.
  
      ​X ​                        ​Y ​   ​      ​X ​                        ​Y ​   ​
    ​+----+ ​   (f x1) = y1     ​+----+    ​+----+ ​   (f x1) = y1     ​+----+
-   | x1 | ----------------->​ | y1 |+   | x1 |------------------->​| y1 |
    ​| ​   |    (f x2) = nil    |    |    ​| ​   |    (f x2) = nil    |    |
-   | x2 | -----------------x |    |+   | x2 |------------------x |    |
    ​| ​   |    (f x3) = y3     ​| ​   |    ​| ​   |    (f x3) = y3     ​| ​   |
-   | x3 | ----------------->​ | y3 |+   | x3 |------------------->​| y3 |
    ​| ​   |    (f x4) = nil    |    |    ​| ​   |    (f x4) = nil    |    |
-   | x4 | -----------------x |    |+   | x4 |------------------x |    |
    ​+----+ ​                   +----+    ​+----+ ​                   +----+
  
Line 483: Line 517:
 ==== reduce ==== ==== reduce ====
  
-(reduce f initial coll) \\+**(reduce f initial coll)** \\
 reduce 함수는 coll의 요소 el에 대해 2개의 인수를 받는 함수 (f acc el)의 결과를 다음 el들의 f의 acc에 적용하여 누적한 최종값(acc)을 리턴한다. reduce 함수는 coll의 요소 el에 대해 2개의 인수를 받는 함수 (f acc el)의 결과를 다음 el들의 f의 acc에 적용하여 누적한 최종값(acc)을 리턴한다.
  
Line 528: Line 562:
 ==== into ==== ==== into ====
  
-(into to from) \\+**(into to from)** \\
 from 컬렉션의 요소들을 to 컬렉션에 넣는다. from 컬렉션의 요소들을 to 컬렉션에 넣는다.
  
Line 542: Line 576:
 ==== merge / merge-with ==== ==== merge / merge-with ====
  
-(merge & maps) \\+**(merge & maps)** \\
 맵들을 합친다. 키가 겹치면 나중의 것을 취한다. 맵들을 합친다. 키가 겹치면 나중의 것을 취한다.
  
   (merge {:a 1 :b 2 :c 3} {:b 9 :d 4}) ;=> {:d 4, :a 1, :b 9, :c 3}   (merge {:a 1 :b 2 :c 3} {:b 9 :d 4}) ;=> {:d 4, :a 1, :b 9, :c 3}
   ​   ​
-(merge-with f & maps) \\+**(merge-with f & maps)** \\
 맵들을 합친다. 키가 겹치면 그 값들을 함수 f에 적용한 값을 취한다. 맵들을 합친다. 키가 겹치면 그 값들을 함수 f에 적용한 값을 취한다.
  
   (merge-with + {:a 1  :b 2} {:a 10  :b 20 :c 30}) ;=> {:a 11 :b 22 :c 30}   (merge-with + {:a 1  :b 2} {:a 10  :b 20 :c 30}) ;=> {:a 11 :b 22 :c 30}
 ==== let 문구 ==== ==== let 문구 ====
 +
 +로컬 바인딩
 +
 +  (let [x 1] 
 +    x)
 +  ;=> 1
 +
 +
 +  (let [a 1 b 2] 
 +    (+ a b))
 +  ;=> 3
 +
 +  (let [x 10
 +        y (range 10)] 
 +    (apply + y))
 +  ;=> 45
  
 ==== loop recur ==== ==== loop recur ====
Line 625: Line 675:
 ==== iterate /repeat ==== ==== iterate /repeat ====
  
-(iterate f x) \\+**(iterate f x)** \\
 x, (f x), (f (f x))의 지연 시퀀스를 만든다. x, (f x), (f (f x))의 지연 시퀀스를 만든다.
  
Line 632: Line 682:
  
  
-(repeat x) (repeat n x) \\+**(repeat x) (repeat n x)** \\
 주어진 값을 반복하는 지연 시퀀스를 만든다. 주어진 값을 반복하는 지연 시퀀스를 만든다.
    
Line 642: Line 692:
 ==== apply ==== ==== apply ====
  
-(apply f args) \\+**(apply f args)** \\
 함수 f를 args에 적용한다. 함수 f를 args에 적용한다.
  
Line 654: Line 704:
 ==== partial ==== ==== partial ====
  
-(partial f)(partial f arg1)(partial f arg1 arg2) ... \\+**(partial f)(partial f arg1)(partial f arg1 arg2) ... ** \\
 함수 f와 f의 일부 인수를 받고 함수를 반환하는데,​ 이 반환함수는 f의 나머지 인수를 받아서 f 함수를 수행할 수 있다. 함수 f와 f의 일부 인수를 받고 함수를 반환하는데,​ 이 반환함수는 f의 나머지 인수를 받아서 f 함수를 수행할 수 있다.
  
Line 667: Line 717:
 ==== comp ==== ==== comp ====
  
-(comp f g) \\+**(comp f g)** \\
 합성함수 f(g)를 만든다. 합성함수 f(g)를 만든다.
  
Line 676: Line 726:
 ==== concat / mapcat ==== ==== concat / mapcat ====
  
-(concat x y)(concat x y & zs) \\+**(concat x y)(concat x y & zs)** \\
 컬렉션들을 합친다. 컬렉션들을 합친다.
  
Line 687: Line 737:
  
  
-(mapcat f & colls) \\+**(mapcat f & colls)** \\
 일반적인 map을 수행한 후, concat을 적용한다. f는 컬렉션을 반환해야 한다. 일반적인 map을 수행한 후, concat을 적용한다. f는 컬렉션을 반환해야 한다.
  
Line 695: Line 745:
 ==== some / every? ==== ==== some / every? ====
  
-(some pred coll) \\+**(some pred coll)** \\
 coll의 요소 x에 대해 (f x)가 논리적으로 참일 때의 반환값을 반환한다. coll의 요소 x에 대해 (f x)가 논리적으로 참일 때의 반환값을 반환한다.
  
Line 706: Line 756:
  
  
-(every? pred coll) \\+**(every? pred coll)** \\
 coll의 모든 요소 x에 대해 (pred x)가 참이면 true, 아니면 false를 반환한다. coll의 모든 요소 x에 대해 (pred x)가 참이면 true, 아니면 false를 반환한다.
  
Line 753: Line 803:
 ==== identity ==== ==== identity ====
  
-(identity x) \\+**(identity x)** \\
 받은 인수를 그래로 반환한다. 받은 인수를 그래로 반환한다.
  
Line 760: Line 810:
 ==== interleave / interpose ==== ==== interleave / interpose ====
  
-(interleave c1 c2) \\+**(interleave c1 c2)** \\
 각 컬렉션의 요소들을 순서대로 섞는다. 각 컬렉션의 요소들을 순서대로 섞는다.
  
   (interleave [:a :b :c] [1 2 3]) ;=> (:a 1 :b 2 :c 3)   (interleave [:a :b :c] [1 2 3]) ;=> (:a 1 :b 2 :c 3)
  
-(interpose sep coll) \\+**(interpose sep coll)** \\
 coll의 요소 사이에 sep을 넣는다. coll의 요소 사이에 sep을 넣는다.
  
Line 771: Line 821:
 ==== partition / partition-by ==== ==== partition / partition-by ====
  
-(partition n coll) (partition n step coll) (partition n step pad coll) \\+**(partition n coll) (partition n step coll) (partition n step pad coll)** \\
 아이템을 n개씩 묶는다. step만큼 건너뛰면서. 아이템을 n개씩 묶는다. step만큼 건너뛰면서.
  
Line 787: Line 837:
  
  
-(partition-by f coll) \\+**(partition-by f coll)** \\
 f함수의 반환값에 따라 아이템을 묶는다. f함수의 반환값에 따라 아이템을 묶는다.
  
Line 801: Line 851:
 ==== group-by ==== ==== group-by ====
  
-(group-by f coll) \\+**(group-by f coll)** \\
 함수 f의 반환값이 같은 것끼리 묶는다. 함수 f의 반환값이 같은 것끼리 묶는다.
  
Line 810: Line 860:
   ;=> {1 ["​a"​],​ 2 ["​as"​ "​aa"​],​ 3 ["​asd"​],​ 4 ["​asdf"​ "​qwer"​]}   ;=> {1 ["​a"​],​ 2 ["​as"​ "​aa"​],​ 3 ["​asd"​],​ 4 ["​asdf"​ "​qwer"​]}
   ​   ​
 +
 ==== map-indexed / keep-indexed ==== ==== map-indexed / keep-indexed ====
  
-(map-indexed f coll) \\+**(map-indexed f coll)** \\
 map 과 같은데, 함수 f의 첫 인수로 인덱스이고,​ 두번째 인수가 coll의 요소(item)이다. map 과 같은데, 함수 f의 첫 인수로 인덱스이고,​ 두번째 인수가 coll의 요소(item)이다.
  
Line 822: Line 873:
  
  
-(keep-indexed f coll) \\+**(keep-indexed f coll)** \\
 keep 과 같은데, 함수 f의 첫 인수로 인덱스이고,​ 두번째 인수가 coll의 요소(item)이다. keep 과 같은데, 함수 f의 첫 인수로 인덱스이고,​ 두번째 인수가 coll의 요소(item)이다.
  
   (keep-indexed #(if (odd? %1) %2) [:a :b :c :d :e])   (keep-indexed #(if (odd? %1) %2) [:a :b :c :d :e])
   ;=> (:b :d)   ;=> (:b :d)
 +
 +
 ==== lazy-seq ==== ==== lazy-seq ====
  
Line 833: Line 886:
   (defn fib [a b] (lazy-seq (cons a (fib b (+ b a)))))   (defn fib [a b] (lazy-seq (cons a (fib b (+ b a)))))
   (take 5 (fib 1 1))  ;=> (1 1 2 3 5)   (take 5 (fib 1 1))  ;=> (1 1 2 3 5)
 +  ​
  
 ==== destructuring ==== ==== destructuring ====
- 
lecture/4clojure/level-elementary-easy.1449122762.txt.gz · Last modified: 2019/02/04 14:26 (external edit)