function.js

/**
 * 函数式编程工具函数
 * 
 * wjs-js-toolkit 工具库
 * 提供常用的函数式编程方法和工具函数，包括柯里化、组合、节流、防抖、缓存、重试等
 * 
 * @module function
 * @author wjs
 */

/**
 * 函数柯里化
 * @param {Function} func - 函数
 * @param {number} arity - 参数个数
 * @returns {Function} - 柯里化后的函数
 *
 * wjs created by 2015-06-01
 */
function wjs_curry(func, arity) {
  arity = arity || func.length
  return function curried() {
    var args = Array.prototype.slice.call(arguments)
    if (args.length >= arity) {
      return func.apply(this, args)
    }
    return function() {
      return curried.apply(this, args.concat(Array.prototype.slice.call(arguments)))
    }
  }
}

/**
 * 函数反柯里化
 * @param {Function} func - 函数
 * @returns {Function} - 反柯里化后的函数
 *
 * wjs created by 2015-06-05
 */
function wjs_uncurry(func) {
  return function() {
    var args = Array.prototype.slice.call(arguments)
    var context = args.shift()
    return func.apply(context, args)
  }
}

/**
 * 函数组合
 * @param {...Function} funcs - 函数列表
 * @returns {Function} - 组合后的函数
 *
 * wjs created by 2015-06-10
 */
function wjs_compose() {
  var funcs = Array.prototype.slice.call(arguments)
  return function(x) {
    return funcs.reduceRight(function(acc, fn) {
      return fn(acc)
    }, x)
  }
}

/**
 * 函数管道（从左到右执行）
 * @param {...Function} funcs - 函数列表
 * @returns {Function} - 管道函数
 *
 * wjs created by 2015-07-01
 */
function wjs_pipe() {
  var funcs = Array.prototype.slice.call(arguments)
  return function(x) {
    return funcs.reduce(function(acc, fn) {
      return fn(acc)
    }, x)
  }
}

/**
 * 函数节流（时间戳版）
 * @param {Function} func - 函数
 * @param {number} wait - 等待时间
 * @returns {Function} - 节流后的函数
 *
 * wjs created by 2015-07-05
 */
function wjs_throttleTimestamp(func, wait) {
  var previous = 0
  return function() {
    var now = Date.now()
    if (now - previous >= wait) {
      func.apply(this, arguments)
      previous = now
    }
  }
}

/**
 * 函数防抖（定时器版）
 * @param {Function} func - 函数
 * @param {number} wait - 等待时间
 * @returns {Function} - 防抖后的函数
 *
 * wjs created by 2015-07-10
 */
function wjs_debounceTimer(func, wait) {
  var timeout = null
  return function() {
    clearTimeout(timeout)
    timeout = setTimeout(function() {
      func.apply(this, arguments)
    }.bind(this), wait)
  }
}

/**
 * 函数缓存
 * @param {Function} func - 函数
 * @param {Function} hashFn - 哈希函数
 * @returns {Function} - 带缓存的函数
 *
 * wjs created by 2015-08-01
 */
function wjs_memoize(func, hashFn) {
  var cache = {}
  hashFn = hashFn || function() {
    return JSON.stringify(arguments)
  }
  return function() {
    var key = hashFn.apply(this, arguments)
    if (cache[key]) {
      return cache[key]
    }
    var result = func.apply(this, arguments)
    cache[key] = result
    return result
  }
}

/**
 * 函数记忆（带过期时间）
 * @param {Function} func - 函数
 * @param {number} ttl - 过期时间（毫秒）
 * @returns {Function} - 带记忆的函数
 *
 * wjs created by 2015-08-05
 */
function wjs_memoizeWithTtl(func, ttl) {
  var cache = {}
  return function() {
    var key = JSON.stringify(arguments)
    var now = Date.now()
    if (cache[key] && now - cache[key].timestamp < ttl) {
      return cache[key].value
    }
    var result = func.apply(this, arguments)
    cache[key] = { value: result, timestamp: now }
    return result
  }
}

/**
 * 函数参数预填充（偏函数）
 * @param {Function} func - 函数
 * @param {...*} args - 预填充参数
 * @returns {Function} - 偏函数
 *
 * wjs created by 2015-08-10
 */
function wjs_partial(func) {
  var args = Array.prototype.slice.call(arguments, 1)
  return function() {
    var newArgs = args.concat(Array.prototype.slice.call(arguments))
    return func.apply(this, newArgs)
  }
}

/**
 * 函数参数反转
 * @param {Function} func - 函数
 * @returns {Function} - 参数反转后的函数
 *
 * wjs created by 2015-09-01
 */
function wjs_reverseArgs(func) {
  return function() {
    var args = Array.prototype.slice.call(arguments).reverse()
    return func.apply(this, args)
  }
}

/**
 * 函数参数交换
 * @param {Function} func - 函数
 * @returns {Function} - 参数交换后的函数
 *
 * wjs created by 2015-09-05
 */
function wjs_swapArgs(func) {
  return function(a, b) {
    return func.call(this, b, a)
  }
}

/**
 * 函数执行次数限制
 * @param {Function} func - 函数
 * @param {number} times - 最大执行次数
 * @returns {Function} - 限制后的函数
 *
 * wjs created by 2015-09-10
 */
function wjs_limitCalls(func, times) {
  var count = 0
  return function() {
    if (count < times) {
      count++
      return func.apply(this, arguments)
    }
  }
}

/**
 * 函数只执行一次
 * @param {Function} func - 函数
 * @returns {Function} - 只执行一次的函数
 *
 * wjs created by 2015-10-01
 */
function wjs_once(func) {
  var called = false
  var result
  return function() {
    if (!called) {
      called = true
      result = func.apply(this, arguments)
    }
    return result
  }
}

