from partial import _, __, ___

pc = _.partial(print, 1)
pc(2)
# 결과: 1 2
# 2 가 오른쪽으로 들어갑니다.
pc(2, 3)
# 결과: 1 2 3
# 2, 3이 오른쪽으로 들어갑니다.

pc = _.partial(print, _, 2)
pc(1)
# 결과: 1 2
# 1이 왼쪽의 _ 자리에 들어갑니다.
pc(1, 3)
# 결과: 1 2 3
# 1이 왼쪽의 _ 자리에 들어가고 3이 오른쪽으로 들어갑니다.

pc = _.partial(print, _, _, 3)
pc(1)
# 결과: 1 undefined 3
# 1이 왼쪽의 _ 자리에 들어가고 두 번째 _는 들어오지 않아 undefined가 됩니다.
pc(1, 2)
# 결과: 1 2 3
# 1과 2가 순서대로 _, _를 채웁니다.
pc(1, 2, 4)
# 결과: 1 2 3 4
# 1과 2가 순서대로 _, _를 채우고 3의 오른쪽으로 4가 들어갑니다.

pc = _.partial(print, _, 2, _, 4)
pc(1, 3, 5)
# 결과: 1 2 3 4 5
# 1을 _ 자리에 채우고 2를 넘겨서 _에 3을 채우고 4의 오른쪽에 5가 들어갑니다.

pc = _.partial(print, _, 2, _, _, 5)
pc(1, 3, 4, 6)
# 결과: 1 2 3 4 5 6
# 1을 _ 자리에 채우고 2를 넘겨서 _에 3을 채우고 다음 _에 4를 채우고 5의 오른쪽에 6이 들어갑니다.

pc = _.partial(print, ___, 2, 3)
pc(1)
# 결과: 1 2 3
# ___ 자리에 1이 들어가고 2, 3은 맨 오른쪽에 들어갑니다.
pc(1, 4, 5, 6)
# 결과: 1 4 5 6 2 3
# ___ 자리에 1, 4, 5, 6이 들어가고 2, 3은 맨 오른쪽에 들어갑니다.

pc = _.partial(print, _, 2, ___, 6)
pc(1, 3, 4, 5)
# 결과: 1 2 3 4 5 6
# _에 1이 들어가고 2를 넘어가고 ___ 자리에 3, 4, 5가 채워지고 6이 맨 오른쪽에 들어갑니다.
pc(1, 3, 4, 5, 7, 8, 9)
# 결과: 1 2 3 4 5 7 8 9 6
# _에 1이 들어가고 2를 넘어가고 ___ 자리에 3, 4, 5, 7, 8, 9가 채워지고 6이 맨 오른쪽에 들어갑니다.

pc = _.partial(print, _, 2, ___, 5, _, 7)
pc(1)
# 결과: 1 2 5 undefined 7
# _ 자리에 1이 들어가고 2와 5사이는 유동적이므로 모이고 5가 들어간 후 _가 undefined로 대체 되고 7이 들어갑니다.
pc(1, 3, 4)
# 결과: 1 2 3 5 4 7
# _ 자리에 1이 들어가고 2와 5사이에 3이 들어가고 _ 를 4로 채운 후 7이 들어갑니다.
# 왼쪽의 _ 들이 우선 순위가 제일 높고 ___ 보다 오른쪽의 _ 들이 우선순위가 높습니다.
pc(1, 3, 4, 6, 8)
# 결과: 1 2 3 4 6 5 8 7
# _ 자리에 1이 들어가고 2와 5사이에 3, 4, 6이 들어가고 _ 를 8로 채운 후 7이 들어갑니다.

def add (a, b): 
  return a + b
  
add10 = _(add, 10)
print( add10(5) )
# 15

_.go(10, # 첫 번째 함수에서 사용할 인자
  lambda a: a * 10, # 연속 실행할 함수 1
  # 100
  lambda a: a - 50, # 연속 실행할 함수 2
  # 50
  lambda a: a + 10) # 연속 실행할 함수 3
  # 60

