스칼라 함수 식 프로 그래 밍 과정 깊이 이해

스칼라 함수 식 프로 그래 밍 과정 깊이 이해
우 리 는 곧 변태 의 과정 을 시작 할 것 이다.
만약 입방 화 를 요구한다 면 이렇게 할 수 있다

35 * 35 * 35 
68 * 68 * 68 

문제 없어,추상 적 으로 함수 써 봐.

def cube(n: Int) = n * n * n 
cube(35) 
cube(68)

편리 합 니 다.1 에서 10 의 세제곱 과,OK 를 구하 면 재 귀 를 쓰 세 요.

def cube(n: Int) = n * n * n 
 def sumCube(a: Int, b: Int): Int = 
   if (a > b) 0 else cube(a) + sumCube(a + 1, b) 
 
sumCube(1, 10)

변태 점,입방 과,제곱 과,곱셈 과 는 여전히 그들의 함 수 를 쓰 고 순서대로 계산 하 는 데 문제 가 없다.

def cube(n: Int) = n * n * n 
def id(n: Int) = n 
def square(n : Int) = n * n 
def fact(n: Int): Int = 
  if (n == 0) 1 else n * fact(n - 1) 
 
def sumCube(a: Int, b: Int): Int = 
  if (a > b) 0 else cube(a) + sumCube(a + 1, b) 
 
def sumSquare(a: Int, b: Int): Int = 
  if(a > b) 0 else square(a) + sumSquare(a + 1, b) 
  
def sumFact(a: Int, b: Int): Int = 
  if (a > b) 0 else fact(a) + sumFact(a + 1, b) 
 
def sumInt(a: Int, b: Int): Int = 
  if(a > b) 0 else id(a) + sumInt(a + 1, b)  
 
 sumCube(1, 10) 
 sumInt(1, 10) 
 sumSquare(1, 10) 
 sumFact(1, 10)

그리고 같은 논리 적 인 if else 를 썼 다 는 것 을 알 게 되 었 습 니 다.이상 하지 않 습 니까?이런 머리 없 는 조작 은 당연히 피해 야 합 니 다.
우 리 는 이 함수 들 의 이름 은 다 르 지만 처리 논리 가 같은 슬 래 그 를 모두 하나의 함수 에 밀봉 해 야 한다.그리고 이 함 수 는 매개 변수 로 고급 함수 에 할당 할 것 이다.운행 결 과 는 들 어 오 는 매개 변수 유형 과 만 관계 가 있다.즉,cube,square,fact 를 하나의 f 로 일반화 하 는 것 이다.

def cube(n: Int) = n * n * n 
def id(n: Int) = n 
def square(n : Int) = n * n 
def fact(n: Int): Int = 
  if (n == 0) 1 else n * fact(n - 1) 
//    
def sum(f: Int=>Int, a:Int, b:Int): Int = 
  if(a>b) 0 else f(a)+sum(f, a+1, b)
//               
def sumCube(a: Int, b: Int): Int = sum(cube, a, b) 
def sumSquare(a: Int, b: Int): Int = sum(square, a, b) 
def sumFact(a: Int, b: Int): Int = sum(fact, a, b) 
def sumInt(a: Int, b: Int): Int = sum(id, a, b) 
 
 sumCube(1, 10) 
 sumInt(1, 10) 
 sumSquare(1, 10) 
 sumFact(1, 10)

그러나 이렇게 쓰 면 또 하나의 문제 가 있 습 니 다.바로 앞에서 cube,id 의 초기 정 의 를 정 의 했 습 니 다.그 다음 에 계속 정 의 를 내 려 야 합 니 다.사실은 포장 을 한 층 했 습 니 다.필요 없습니다.제거 하고 익명 함수 의 기능 을 사용 하여 호출 을 더욱 간소화 하 는 것 입 니 다.대부분의 상황 에서 우리 가 관심 을 가 지 는 것 은 고급 함수 이지 매개 변수 로 들 어 오 는 함수 가 아니 기 때문에 하나의 함 수 를 단독으로 정의 하 는 것 은 필요 하지 않다.칭찬 할 만 한 것 은 스칼라 에서 익명 함 수 를 정의 하 는 문법 이 매우 간단 하 다 는 것 이다.화살표 왼쪽 은 매개 변수 목록 이 고 오른쪽 은 함수 체 이 며 매개 변수의 유형 은 생략 할 수 있 으 며 스칼라 의 유형 추측 시스템 은 매개 변수의 유형 을 추측 할 수 있다.익명 함 수 를 사용 한 후,우리 의 코드 는 더욱 간결 해 졌 다.

//           
def fact(n: Int): Int = 
if (n == 0) 1 else n * fact(n - 1) 
 
def sum(f: Int => Int, a: Int, b: Int): Int = 
  if (a > b) 0 else f(a) + sum(f, a + 1, b) 
 
//               
def sumCube(a: Int, b: Int): Int = sum(x => x * x * x, a, b) 
def sumSquare(a: Int, b: Int): Int = sum(x => x * x, a, b) 
def sumFact(a: Int, b: Int): Int = sum(fact, a, b) 
def sumInt(a: Int, b: Int): Int = sum(x => x, a, b) 
 

sumCube(1, 10) 
sumInt(1, 10) 
sumSquare(1, 10) 
sumFact(1, 10)