/**
 * 函数延迟执行
 * @param {Function} func - 函数
 * @param {number} delay - 延迟时间（毫秒）
 * @returns {number} - 定时器ID
 *
 * wjs created by 2015-10-05
 */
function wjs_delayCall(func, delay) {
  return setTimeout(func, delay)
}

/**
 * 函数立即执行
 * @param {Function} func - 函数
 * @returns {*} - 函数返回值
 *
 * wjs created by 2015-10-10
 */
function wjs_immediateCall(func) {
  return func()
}

/**
 * 函数异步执行
 * @param {Function} func - 函数
 * @returns {Function} - 异步函数
 *
 * wjs created by 2015-11-01
 */
function wjs_asyncCall(func) {
  return function() {
    var args = arguments
    setTimeout(function() {
      func.apply(this, args)
    }.bind(this), 0)
  }
}

/**
 * 函数错误捕获
 * @param {Function} func - 函数
 * @param {Function} fallback - 错误处理函数
 * @returns {Function} - 带错误处理的函数
 *
 * wjs created by 2015-11-05
 */
function wjs_catchError(func, fallback) {
  return function() {
    try {
      return func.apply(this, arguments)
    } catch (e) {
      if (fallback) {
        return fallback(e)
      }
      console.error(e)
    }
  }
}

/**
 * 函数错误重试
 * @param {Function} func - 函数
 * @param {number} retries - 重试次数
 * @returns {Function} - 带重试的函数
 *
 * wjs created by 2015-11-10
 */
function wjs_retry(func, retries) {
  return function() {
    var args = arguments
    var attempt = 0
    
    var tryAgain = function() {
      try {
        return func.apply(this, args)
      } catch (e) {
        if (attempt < retries) {
          attempt++
          return tryAgain.apply(this)
        }
        throw e
      }
    }.bind(this)
    
    return tryAgain()
  }
}

/**
 * 函数超时处理
 * @param {Function} func - 函数
 * @param {number} timeout - 超时时间（毫秒）
 * @returns {Promise} - Promise对象
 *
 * wjs created by 2015-12-01
 */
function wjs_timeout(func, timeout) {
  return new Promise(function(resolve, reject) {
    var timer = setTimeout(function() {
      reject(new Error('Timeout'))
    }, timeout)
    
    try {
      var result = func()
      clearTimeout(timer)
      resolve(result)
    } catch (e) {
      clearTimeout(timer)
      reject(e)
    }
  })
}

/**
 * 函数时间测量
 * @param {Function} func - 函数
 * @returns {Object} - {result, time}
 *
 * wjs created by 2015-12-05
 */
function wjs_measureTime(func) {
  var start = Date.now()
  var result = func()
  var end = Date.now()
  return {
    result: result,
    time: end - start
  }
}

/**
 * 函数调用次数统计
 * @param {Function} func - 函数
 * @returns {Function} - 带统计的函数
 *
 * wjs created by 2015-12-10
 */
function wjs_countCalls(func) {
  var count = 0
  var wrapped = function() {
    count++
    return func.apply(this, arguments)
  }
  wrapped.getCount = function() { return count }
  return wrapped
}

/**
 * 函数调用日志
 * @param {Function} func - 函数
 * @param {string} name - 函数名
 * @returns {Function} - 带日志的函数
 *
 * wjs created by 2016-01-01
 */
function wjs_logCalls(func, name) {
  return function() {
    console.log('[wjs_log] ' + (name || func.name) + ' called with:', arguments)
    var result = func.apply(this, arguments)
    console.log('[wjs_log] ' + (name || func.name) + ' returned:', result)
    return result
  }
}

/**
 * 函数性能监控
 * @param {Function} func - 函数
 * @param {number} threshold - 阈值（毫秒）
 * @returns {Function} - 带监控的函数
 *
 * wjs created by 2016-01-05
 */
function wjs_monitorPerformance(func, threshold) {
  return function() {
    var start = Date.now()
    var result = func.apply(this, arguments)
    var end = Date.now()
    if (end - start > threshold) {
      console.warn('[wjs_perf] ' + func.name + ' took ' + (end - start) + 'ms')
    }
    return result
  }
}

/**
 * 函数上下文绑定
 * @param {Function} func - 函数
 * @param {Object} context - 上下文
 * @returns {Function} - 绑定后的函数
 *
 * wjs created by 2016-01-10
 */
function wjs_bind(func, context) {
  return function() {
    return func.apply(context, arguments)
  }
}

/**
 * 函数部分应用（右偏）
 * @param {Function} func - 函数
 * @param {...*} args - 尾部参数
 * @returns {Function} - 偏函数
 *
 * wjs created by 2016-02-01
 */
function wjs_partialRight(func) {
  var args = Array.prototype.slice.call(arguments, 1)
  return function() {
    var newArgs = Array.prototype.slice.call(arguments).concat(args)
    return func.apply(this, newArgs)
  }
}

/**
 * 函数参数展开
 * @param {Function} func - 函数
 * @returns {Function} - 参数展开后的函数
 *
 * wjs created by 2016-02-05
 */
function wjs_spreadArgs(func) {
  return function(args) {
    return func.apply(this, args)
  }
}

/**
 * 函数参数收集
 * @param {Function} func - 函数
 * @returns {Function} - 参数收集后的函数
 *
 * wjs created by 2016-02-10
 */
function wjs_gatherArgs(func) {
  return function() {
    return func.call(this, Array.prototype.slice.call(arguments))
  }
}

/**
 * 函数条件执行
 * @param {Function} condition - 条件函数
 * @param {Function} func - 函数
 * @returns {Function} - 条件执行函数
 *
 * wjs created by 2016-03-01
 */
function wjs_when(condition, func) {
  return function() {
    if (condition.apply(this, arguments)) {
      return func.apply(this, arguments)
    }
  }
}