_.go(10, # 첫 번째 함수에서 사용할 인자
  lambda a: _.mr(a * 10, 50), # 두 개의 값을 리턴
  lambda a, b: a - b, # 두 개의 인자 받기
  lambda a: a + 10)
  # 60

_.go(_.mr(2, 3),
  lambda a, b: a + b, # 2 + 3
  lambda a: a * a)
  # 25

def add(a, b):
  return a + b
  
def square(a):
  return a * a
  
_.go(_.mr(2, 3), add, square)
# 25

f1 = _.pipe(add, square)
f1(2, 3)
# 25

values = lambda data: _.map(data, lambda v, *r: v)
print(values({ 'a': 1, 'b': 2, 'c': 4 }))
# [1, 2, 4]

take3 = lambda data: _.take(data, 3)
take3([1, 2, 3, 4, 5])
# [1, 2, 3]

values = _.map(lambda v, *r: v)
print(values({ 'a': 1, 'b': 2, 'c': 4 }))
# [1, 2, 4]

take3 = _.take(3)
take3([1, 3, 5, 7, 9])
# [1, 3, 5]

users = [
  { 'id': 1, 'name': 'ID', 'age': 32 },
  { 'id': 2, 'name': 'HA', 'age': 25 },
  { 'id': 3, 'name': 'BJ', 'age': 32 },
  { 'id': 4, 'name': 'PJ', 'age': 28 },
  { 'id': 5, 'name': 'JE', 'age': 27 },
  { 'id': 6, 'name': 'JM', 'age': 32 },
  { 'id': 7, 'name': 'JI', 'age': 31 }
]

## 일반적인 사용
_.go(users,
  lambda users: _.filter(users, lambda u, *r: u['age'] < 30),
  lambda users: _.pluck(users, 'name'),
  print)
# ['HA', 'PJ', 'JE']

## 부분 커링이 된다면
_.go(users,
  _.filter(lambda u, *r: u['age'] < 30),
  _.pluck('name'),
  print)
# ['HA', 'PJ', 'JE']

## Underscore.py 체인
underscore\
  .chain(users)\
  .filter(lambda u: u['age'] < 30)\
  .pluck('name')\
  .tap(print)
# ['HA', 'PJ', 'JE']

products = [
  { 'id': 1, 'name': '후드 집업', 'discounted_price': 6000, 'price': 10000  },
  { 'id': 2, 'name': '코잼 후드티', 'discounted_price': 8000, 'price': 8000  },
  { 'id': 3, 'name': 'A1 반팔티', 'discounted_price': 6000, 'price': 6000  },
  { 'id': 4, 'name': '코잼 반팔티', 'discounted_price': 5000, 'price': 6000  }
]

# 할인 상품들을 가격이 낮은 순으로 정렬한 상품 이름들
_.go(products,
  _.filter(lambda p, *r: p['price'] > p['discounted_price']),
  _.sortBy('discounted_price'),
  _.pluck('name'),
  print)
  # ['코잼 반팔티', '후드 집업']

# 할인이 없는 상품들의 id들
_.go(products,
  _.reject(lambda p, *r: p['price'] > p['discounted_price']),
  _.pluck('id'),
  print)
  # [2, 3]

# 할인 상품 중 할인액이 가장 낮은 상품의 이름
_.go(products,
  _.filter(lambda p, *r: p['price'] > p['discounted_price']),
  _.min(lambda p, *r: p['price'] - p['discounted_price']),
  _.val('name'),
  print)
  # 코잼 반팔티

# 할인액이 가장 높은 상품의 이름
_.go(products,
  _.max(lambda p, *r: p['price'] - p['discounted_price']),
  _.val('name'),
  print)
  # 후드 집업

async def asy_add(val, *r):
  await asyncio.sleep(1)
  return val + 10
  
## await 키워드를 사용해서 바로 실행하는 _.go.asy
await _.asy.go(10,
  asy_add,
  print)
  # 20
  
## _.asy.pipe로 비동기 함수와 동기 함수 조합해 만든 새로운 함수
asy_pipe = _.asy.pipe(asy_add, print)
await asy_pipe(10) 
# 20