여기까지 쓰 면 문제 가 해결 되 는 차이 가 많 지 않 습 니 다.그러나 우 리 는 함수 식 프로 그래 밍 의 참뜻 을 자세히 생각해 보 겠 습 니 다.하 나 는 다른 출력 에 입력 합 니 다.이렇게 두 개의 매개 변수 가 전달 되 는 것 이 아니 라 매우 번 거 로 워 보 입 니 다.

def fact(n: Int): Int = 
if (n == 0) 1 else n * fact(n - 1) 
 
//     
def sum(f: Int => Int): (Int, Int) => Int = { 
  def sumF(a: Int, b: Int): Int = 
   if (a > b) 0 else f(a) + sumF(a + 1, b) 
 
  sumF 
} 
//               
def sumCube: Int = sum(x => x * x * x) 
def sumSquare: Int = sum(x => x * x) 
def sumFact: Int = sum(fact) 
def sumInt: Int = sum(x => x) 
 
//                ! 
sumCube(1, 10) 
sumInt(1, 10) 
sumSquare(1, 10) 
sumFact(1, 10)

실제로 이때 sum 에 들 어 오 는 것 은 익명 함수 입 니 다.g(f(x)에 있 는 f(x)와 유사 합 니 다.뇌 보 연산 이 아 닌 그 f(x)를 호출 해 야 합 니 다.
다시 한 번 뇌 동 을 열 어 보 겠 습 니 다.sum 이 함수 로 돌아 온 이상 우 리 는 이 함수 들 을 직접 사용 할 수 있 습 니 다.호출 명령 을 다시 한 번 쓸 필요 가 없습니다.sumCube(1,10)류 의 문 구 는 생략 할 수 있 습 니 다.

def fact(n: Int): Int = 
  if (n == 0) 1 else n * fact(n - 1) 
 
//     
def sum(f: Int => Int): (Int, Int) => Int = { 
  def sumF(a: Int, b: Int): Int = 
   if (a > b) 0 else f(a) + sumF(a + 1, b) 
  sumF 
}

//          ! 
sum(x => x * x * x) (1, 10) //=> sumCube(1, 10) 
sum(x => x) (1, 10)      //=> sumInt(1, 10) 
sum(x => x * x) (1, 10)   //=> sumSquare(1, 10) 
sum(fact) (1, 10)       //=> sumFact(1, 10)

마지막 으로 우 리 는 고급 함수 의 문법 설탕 을 사용 하여 이 코드 를 더욱 최적화 시 킬 수 있다. 

//         sum   
 def sum(f: Int => Int): (Int, Int): Int = { 
 def sumF(a: Int, b: Int): Int = 
  if (a > b) 0 else f(a) + sumF(a + 1, b) 
 
 sumF 
} 
//         sum   
 def sum(f: Int => Int)(a: Int, b: Int): Int = 
 if (a > b) 0 else f(a) + sum(f)(a + 1, b)

나 는 오히려 문법 사탕 으로 조금 더 쉽게 이해 할 수 있 고 우리 가 배 운 수학 언어 를 선 호한 다 고 생각한다.
독자 들 은 우리 가 원래 의 sum 함 수 를 이런 형식 으로 바 꾸 면 좋 은 점 이 어디 에 있 느 냐 고 물 을 수 있다.답 은 우리 가 더 많은 가능성 을 얻 었 다 는 것 이다.예 를 들 어 처음에 구 화 된 상하 한 이 아직 확정 되 지 않 았 다.우 리 는 프로그램 에서 하나의 함 수 를 sum 에 게 전달 할 수 있다.sum(fact)은 완전히 합 법 적 인 표현 식 이 고 후속 적 인 상하 한 이 확정 되 었 을 때 다른 두 개의 매개 변 수 를 전달 할 수 있다.sum 함수 에 대해 우 리 는 a,b 매개 변 수 를 다시 바 꿀 수 있 습 니 다.그러면 sum 함 수 는 이러한 함수 가 됩 니 다.매번 하나의 매개 변 수 를 받 을 수 있 고 다른 매개 변 수 를 받 는 함수 로 돌아 갑 니 다.호출 한 후에 하나의 매개 변수 만 받 는 함수 로 돌아 갑 니 다.이것 이 바로 전설의 코 리 화,얼마나 완벽 한 형식 인가!현실 세계 에서 이러한 함수 식 프로 그래 밍 언어 가 있 습 니 다.바로 Haskell 입 니 다.Haskell 에서 모든 함 수 는 콜 리 화 되 었 습 니 다.즉,모든 함 수 는 하나의 매개 변수 만 받 습 니 다!

//       sum   
 def sum(f: Int => Int)(a: Int) (b: Int): Int = 
if (a > b) 0 else f(a) + sum(f)(a + 1)(b) 
 
//             ! 
 sum(x => x * x * x)(1)(10) //=> sumCube(1, 10) 
 sum(x => x)(1)(10)      //=> sumInt(1, 10)
 

궁금 한 점 이 있 으 시 면 메 시 지 를 남기 거나 본 사이트 의 커 뮤 니 티 에 가서 토론 을 하 세 요.읽 어 주 셔 서 감사합니다. 도움 이 되 었 으 면 좋 겠 습 니 다.본 사이트 에 대한 지지 에 감 사 드 립 니 다!