/**
 * 函数否定执行
 * @param {Function} func - 函数
 * @returns {Function} - 否定函数
 *
 * wjs created by 2016-03-05
 */
function wjs_not(func) {
  return function() {
    return !func.apply(this, arguments)
  }
}

/**
 * 函数与操作
 * @param {...Function} funcs - 函数列表
 * @returns {Function} - 与操作函数
 *
 * wjs created by 2016-03-10
 */
function wjs_and() {
  var funcs = Array.prototype.slice.call(arguments)
  return function() {
    for (var i = 0; i < funcs.length; i++) {
      if (!funcs[i].apply(this, arguments)) {
        return false
      }
    }
    return true
  }
}

/**
 * 函数或操作
 * @param {...Function} funcs - 函数列表
 * @returns {Function} - 或操作函数
 *
 * wjs created by 2016-04-01
 */
function wjs_or() {
  var funcs = Array.prototype.slice.call(arguments)
  return function() {
    for (var i = 0; i < funcs.length; i++) {
      if (funcs[i].apply(this, arguments)) {
        return true
      }
    }
    return false
  }
}

/**
 * 函数异或操作
 * @param {Function} func1 - 函数1
 * @param {Function} func2 - 函数2
 * @returns {Function} - 异或操作函数
 *
 * wjs created by 2016-04-05
 */
function wjs_xor(func1, func2) {
  return function() {
    var result1 = func1.apply(this, arguments)
    var result2 = func2.apply(this, arguments)
    return result1 !== result2
  }
}

/**
 * 函数常量返回
 * @param {*} value - 常量值
 * @returns {Function} - 常量函数
 *
 * wjs created by 2016-04-10
 */
function wjs_constant(value) {
  return function() {
    return value
  }
}

/**
 * 函数恒等函数
 * @param {*} value - 值
 * @returns {*} - 原值
 *
 * wjs created by 2016-05-01
 */
function wjs_identity(value) {
  return value
}

/**
 * 函数空操作
 *
 * wjs created by 2016-05-05
 */
function wjs_noop() {}

/**
 * 函数抛错
 * @param {Error|string} error - 错误对象或消息
 * @returns {Function} - 抛错函数
 *
 * wjs created by 2016-05-10
 */
function wjs_throwError(error) {
  return function() {
    throw typeof error === 'string' ? new Error(error) : error
  }
}

/**
 * 函数延迟返回
 * @param {Function} func - 函数
 * @param {number} delay - 延迟时间（毫秒）
 * @returns {Function} - 延迟返回函数
 *
 * wjs created by 2016-06-01
 */
function wjs_delayedReturn(func, delay) {
  return function() {
    var args = arguments
    var context = this
    setTimeout(function() {
      func.apply(context, args)
    }, delay)
  }
}

/**
 * 函数批量执行
 * @param {Array} funcs - 函数数组
 * @param {...*} args - 参数
 *
 * wjs created by 2016-06-05
 */
function wjs_batchExecute(funcs) {
  var args = Array.prototype.slice.call(arguments, 1)
  funcs.forEach(function(func) {
    func.apply(null, args)
  })
}

/**
 * 函数顺序执行
 * @param {Array} funcs - 函数数组
 * @returns {Promise} - Promise对象
 *
 * wjs created by 2016-06-10
 */
function wjs_sequentialExecute(funcs) {
  return funcs.reduce(function(prev, func) {
    return prev.then(func)
  }, Promise.resolve())
}

/**
 * 函数并行执行
 * @param {Array} funcs - 函数数组
 * @returns {Promise} - Promise对象
 *
 * wjs created by 2016-07-01
 */
function wjs_parallelExecute(funcs) {
  return Promise.all(funcs.map(function(func) {
    return func()
  }))
}

/**
 * 函数竞争执行（取最快完成的）
 * @param {Array} funcs - 函数数组
 * @returns {Promise} - Promise对象
 *
 * wjs created by 2016-07-05
 */
function wjs_raceExecute(funcs) {
  return Promise.race(funcs.map(function(func) {
    return func()
  }))
}

/**
 * 函数重试执行（带延迟）
 * @param {Function} func - 函数
 * @param {number} retries - 重试次数
 * @param {number} delay - 延迟时间（毫秒）
 * @returns {Promise} - Promise对象
 *
 * wjs created by 2016-07-10
 */
function wjs_retryWithDelay(func, retries, delay) {
  return function() {
    var args = arguments
    var attempt = 0
    
    var tryAgain = function() {
      return new Promise(function(resolve, reject) {
        try {
          var result = func.apply(this, args)
          resolve(result)
        } catch (e) {
          if (attempt < retries) {
            attempt++
            setTimeout(function() {
              tryAgain().then(resolve).catch(reject)
            }, delay)
          } else {
            reject(e)
          }
        }
      }.bind(this))
    }.bind(this)
    
    return tryAgain()
  }
}

/**
 * 函数防抖（带最大等待时间）
 * @param {Function} func - 函数
 * @param {number} wait - 等待时间
 * @param {number} maxWait - 最大等待时间
 * @returns {Function} - 防抖后的函数
 *
 * wjs created by 2016-08-01
 */
function wjs_debounceWithMaxWait(func, wait, maxWait) {
  var timeout = null
  var lastCallTime = 0
  
  return function() {
    var now = Date.now()
    var args = arguments
    var context = this
    
    if (now - lastCallTime >= maxWait) {
      func.apply(context, args)
      lastCallTime = now
    } else {
      clearTimeout(timeout)
      timeout = setTimeout(function() {
        func.apply(context, args)
        lastCallTime = Date.now()
      }, wait)
    }
  }
}

/**
 * 函数节流（带尾部执行）
 * @param {Function} func - 函数
 * @param {number} wait - 等待时间
 * @returns {Function} - 节流后的函数
 *
 * wjs created by 2016-08-05
 */