## _.pipe는 비동기 함수를 만나면 자동으로 _.asy.pipe가 됩니다.
asy_pipe = _.pipe(asy_add, print)
await asy_pipe(10)
# 20

async def asyncDate(*r):
  await asyncio.sleep(1)
  return datetime.datetime.now()

def syncDate(*r):
  return datetime.datetime.now()

_.go(
  [1, 2, 3],
  _.map(syncDate),
  _.map(lambda now, *r: now.strftime('%Y-%m-%d %H:%M:%S')),
  print)
# ['2017-06-16 12:34:39', '2017-06-16 12:34:39', '2017-06-16 12:34:39']

await _.asy.go(
  [1, 2, 3],
  _.map(asyncDate),
  _.map(lambda now, *r: now.strftime('%Y-%m-%d %H:%M:%S')),
  print)
# ['2017-06-16 12:34:39', '2017-06-16 12:34:39', '2017-06-16 12:34:39']

list = [1, 2, 3, 4, 5, 6]
_.go(list,
  _.map(lambda v, *r: v * v), # 6번
  _.filter(lambda v, *r: v < 20), # 6번
  _.take(2),
  print)
# [1, 4]
# 총 12번

list = [1, 2, 3, 4, 5, 6]
_.go(list,
  L.map(lambda v, *r: v * v), # 2번
  L.filter(lambda v, *r: v < 20), # 2번
  L.take(2),
  print)
# [1, 4]
# 총 4번  

users = [
  { 'id': 1, 'name': 'ID', 'age': 12 },
  { 'id': 2, 'name': 'BJ', 'age': 28 },
  { 'id': 3, 'name': 'HA', 'age': 13 },
  { 'id': 4, 'name': 'PJ', 'age': 23 },
  { 'id': 5, 'name': 'JE', 'age': 29 },
  { 'id': 6, 'name': 'JM', 'age': 32 },
  { 'id': 7, 'name': 'JE', 'age': 31 },
  { 'id': 8, 'name': 'HI', 'age': 15 },
  { 'id': 9, 'name': 'HO', 'age': 28 },
  { 'id': 10, 'name': 'KO', 'age': 34 }
]

# 10대 2명까지만 찾아내기
_.go(users,
  L.filter(lambda user, *r : user['age'] < 20),
  L.take(2),
  print)
# [{ 'id': 1, 'name': 'ID', 'age': 12 }, { 'id': 3, 'name': 'HA', 'age': 13 }]
# 3번만 반복

# 10대 2명까지만 찾아내서 이름 수집하기
_.go(users,
  L.filter(lambda user, *r : user['age'] < 20),
  L.map(lambda v, *r : v['name']),
  L.take(2),
  print)
# ['ID', 'HA']
# 3번만 반복

strict_or_lazy1 = __(
  _.range,
  L.strict(100),
  L.map(lambda v, *r: v * v),
  L.filter(lambda v, *r: _.bool(v % 2)),
  L.take(10),
  print)

strict_or_lazy1(50)
# [1, 9, 25, 49, 81, 121, 169, 225, 289, 361]
# 50 번 반복 (염격)

strict_or_lazy1(100)
# [1, 9, 25, 49, 81, 121, 169, 225, 289, 361]
# 20 번 반복 (지연)

strict_or_lazy1(15)
# [1, 9, 25, 49, 81, 121, 169]
# 15 번 반복 (엄격)

strict_or_lazy2 = __(
  _.range,
  L.strict(lambda list, *r : len(list) < 100),
  L.map(lambda v, *r : v * v),
  L.filter(lambda v, *r : bool(v % 2)),
  L.take(10),
  print)

strict_or_lazy2(50)
# [1, 9, 25, 49, 81, 121, 169, 225, 289, 361]
# 50 번 반복 (염격)

strict_or_lazy2(100)
# [1, 9, 25, 49, 81, 121, 169, 225, 289, 361]
# 20 번 반복 (지연)

strict_or_lazy2(15)
# [1, 9, 25, 49, 81, 121, 169]
# 15 번 반복 (엄격)