function wjs_throttleWithTail(func, wait) {
  var timeout = null
  var previous = 0
  
  return function() {
    var now = Date.now()
    var args = arguments
    var context = this
    
    if (now - previous >= wait) {
      if (timeout) {
        clearTimeout(timeout)
        timeout = null
      }
      func.apply(context, args)
      previous = now
    } else if (!timeout) {
      timeout = setTimeout(function() {
        func.apply(context, args)
        previous = Date.now()
        timeout = null
      }, wait - (now - previous))
    }
  }
}

/**
 * 函数防抖节流组合
 * @param {Function} func - 函数
 * @param {number} wait - 等待时间
 * @param {number} maxWait - 最大等待时间
 * @returns {Function} - 组合后的函数
 *
 * wjs created by 2016-08-10
 */
function wjs_debounceThrottle(func, wait, maxWait) {
  var debounced = wjs_debounceWithMaxWait(func, wait, maxWait)
  return function() {
    debounced.apply(this, arguments)
  }
}

/**
 * 函数条件重试
 * @param {Function} func - 函数
 * @param {Function} shouldRetry - 重试条件函数
 * @param {number} maxRetries - 最大重试次数
 * @returns {Function} - 带条件重试的函数
 *
 * wjs created by 2016-09-01
 */
function wjs_retryConditional(func, shouldRetry, maxRetries) {
  return function() {
    var args = arguments
    var attempt = 0
    
    var tryAgain = function() {
      var result = func.apply(this, args)
      if (shouldRetry(result) && attempt < maxRetries) {
        attempt++
        return tryAgain.apply(this)
      }
      return result
    }.bind(this)
    
    return tryAgain()
  }
}

/**
 * 函数指数退避重试
 * @param {Function} func - 函数
 * @param {number} maxRetries - 最大重试次数
 * @param {number} baseDelay - 基础延迟时间
 * @returns {Function} - 带指数退避的函数
 *
 * wjs created by 2016-09-05
 */
function wjs_retryExponentialBackoff(func, maxRetries, baseDelay) {
  return function() {
    var args = arguments
    var attempt = 0
    
    var tryAgain = function() {
      try {
        return func.apply(this, args)
      } catch (e) {
        if (attempt < maxRetries) {
          attempt++
          var delay = baseDelay * Math.pow(2, attempt) + Math.random() * 100
          setTimeout(function() {
            tryAgain.apply(this)
          }.bind(this), delay)
        } else {
          throw e
        }
      }
    }.bind(this)
    
    return tryAgain()
  }
}

/**
 * 函数超时重试
 * @param {Function} func - 函数
 * @param {number} timeout - 超时时间
 * @param {number} retries - 重试次数
 * @returns {Function} - 带超时重试的函数
 *
 * wjs created by 2016-09-10
 */
function wjs_timeoutRetry(func, timeout, retries) {
  return function() {
    var args = arguments
    var attempt = 0
    
    var tryAgain = function() {
      return wjs_timeout(function() {
        return func.apply(this, args)
      }, timeout).catch(function(e) {
        if (attempt < retries) {
          attempt++
          return tryAgain.apply(this)
        }
        throw e
      })
    }.bind(this)
    
    return tryAgain()
  }
}

/**
 * 函数轮询执行
 * @param {Function} func - 函数
 * @param {Function} condition - 停止条件
 * @param {number} interval - 轮询间隔
 * @returns {Function} - 轮询函数
 *
 * wjs created by 2016-10-01
 */
function wjs_poll(func, condition, interval) {
  return function() {
    var args = arguments
    var context = this
    
    var pollAgain = function() {
      var result = func.apply(context, args)
      if (!condition(result)) {
        setTimeout(pollAgain, interval)
      }
    }
    
    pollAgain()
  }
}

/**
 * 函数节流（RAF版）
 * @param {Function} func - 函数
 * @returns {Function} - 节流后的函数
 *
 * wjs created by 2016-10-05
 */
function wjs_throttleRaf(func) {
  var running = false
  
  return function() {
    if (!running) {
      running = true
      requestAnimationFrame(function() {
        func.apply(this, arguments)
        running = false
      }.bind(this))
    }
  }
}

/**
 * 函数防抖（RAF版）
 * @param {Function} func - 函数
 * @returns {Function} - 防抖后的函数
 *
 * wjs created by 2016-10-10
 */
function wjs_debounceRaf(func) {
  var frameId = null
  
  return function() {
    if (frameId) {
      cancelAnimationFrame(frameId)
    }
    var args = arguments
    var context = this
    frameId = requestAnimationFrame(function() {
      func.apply(context, args)
    })
  }
}

/**
 * 函数缓存清除
 * @param {Function} func - 带缓存的函数
 *
 * wjs created by 2016-11-01
 */
function wjs_clearCache(func) {
  if (func.cache) {
    func.cache = {}
  }
}

/**
 * 函数缓存大小限制
 * @param {Function} func - 函数
 * @param {number} maxSize - 最大缓存大小
 * @returns {Function} - 带缓存限制的函数
 *
 * wjs created by 2016-11-05
 */
function wjs_memoizeWithLimit(func, maxSize) {
  var cache = {}
  var keys = []
  
  return function() {
    var key = JSON.stringify(arguments)
    
    if (cache[key]) {
      return cache[key]
    }
    
    var result = func.apply(this, arguments)
    cache[key] = result
    keys.push(key)
    
    if (keys.length > maxSize) {
      delete cache[keys.shift()]
    }
    
    return result
  }
}

/**
 * 函数缓存淘汰策略（LRU）
 * @param {Function} func - 函数
 * @param {number} maxSize - 最大缓存大小
 * @returns {Function} - 带LRU缓存的函数
 *
 * wjs created by 2016-11-10
 */
function wjs_memoizeLru(func, maxSize) {
  var cache = {}
  var order = []
  
  return function() {
    var key = JSON.stringify(arguments)
    
    if (cache[key]) {
      var index = order.indexOf(key)
      if (index > -1) {
        order.splice(index, 1)
      }
      order.push(key)
      return cache[key]
    }
    
    var result = func.apply(this, arguments)
    cache[key] = result
    order.push(key)
    
    if (order.length > maxSize) {
      var oldestKey = order.shift()
      delete cache[oldestKey]
    }
    
    return result
  }
}

/**
 * 函数缓存淘汰策略（LFU）
 * @param {Function} func - 函数
 * @param {number} maxSize - 最大缓存大小
 * @returns {Function} - 带LFU缓存的函数
 *
 * wjs created by 2016-12-01
 */
function wjs_memoizeLfu(func, maxSize) {
  var cache = {}
  var freq = {}
  
  return function() {
    var key = JSON.stringify(arguments)
    
    if (cache[key]) {
      freq[key] = (freq[key] || 0) + 1
      return cache[key]
    }
    
    var result = func.apply(this, arguments)
    cache[key] = result
    freq[key] = 1
    
    if (Object.keys(cache).length > maxSize) {
      var minFreq = Infinity
      var minKey = null
      for (var k in freq) {
        if (freq[k] < minFreq) {
          minFreq = freq[k]
          minKey = k
        }
      }
      if (minKey) {
        delete cache[minKey]
        delete freq[minKey]
      }
    }
    
    return result
  }
}

/**
 * 函数组合（异步版）
 * @param {...Function} funcs - 函数列表
 * @returns {Function} - 组合后的函数
 *
 * wjs created by 2017-01-01
 */
function wjs_composeAsync() {
  var funcs = Array.prototype.slice.call(arguments)
  return function(x) {
    return funcs.reduceRight(function(acc, fn) {
      return acc.then(fn)
    }, Promise.resolve(x))
  }
}

/**
 * 函数管道（异步版）
 * @param {...Function} funcs - 函数列表
 * @returns {Function} - 管道函数
 *
 * wjs created by 2017-01-05
 */
function wjs_pipeAsync() {
  var funcs = Array.prototype.slice.call(arguments)
  return function(x) {
    return funcs.reduce(function(acc, fn) {
      return acc.then(fn)
    }, Promise.resolve(x))
  }
}

/**
 * 函数批量执行（异步版）
 * @param {Array} funcs - 函数数组
 * @param {...*} args - 参数
 * @returns {Promise} - Promise对象
 *
 * wjs created by 2017-01-10
 */
function wjs_batchExecuteAsync(funcs) {
  var args = Array.prototype.slice.call(arguments, 1)
  return Promise.all(funcs.map(function(func) {
    return func.apply(null, args)
  }))
}

/**
 * 函数顺序执行（异步版）
 * @param {Array} funcs - 函数数组
 * @returns {Promise} - Promise对象
 *
 * wjs created by 2017-02-01
 */
function wjs_sequentialExecuteAsync(funcs) {
  return funcs.reduce(function(prev, func) {
    return prev.then(func)
  }, Promise.resolve())
}

/**
 * 函数并行执行（异步版）
 * @param {Array} funcs - 函数数组
 * @returns {Promise} - Promise对象
 *
 * wjs created by 2017-02-05
 */
function wjs_parallelExecuteAsync(funcs) {
  return Promise.all(funcs.map(function(func) {
    return func()
  }))
}

/**
 * 函数并发控制
 * @param {Array} funcs - 函数数组
 * @param {number} limit - 并发限制
 * @returns {Promise} - Promise对象
 *
 * wjs created by 2017-02-10
 */
function wjs_concurrentExecute(funcs, limit) {
  return new Promise(function(resolve) {
    var results = []
    var executing = 0
    var index = 0
    
    var executeNext = function() {
      if (index >= funcs.length) {
        if (executing === 0) {
          resolve(results)
        }
        return
      }
      
      while (executing < limit && index < funcs.length) {
        var funcIndex = index++
        executing++
        
        funcs[funcIndex]().then(function(result) {
          results[funcIndex] = result
          executing--
          executeNext()
        }).catch(function(err) {
          results[funcIndex] = err
          executing--
          executeNext()
        })
      }
    }
    
    executeNext()
  })
}

/**
 * 函数限流执行
 * @param {Function} func - 函数
 * @param {number} maxPerSecond - 每秒最大执行次数
 * @returns {Function} - 限流后的函数
 *
 * wjs created by 2017-03-01
 */
function wjs_rateLimit(func, maxPerSecond) {
  var queue = []
  var lastExecTime = 0
  var interval = 1000 / maxPerSecond
  
  var execute = function() {
    var now = Date.now()
    if (now - lastExecTime >= interval && queue.length > 0) {
      var item = queue.shift()
      func.apply(item.context, item.args)
      lastExecTime = now
    }
    if (queue.length > 0) {
      setTimeout(execute, interval)
    }
  }
  
  return function() {
    queue.push({
      context: this,
      args: Array.prototype.slice.call(arguments)
    })
    if (queue.length === 1) {
      execute()
    }
  }
}

/**
 * 函数熔断机制
 * @param {Function} func - 函数
 * @param {number} failureThreshold - 失败阈值
 * @param {number} cooldownPeriod - 冷却时间（毫秒）
 * @returns {Function} - 带熔断的函数
 *
 * wjs created by 2017-03-05
 */
function wjs_circuitBreaker(func, failureThreshold, cooldownPeriod) {
  var state = 'closed'
  var failures = 0
  var lastFailureTime = 0
  
  return function() {
    var now = Date.now()
    
    if (state === 'open') {
      if (now - lastFailureTime >= cooldownPeriod) {
        state = 'half-open'
      } else {
        throw new Error('Circuit breaker is open')
      }
    }
    
    try {
      var result = func.apply(this, arguments)
      failures = 0
      state = 'closed'
      return result
    } catch (e) {
      failures++
      lastFailureTime = now
      
      if (failures >= failureThreshold) {
        state = 'open'
      }
      
      throw e
    }
  }
}

/**
 * 函数降级处理
 * @param {Function} primary - 主函数
 * @param {Function} fallback - 降级函数
 * @returns {Function} - 带降级的函数
 *
 * wjs created by 2017-03-10
 */
function wjs_fallback(primary, fallback) {
  return function() {
    try {
      return primary.apply(this, arguments)
    } catch (e) {
      return fallback.apply(this, arguments)
    }
  }
}

/**
 * 函数重试（异步版）
 * @param {Function} func - 函数
 * @param {number} retries - 重试次数
 * @returns {Function} - 带重试的函数
 *
 * wjs created by 2018-01-01
 */
function wjs_retryAsync(func, retries) {
  return function() {
    var args = arguments
    var attempt = 0
    
    var tryAgain = function() {
      return func.apply(this, args).catch(function(e) {
        if (attempt < retries) {
          attempt++
          return tryAgain.apply(this)
        }
        throw e
      })
    }.bind(this)
    
    return tryAgain()
  }
}

/**
 * 函数超时（异步版）
 * @param {Function} func - 函数
 * @param {number} timeout - 超时时间（毫秒）
 * @returns {Function} - 带超时的函数
 *
 * wjs created by 2018-01-05
 */
function wjs_timeoutAsync(func, timeout) {
  return function() {
    var args = arguments
    
    return Promise.race([
      func.apply(this, args),
      new Promise(function(_, reject) {
        setTimeout(function() {
          reject(new Error('Timeout'))
        }, timeout)
      })
    ])
  }
}

/**
 * 函数缓存（异步版）
 * @param {Function} func - 函数
 * @returns {Function} - 带缓存的函数
 *
 * wjs created by 2018-01-10
 */
function wjs_memoizeAsync(func) {
  var cache = {}
  
  return function() {
    var key = JSON.stringify(arguments)
    
    if (cache[key]) {
      return cache[key]
    }
    
    var promise = func.apply(this, arguments)
    cache[key] = promise
    
    promise.catch(function() {
      delete cache[key]
    })
    
    return promise
  }
}

/**
 * 函数批处理
 * @param {Function} func - 函数
 * @param {number} batchSize - 批处理大小
 * @param {number} delay - 延迟时间
 * @returns {Function} - 批处理函数
 *
 * wjs created by 2018-02-01
 */
function wjs_batchProcess(func, batchSize, delay) {
  var queue = []
  var timer = null
  
  var processBatch = function() {
    var batch = queue.splice(0, batchSize)
    if (batch.length > 0) {
      func(batch)
    }
    if (queue.length > 0) {
      timer = setTimeout(processBatch, delay)
    }
  }
  
  return function(item) {
    queue.push(item)
    if (!timer) {
      timer = setTimeout(processBatch, delay)
    }
  }
}

/**
 * 函数去重执行
 * @param {Function} func - 函数
 * @param {Function} keyFn - 键函数
 * @returns {Function} - 去重函数
 *
 * wjs created by 2018-02-05
 */
function wjs_dedupExecute(func, keyFn) {
  var executing = {}
  
  return function() {
    var key = keyFn ? keyFn.apply(this, arguments) : JSON.stringify(arguments)
    
    if (executing[key]) {
      return executing[key]
    }
    
    var promise = func.apply(this, arguments)
    executing[key] = promise
    
    promise.then(function() {
      delete executing[key]
    }).catch(function() {
      delete executing[key]
    })
    
    return promise
  }
}

/**
 * 函数缓存（带版本号）
 * @param {Function} func - 函数
 * @returns {Object} - 缓存控制对象
 *
 * wjs created by 2018-02-10
 */
function wjs_versionedCache(func) {
  var cache = {}
  var version = 0
  
  var wrapped = function() {
    var key = version + '_' + JSON.stringify(arguments)
    if (cache[key]) {
      return cache[key]
    }
    var result = func.apply(this, arguments)
    cache[key] = result
    return result
  }
  
  wrapped.invalidate = function() {
    version++
    cache = {}
  }
  
  wrapped.getVersion = function() {
    return version
  }
  
  return wrapped
}

/**
 * 函数延迟绑定
 * @param {Object} obj - 对象
 * @param {string} method - 方法名
 * @returns {Function} - 延迟绑定函数
 *
 * wjs created by 2019-01-01
 */
function wjs_lazyBind(obj, method) {
  return function() {
    return obj[method].apply(obj, arguments)
  }
}

/**
 * 函数自动柯里化
 * @param {Function} func - 函数
 * @returns {Function} - 自动柯里化函数
 *
 * wjs created by 2019-01-05
 */
function wjs_autoCurry(func) {
  return function curried() {
    var args = Array.prototype.slice.call(arguments)
    if (args.length >= func.length) {
      return func.apply(this, args)
    }
    return function() {
      return curried.apply(this, args.concat(Array.prototype.slice.call(arguments)))
    }
  }
}

/**
 * 函数递归优化（尾递归）
 * @param {Function} func - 函数
 * @returns {Function} - 优化后的函数
 *
 * wjs created by 2019-01-10
 */
function wjs_tailRecursion(func) {
  return function() {
    var result = func.apply(this, arguments)
    while (typeof result === 'function') {
      result = result()
    }
    return result
  }
}

/**
 * 函数参数验证
 * @param {Function} func - 函数
 * @param {Function} validator - 验证函数
 * @returns {Function} - 带验证的函数
 *
 * wjs created by 2020-01-01
 */
function wjs_validateArgs(func, validator) {
  return function() {
    if (validator.apply(this, arguments)) {
      return func.apply(this, arguments)
    }
    throw new Error('Invalid arguments')
  }
}

/**
 * 函数参数转换
 * @param {Function} func - 函数
 * @param {Function} transform - 转换函数
 * @returns {Function} - 带转换的函数
 *
 * wjs created by 2020-01-05
 */
function wjs_transformArgs(func, transform) {
  return function() {
    var args = transform.apply(this, arguments)
    return func.apply(this, args)
  }
}

/**
 * 函数返回值转换
 * @param {Function} func - 函数
 * @param {Function} transform - 转换函数
 * @returns {Function} - 带转换的函数
 *
 * wjs created by 2020-01-10
 */
function wjs_transformResult(func, transform) {
  return function() {
    var result = func.apply(this, arguments)
    return transform(result)
  }
}

/**
 * 函数错误转换
 * @param {Function} func - 函数
 * @param {Function} transform - 转换函数
 * @returns {Function} - 带转换的函数
 *
 * wjs created by 2021-01-01
 */
function wjs_transformError(func, transform) {
  return function() {
    try {
      return func.apply(this, arguments)
    } catch (e) {
      throw transform(e)
    }
  }
}

/**
 * 函数时间切片
 * @param {Function} func - 函数
 * @param {number} timeLimit - 时间限制（毫秒）
 * @returns {Function} - 时间切片函数
 *
 * wjs created by 2021-01-05
 */
function wjs_timeSlice(func, timeLimit) {
  return function() {
    var args = arguments
    var context = this
    var start = Date.now()
    
    var work = function() {
      func.apply(context, args)
      var elapsed = Date.now() - start
      if (elapsed < timeLimit) {
        setTimeout(work, 0)
      }
    }
    
    work()
  }
}

/**
 * 函数工作池
 * @param {number} maxWorkers - 最大工作线程数
 * @returns {Object} - 工作池对象
 *
 * wjs created by 2021-01-10
 */
function wjs_workerPool(maxWorkers) {
  var queue = []
  var workers = 0
  
  return {
    run: function(func) {
      return new Promise(function(resolve, reject) {
        queue.push({ func: func, resolve: resolve, reject: reject })
        this._process()
      }.bind(this))
    },
    
    _process: function() {
      if (workers >= maxWorkers || queue.length === 0) {
        return
      }
      
      workers++
      var item = queue.shift()
      
      Promise.resolve()
        .then(item.func)
        .then(item.resolve)
        .catch(item.reject)
        .finally(function() {
          workers--
          this._process()
        }.bind(this))
    }
  }
}

/**
 * 函数调度器
 * @returns {Object} - 调度器对象
 *
 * wjs created by 2022-01-01
 */
function wjs_scheduler() {
  var queue = []
  var running = false
  
  return {
    schedule: function(func, delay) {
      return new Promise(function(resolve) {
        queue.push({ func: func, delay: delay, resolve: resolve })
        queue.sort(function(a, b) { return a.delay - b.delay })
        if (!running) {
          this._run()
        }
      }.bind(this))
    },
    
    _run: function() {
      running = true
      if (queue.length === 0) {
        running = false
        return
      }
      
      var item = queue.shift()
      setTimeout(function() {
        item.resolve(item.func())
        this._run()
      }.bind(this), item.delay)
    }
  }
}

/**
 * 函数调用链
 * @returns {Object} - 调用链对象
 *
 * wjs created by 2022-01-05
 */
function wjs_callChain() {
  var chain = []
  
  return {
    add: function(func) {
      chain.push(func)
      return this
    },
    
    execute: function() {
      var args = arguments
      return chain.reduce(function(result, func) {
        return func.apply(this, result !== undefined ? [result].concat(Array.prototype.slice.call(args, 1)) : args)
      }.bind(this), undefined)
    },
    
    clear: function() {
      chain = []
      return this
    },
    
    length: function() {
      return chain.length
    }
  }
}

/**
 * 函数组合器
 * @returns {Object} - 组合器对象
 *
 * wjs created by 2022-01-10
 */
function wjs_combinator() {
  var funcs = []
  
  return {
    use: function(func) {
      funcs.push(func)
      return this
    },
    
    compose: function() {
      return wjs_compose.apply(null, funcs)
    },
    
    pipe: function() {
      return wjs_pipe.apply(null, funcs)
    },
    
    clear: function() {
      funcs = []
      return this
    }
  }
}

/**
 * 函数装饰器工厂
 * @param {Function} decorator - 装饰器函数
 * @returns {Function} - 装饰器工厂函数
 *
 * wjs created by 2023-01-01
 */
function wjs_decoratorFactory(decorator) {
  return function() {
    var args = Array.prototype.slice.call(arguments)
    return function(target, key, descriptor) {
      var original = descriptor.value
      descriptor.value = decorator(original, args)
      return descriptor
    }
  }
}

/**
 * 函数重试装饰器
 * @param {number} retries - 重试次数
 * @returns {Function} - 装饰器函数
 *
 * wjs created by 2023-01-05
 */
function wjs_retryDecorator(retries) {
  return function(target, key, descriptor) {
    var original = descriptor.value
    descriptor.value = wjs_retry(original, retries)
    return descriptor
  }
}

/**
 * 函数缓存装饰器
 * @returns {Function} - 装饰器函数
 *
 * wjs created by 2023-01-10
 */
function wjs_memoizeDecorator() {
  return function(target, key, descriptor) {
    var original = descriptor.value
    descriptor.value = wjs_memoize(original)
    return descriptor
  }
}

/**
 * 函数防抖装饰器
 * @param {number} wait - 等待时间
 * @returns {Function} - 装饰器函数
 *
 * wjs created by 2024-01-01
 */
function wjs_debounceDecorator(wait) {
  return function(target, key, descriptor) {
    var original = descriptor.value
    descriptor.value = wjs_debounce(original, wait)
    return descriptor
  }
}

/**
 * 函数节流装饰器
 * @param {number} wait - 等待时间
 * @returns {Function} - 装饰器函数
 *
 * wjs created by 2024-01-05
 */
function wjs_throttleDecorator(wait) {
  return function(target, key, descriptor) {
    var original = descriptor.value
    descriptor.value = wjs_throttle(original, wait)
    return descriptor
  }
}

/**
 * 函数超时装饰器
 * @param {number} timeout - 超时时间
 * @returns {Function} - 装饰器函数
 *
 * wjs created by 2024-01-10
 */
function wjs_timeoutDecorator(timeout) {
  return function(target, key, descriptor) {
    var original = descriptor.value
    descriptor.value = wjs_timeoutAsync(original, timeout)
    return descriptor
  }
}

/**
 * 函数错误处理装饰器
 * @param {Function} fallback - 错误处理函数
 * @returns {Function} - 装饰器函数
 *
 * wjs created by 2025-01-01
 */
function wjs_errorHandlerDecorator(fallback) {
  return function(target, key, descriptor) {
    var original = descriptor.value
    descriptor.value = wjs_catchError(original, fallback)
    return descriptor
  }
}

/**
 * 函数性能监控装饰器
 * @param {number} threshold - 阈值
 * @returns {Function} - 装饰器函数
 *
 * wjs created by 2025-01-05
 */
function wjs_performanceDecorator(threshold) {
  return function(target, key, descriptor) {
    var original = descriptor.value
    descriptor.value = wjs_monitorPerformance(original, threshold)
    return descriptor
  }
}

/**
 * 函数日志装饰器
 * @param {string} name - 函数名
 * @returns {Function} - 装饰器函数
 *
 * wjs created by 2025-01-10
 */
function wjs_logDecorator(name) {
  return function(target, key, descriptor) {
    var original = descriptor.value
    descriptor.value = wjs_logCalls(original, name || key)
    return descriptor
  }
}

/**
 * 函数调用追踪装饰器
 * @returns {Function} - 装饰器函数
 *
 * wjs created by 2026-01-01
 */
function wjs_traceDecorator() {
  var depth = 0
  
  return function(target, key, descriptor) {
    var original = descriptor.value
    descriptor.value = function() {
      depth++
      var indent = '  '.repeat(depth)
      console.log(indent + '→ ' + key + '(' + Array.prototype.slice.call(arguments).join(', ') + ')')
      var result = original.apply(this, arguments)
      console.log(indent + '← ' + key + ' => ' + (result === undefined ? 'undefined' : result))
      depth--
      return result
    }
    return descriptor
  }
}

// ============================================================
// 导出模块
// ============================================================
if (typeof module !== 'undefined' && module.exports) {
  module.exports = {
    wjs_curry,
    wjs_uncurry,
    wjs_compose,
    wjs_pipe,
    wjs_throttleTimestamp,
    wjs_debounceTimer,
    wjs_memoize,
    wjs_memoizeWithTtl,
    wjs_partial,
    wjs_reverseArgs,
    wjs_swapArgs,
    wjs_limitCalls,
    wjs_once,
    wjs_delayCall,
    wjs_immediateCall,
    wjs_asyncCall,
    wjs_catchError,
    wjs_retry,
    wjs_timeout,
    wjs_measureTime,
    wjs_countCalls,
    wjs_logCalls,
    wjs_monitorPerformance,
    wjs_bind,
    wjs_partialRight,
    wjs_spreadArgs,
    wjs_gatherArgs,
    wjs_when,
    wjs_not,
    wjs_and,
    wjs_or,
    wjs_xor,
    wjs_constant,
    wjs_identity,
    wjs_noop,
    wjs_throwError,
    wjs_delayedReturn,
    wjs_batchExecute,
    wjs_sequentialExecute,
    wjs_parallelExecute,
    wjs_raceExecute,
    wjs_retryWithDelay,
    wjs_debounceWithMaxWait,
    wjs_throttleWithTail,
    wjs_debounceThrottle,
    wjs_retryConditional,
    wjs_retryExponentialBackoff,
    wjs_timeoutRetry,
    wjs_poll,
    wjs_throttleRaf,
    wjs_debounceRaf,
    wjs_clearCache,
    wjs_memoizeWithLimit,
    wjs_memoizeLru,
    wjs_memoizeLfu,
    wjs_composeAsync,
    wjs_pipeAsync,
    wjs_batchExecuteAsync,
    wjs_sequentialExecuteAsync,
    wjs_parallelExecuteAsync,
    wjs_concurrentExecute,
    wjs_rateLimit,
    wjs_circuitBreaker,
    wjs_fallback,
    wjs_retryAsync,
    wjs_timeoutAsync,
    wjs_memoizeAsync,
    wjs_batchProcess,
    wjs_dedupExecute,
    wjs_versionedCache,
    wjs_lazyBind,
    wjs_autoCurry,
    wjs_tailRecursion,
    wjs_validateArgs,
    wjs_transformArgs,
    wjs_transformResult,
    wjs_transformError,
    wjs_timeSlice,
    wjs_workerPool,
    wjs_scheduler,
    wjs_callChain,
    wjs_combinator,
    wjs_decoratorFactory,
    wjs_retryDecorator,
    wjs_memoizeDecorator,
    wjs_debounceDecorator,
    wjs_throttleDecorator,
    wjs_timeoutDecorator,
    wjs_errorHandlerDecorator,
    wjs_performanceDecorator,
    wjs_logDecorator,
    wjs_traceDecorator
  }
}