var factorial = function(n) {
  return n == 1 ? 1 : n * factorial(n - 1);
}

factorial(5); // 120

(def factorial
  (fn [n] (if (= n 1) 1
             (* n (factorial (- n 1))))))

(factorial 5) ; 120

(function(n) {
  return n == 1 ? 1 : n * factorial(n - 1);
})(5);

((fn [n] (if (= n 1) 1
             (* n (factorial (- n 1)))))
 5)

∀F ∃X -> FX = X

Y = λf.((λx.f(xx))(λx.f(xx)))

var factorial = function(n) {
  return n == 1 ? 1 : n * factorial(n - 1);
}

factorial(5); // 120

(def factorial
  (fn [n] (if (= n 1) 1
             (* n (factorial (- n 1))))))

(factorial 5) ; 120

var factorial = function(f, n) {
  return n == 1 ? 1 : n * f(f, n - 1);
}

factorial(factorial, 5); // 120

(def factorial
  (fn [f n] (if (= n 1) 1
             (* n (f f (- n 1))))))

(factorial factorial 5) ; 120

var factorial = function(f) {
  return function(n) {
    return n == 1 ? 1 : n * f(f)(n - 1);
  }
}

factorial(factorial)(5); // 120

(def factorial
  (fn [f] (fn [n] (if (= n 1) 1
                    (* n ((f f) (- n 1)))))))

((factorial factorial) 5) ; 120

var self_invoke = function(f) {
  return f(f);
};

var factorial = self_invoke(function(f) {
  return function(n) {
    return n == 1 ? 1 : n * self_invoke(f)(n - 1);
  };
});

factorial(5); // 120

(def self-invoke
  (fn [f] (f f)))

(def factorial
  (self-invoke
   (fn [f]
     (fn [n] (if (= n 1) 1
                (* n ((self-invoke f) (- n 1))))))))

(factorial 5) ; 120

var factorial = (function(self_invoke) {
  return self_invoke(function(f) {
    return function(n) {
      return n == 1 ? 1 : n * self_invoke(f)(n - 1);
    };
  });
})(function(f) {
  return f(f);
});

factorial(5); // 120

(def factorial
  ((fn [self-invoke]
     (self-invoke
      (fn [f]
        (fn [n]
          (if (= n 1) 1
              (* n ((self-invoke f) (- n 1))))))))
   (fn [f] (f f))))

(factorial 5) ; 120

function(n) {
  return n == 1 ? 1 : n * self_invoke(f)(n - 1);
};

(fn [n]
  (if (= n 1) 1
      (* n ((self-invoke f) (- n 1)))))

(function(self){
  return function(n) {
    return n == 1 ? 1 : n * self(n - 1);
  };
})(function(m) {
  return self_invoke(f)(m);
}));

((fn [self]
  (fn [n]
    (if (= n 1) 1
        (* n (self (- n 1)))))
 (fn [m] ((self-invoke f) m)))

function(self){
  return function(n) {
    return n == 1 ? 1 : n * self(n - 1);
  };
}

(fn [self]
  (fn [n]
    (if (= n 1) 1
        (* n (self (- n 1))))))

var fake_factorial = function(self) {
  return function(n) {
    return n == 1 ? 1 : n * self(n - 1);
  };
}

var y = function(fake_rec) {
  return (function(self_invoke) {
    return self_invoke(function(f) {
      return fake_rec(function(m) {
        return self_invoke(f)(m);
      });
    });
  })(function(f) {
    return f(f);
  });
};

var factorial = y(fake_factorial);

factorial(5); // 120

(def fake-factorial
  (fn [self]
    (fn [n]
      (if (= n 1) 1
          (* n (self (- n 1)))))))

(def y
  (fn [fake-rec] ((fn [self-invoke]
                   (self-invoke
                    (fn [f]
                      (fake-rec
                       (fn [m] ((self-invoke f) m))))))
                 (fn [f] (f f)))))

(def factorial
  (y fake-factorial))

(factorial 5) ; 120

var y = function(fake_rec) {
  return (function(f) {
    return f(f);
  })(function(f) {
    return fake_rec(function(x) {
      return f(f)(x);
    });
  });
};

(def y
  (fn [fake-rec]
    ((fn [f] (f f)) (fn [f]
                     (fake-rec (fn [x] ((f f) x)))))))

(+ 1 1)  --> 2
(- 2 1)  --> 1
(* 2 3)  --> 6
(/ 2 1)  --> 2
(+ 1 2 3 4)  --> 10

(cons 17 29)

  *
 / \
17 29

(cons 3 (cons 5 (cons 7 (cons 9 nil))))

 *--*--*--*--nil
 |  |  |  |
 3  5  7  9

(cons (cons 1 2) (cons 3 4))

   *
  / \
 *   *
/ \ / \
1 2 3 4

(car (cons 1 2)) --> 1
(cdr (cons 1 2)) --> 2

(deftest cons-test
  (testing "test my cons"
    (is (= (car (cons 17 29)) 17))
    (is (= (cdr (cons 17 29)) 29))))

(defn cons
  [a, b]
  (fn [m] (if (= m 0) a b)))

(defn car
  [c]
  (c 0))

(defn cdr
  [c]
  (c 1))

(defn cons
  [a, b]
  (defn dispatch
    [m]
    (if (= m 0) a b))
  dispath)

(defn cons
  [a, b]
  (fn [f] (f a b)))

(defn car
  [c]
  (c (fn [a, b] a)))

(defn cdr
  [c]
  (c (fn [a, b] b)))

(defn cons
  [a, b]

  (defn sqr
    [x, n]
    (cond (= n 0) 1
          (= n 1) x
          (> n 1) (* x (sqr x (- n 1)))
          :else (throw (.IllegalArgumentException "wrong param"))))

  (* (sqr 2 a) (sqr 3 b)))

(defn factor
  [x, a]

  (defn iter
    [x, n]
    (if (= 0 (mod x a)) (iter (/ x a) (+ n 1))
        n))

  (iter x 0))

(defn car
  [c]
  (factor c 2))

(defn cdr
  [c]
  (factor c 3))

public class SummaryUpdateHelper {
    private Map<String, Object> updatedFields;

    public SummaryUpdateHelper(Map<String, Object> updatedFields) {
        this.updatedFields = updatedFields;
    }

    public void updateSummary(Request request, Customer customer) {
        RequestSummary requestSummary = request.getSummary();
        Summary summaryFromDb = customer.getSummary();

        if (summaryFromDb == null && requestSummary != null) {
            summaryFromDb = new Summary();
        }

        if (null != requestSummary) {
            updateSummaryAttributes(requestSummary, summaryFromDb);
        }
        if (updatedFields.containsKey("summary")) {
            customer.setSummary(summaryFromDb);
        }
    }

    private void updateSummaryAttributes(RequestSummary requestSummary, Summary dbSummary) {
        String requestSummaryDetail = requestSummary.getSummaryDetail();
        TrustIndicator requestTrustIndicator = requestSummary.getTrustIndicator();

        String dbSummaryDetail = dbSummary.getDetail();
        TrustIndicator dbTrustIndicator = dbSummary.getTrustIndicator();

        UpdateAction updateAction = getUpdateAction(requestSummaryDetail,
                dbSummaryDetail, requestTrustIndicator, dbTrustIndicator);

        if (updateAction.updateDetail) {
            dbSummary.setDetail(trimToNull(requestSummaryDetail));
            updatedFields.put("summary", dbSummary);
        }

        dbSummary.setTrustIndicator(updateAction.updatedTrustIndicator);

        if (updateAction.updatedTrustIndicator != dbTrustIndicator) {
            updatedFields.put("summary", dbSummary);
        }
    }

    private UpdateAction getUpdateAction(String requestSummaryDetail, String dbSummaryDetail,
                                         TrustIndicator requestTrustIndicator,
                                         TrustIndicator dbTrustIndicator) {
        UpdateAction updateAction;
        boolean isRequestDetailBlank;
        boolean isDbDetailBlank;
        boolean isRequestAndDbDetailSame;

        updateAction = new UpdateAction();
        updateAction.updatedTrustIndicator = dbTrustIndicator;

        if (null == dbSummaryDetail || "".equals(dbSummaryDetail)) {
            isDbDetailBlank = true;
        } else {
            isDbDetailBlank = false;
        }

        if (null == requestSummaryDetail || "".equals(requestSummaryDetail)) {
            isRequestDetailBlank = true;
        } else {
            isRequestDetailBlank = false;
        }

        if (null != requestSummaryDetail && null != dbSummaryDetail
                && requestSummaryDetail.equalsIgnoreCase(dbSummaryDetail)) {
            isRequestAndDbDetailSame = true;
        } else {
            isRequestAndDbDetailSame = false;
        }

        if (isRequestDetailBlank && !isDbDetailBlank && TRUSTED == requestTrustIndicator) {
            if (TRUSTED == dbTrustIndicator) {
                updateAction.updateDetail = true;
            } else if (UNTRUSTED == dbTrustIndicator) {
                updateAction.updateDetail = true;
                updateAction.updatedTrustIndicator = TRUSTED;
            }
        } else if (!isRequestDetailBlank && isDbDetailBlank) {
            updateAction.updateDetail = true;
            updateAction.updatedTrustIndicator = requestTrustIndicator;
        } else if (!isRequestDetailBlank && !isDbDetailBlank) {
            if (TRUSTED == dbTrustIndicator && TRUSTED == requestTrustIndicator
                    && !isRequestAndDbDetailSame) {
                updateAction.updateDetail = true;
            } else if (UNTRUSTED == dbTrustIndicator && TRUSTED == requestTrustIndicator) {
                updateAction.updatedTrustIndicator = TRUSTED;
                if (!isRequestAndDbDetailSame) {
                    updateAction.updateDetail = true;
                }
            } else if (UNTRUSTED == dbTrustIndicator && UNTRUSTED == requestTrustIndicator
                    && !isRequestAndDbDetailSame) {
                updateAction.updateDetail = true;
            } else if (TRUSTED == dbTrustIndicator && UNTRUSTED == requestTrustIndicator
                    && !isRequestAndDbDetailSame) {
                updateAction.updateDetail = true;
                updateAction.updatedTrustIndicator = UNTRUSTED;
            }
        }
        return updateAction;
    }

    private static String trimToNull(String target) {
        if (target == null) {
            return null;
        }
        String trimmed = target.trim();
        return "".equals(trimmed) ? null : trimmed;
    }

    private class UpdateAction {
        public boolean updateDetail;
        public TrustIndicator updatedTrustIndicator;
    }
}

class SummaryUpdateHelperTest extends Specification {

    @Unroll
    def "request[#requestSummary, #requestTrust] update db[#dbSummary, #dbTrust] = [#finalSummary, #finalTrust]"() {
        given:
        def helper = new SummaryUpdateHelper(newHashMap())
        def request = createRequest(requestSummary, requestTrust)
        def customer = createCustomer(dbSummary, dbTrust)

        when:
        helper.updateSummary(request, customer)

        then:
        customer.summary == createSummary(finalSummary, finalTrust)

        where:
        requestSummary | requestTrust | dbSummary | dbTrust   | finalSummary | finalTrust
        null           | null         | null      | null      | null         | null

        BLANK          | TRUSTED      | null      | null      | null         | null

        /********************************这里省掉58个测试用例*********************************/

        UPDATED        | UNTRUSTED    | ORIGINAL  | UNTRUSTED | UPDATED      | UNTRUSTED
    }

    /*************************************下面的不重要**************************************/
}

if (null == dbSummaryDetail || "".equals(dbSummaryDetail)) {
    isDbDetailBlank = true;
} else {
    isDbDetailBlank = false;
}

private boolean shouldUpdateDetail(String requestSummaryDetail, String dbSummaryDetail,
                                   TrustIndicator requestTrustIndicator,
                                   TrustIndicator dbTrustIndicator) {
    boolean isDbDetailBlank = isNullOrEmpty(dbSummaryDetail);
    boolean isRequestDetailBlank = isNullOrEmpty(requestSummaryDetail);
    boolean isRequestAndDbDetailSame = isSame(requestSummaryDetail, dbSummaryDetail);

    boolean shouldUpdateDetail = false;
    if (isRequestDetailBlank && !isDbDetailBlank && TRUSTED == requestTrustIndicator) {
        if (TRUSTED == dbTrustIndicator) {
            shouldUpdateDetail = true;
        } else if (UNTRUSTED == dbTrustIndicator) {
            shouldUpdateDetail = true;
        }
    } else if (!isRequestDetailBlank && isDbDetailBlank) {
        shouldUpdateDetail = true;
    } else if (!isRequestDetailBlank) {
        if (TRUSTED == dbTrustIndicator && TRUSTED == requestTrustIndicator
                && !isRequestAndDbDetailSame) {
            shouldUpdateDetail = true;
        } else if (UNTRUSTED == dbTrustIndicator && TRUSTED == requestTrustIndicator) {
            if (!isRequestAndDbDetailSame) {
                shouldUpdateDetail = true;
            }
        } else if (UNTRUSTED == dbTrustIndicator && UNTRUSTED == requestTrustIndicator
                && !isRequestAndDbDetailSame) {
            shouldUpdateDetail = true;
        } else if (TRUSTED == dbTrustIndicator && UNTRUSTED == requestTrustIndicator
                && !isRequestAndDbDetailSame) {
            shouldUpdateDetail = true;
        }
    }
    return shouldUpdateDetail;
}

private boolean shouldUpdateDetail(String requestSummaryDetail, String dbSummaryDetail,
                                   TrustIndicator requestTrustIndicator) {
    boolean isDbDetailBlank = isNullOrEmpty(dbSummaryDetail);

    if (isNullOrEmpty(requestSummaryDetail)) {
        return !isDbDetailBlank && TRUSTED == requestTrustIndicator;
    }

    return isDbDetailBlank || !isSame(requestSummaryDetail, dbSummaryDetail);
}

private TrustIndicator getUpdatedIndicator(String requestSummaryDetail, String dbSummaryDetail,
                                                TrustIndicator requestTrustIndicator,
                                                TrustIndicator dbTrustIndicator) {
    TrustIndicator updatedIndicator = dbTrustIndicator;

    boolean isDbDetailBlank = isNullOrEmpty(dbSummaryDetail);
    boolean isRequestDetailBlank = isNullOrEmpty(requestSummaryDetail);

    if (isRequestDetailBlank && !isDbDetailBlank && TRUSTED == requestTrustIndicator) {
        updatedIndicator = requestTrustIndicator;
    } else if (!isRequestDetailBlank && isDbDetailBlank) {
        updatedIndicator = requestTrustIndicator;
    } else if (!isRequestDetailBlank) {
        if (TRUSTED == requestTrustIndicator) {
            updatedIndicator = requestTrustIndicator;
        } else if (UNTRUSTED == requestTrustIndicator
                && !isSame(requestSummaryDetail, dbSummaryDetail)) {
            updatedIndicator = requestTrustIndicator;
        }
    }
    return updatedIndicator;
}

private boolean shouldUpdate(String requestSummaryDetail, String dbSummaryDetail,
                             TrustIndicator requestTrustIndicator) {
    boolean isDbDetailBlank = isNullOrEmpty(dbSummaryDetail);
    boolean isRequestDetailBlank = isNullOrEmpty(requestSummaryDetail);

    if (isRequestDetailBlank) {
        return !isDbDetailBlank && TRUSTED == requestTrustIndicator;
    }

    return isDbDetailBlank || shouldUpdateWhenBothNotBlank(requestSummaryDetail,
            dbSummaryDetail, requestTrustIndicator);
}

private boolean shouldUpdateWhenBothNotBlank(String requestSummaryDetail,
                                             String dbSummaryDetail,
                                             TrustIndicator requestTrustIndicator) {
    return TRUSTED == requestTrustIndicator
            || UNTRUSTED == requestTrustIndicator && !isSame(requestSummaryDetail, dbSummaryDetail);
}

...
where:
requestSummary | requestTrust | dbSummary | dbTrust   | finalSummary | finalTrust
BLANK          | TRUSTED      | null      | null      | BLANK        | TRUSTED
BLANK          | TRUSTED      | BLANK     | UNTRUSTED | BLANK        | TRUSTED
BLANK          | TRUSTED      | EMPTY     | UNTRUSTED | EMPTY        | TRUSTED

EMPTY          | TRUSTED      | null      | null      | BLANK        | TRUSTED
EMPTY          | TRUSTED      | BLANK     | UNTRUSTED | BLANK        | TRUSTED
EMPTY          | TRUSTED      | EMPTY     | UNTRUSTED | EMPTY        | TRUSTED

ORIGINAL       | UNTRUSTED    | BLANK     | TRUSTED   | BLANK        | TRUSTED
ORIGINAL       | UNTRUSTED    | EMPTY     | TRUSTED   | EMPTY        | TRUSTED

UPDATED        | UNTRUSTED    | BLANK     | TRUSTED   | BLANK        | TRUSTED
UPDATED        | UNTRUSTED    | EMPTY     | TRUSTED   | EMPTY        | TRUSTED
UPDATED        | UNTRUSTED    | ORIGINAL  | TRUSTED   | ORIGINAL     | TRUSTED
...

private boolean shouldUpdate(String requestSummaryDetail, TrustIndicator requestTrustIndicator,
                             TrustIndicator dbTrustIndicator) {
    if (isNullOrEmpty(requestSummaryDetail)) {
        return TRUSTED == requestTrustIndicator;
    }
    return !(TRUSTED == dbTrustIndicator && UNTRUSTED == requestTrustIndicator);
}

task hello {
    doLast {
        println 'Hello World'
    }
}

Hello World

:hello
Hello World

BUILD SUCCESSFUL

Total time: 1.879 secs

task hello << {
    println 'Hello World'
}

task upper << {
    String someString = 'mY_nAmE'
    println "Original: " + someString
    println "Upper case: " + someString.toUpperCase()
}

Original: mY_nAmE
Upper case: MY_NAME

task hello << {
    println 'Hello world!'
}

task intro(dependsOn: hello) << {
    println "I'm Gradle"
}

Hello World
I'm Gradle

4.times { counter ->
    task "task$counter"(dependsOn: "depending$counter") << {
        println "I'm task number $counter"
    }
}

4.times { counter ->
    task "depending$counter" << {
        println "I'm depending number $counter"
    }
}

I'm depending number 1
I'm task number 1

4.times { counter ->
    task "task$counter"(dependsOn: "depending$counter") << {
        println "I'm task number $counter"
    }
}

task0.dependsOn task1, task2

4.times { counter ->
    task "depending$counter" << {
        println "I'm depending number $counter"
    }
}

I'm depending number 0
I'm depending number 1
I'm task number 1
I'm depending number 2
I'm task number 2
I'm task number 0

task hello << {
    println 'Hello Earth'
}
hello.doFirst {
    println 'Hello Venus'
}
hello.doLast {
    println 'Hello Mars'
}
hello << {
    println 'Hello Jupiter'
}

Hello Venus
Hello Earth
Hello Mars
Hello Jupiter

defaultTasks 'clean', 'run'
task clean << {
    println 'Default Cleaning!'
}
task run << {
    println 'Default Running!'
}
task other << {
    println "I'm not a default task!"
}

Default Cleaning!
Default Running!

public interface UserDAO {
    User add(User user);

    User update(User user);

    User get(String id);

    boolean delete(String id);

    boolean existed(String username, String password);
}

public class UserDAOImpl implements UserDAO {
    private UserMapper userMapper;

    @Override
    public User add(User user) {
        return userMapper.insert(user);
    }

    @Override
    public User update(User user) {
        return userMapper.update(user);
    }

    @Override
    public User get(String id) {
        return userMapper.selectById(id);
    }

    @Override
    public boolean delete(String id) {
        return userMapper.deleteById(id);
    }

    @Override
    public boolean existed(String username, String password) {
        User user = userMapper.selectByUsernamePassword(username, password);
        return user != null;
    }
}

public class UserDAOEncryptedImpl implements UserDAO {
    private UserMapper userMapperForEncryption;

    @Override
    public User add(User user) {
        user.setPassword(encrypt(user.getPassword()));
        return userMapperForEncryption.insert(user);
    }

    @Override
    public User update(User user) {
        user.setPassword(encrypt(user.getPassword()));
        return userMapperForEncryption.update(user);
    }

    @Override
    public User get(String id) {
        return userMapperForEncryption.selectById(id);
    }

    @Override
    public boolean delete(String id) {
        return userMapperForEncryption.deleteById(id);
    }

    @Override
    public boolean existed(String username, String password) {
        User user = userMapperForEncryption.selectByUsernamePassword(username, encrypt(password));
        return user != null;
    }
}

public class CompositeUserDAOImpl implements UserDAO {
    private UserDAO userDAOWithoutEncryption = new UserDAOImpl();

    @Override
    public User add(User user) {
        return userDAOWithoutEncryption.add(user);
    }

    @Override
    public User update(User user) {
        return userDAOWithoutEncryption.update(user);
    }

    @Override
    public User get(String id) {
        return userDAOWithoutEncryption.get(id);
    }

    @Override
    public boolean delete(String id) {
        return userDAOWithoutEncryption.delete(id);
    }

    @Override
    public boolean existed(String username, String password) {
        return userDAOWithoutEncryption.existed(username, password);
    }
}

public class CompositeUserDAOImpl implements UserDAO {
    private UserDAO userDAOWithoutEncryption = new UserDAOImpl();
    private UserDAO userDAOWithEncryption = new UserDAOEncryptedImpl();

    @Override
    public User add(User user) {
        userDAOWithEncryption.add(user.clone());
        return userDAOWithoutEncryption.add(user);
    }

    @Override
    public User update(User user) {
        userDAOWithEncryption.update(user.clone());
        return userDAOWithoutEncryption.update(user);
    }

    @Override
    public User get(String id) {
        return userDAOWithoutEncryption.get(id);
    }

    @Override
    public boolean delete(String id) {
        userDAOWithEncryption.delete(id);
        return userDAOWithoutEncryption.delete(id);
    }

    @Override
    public boolean existed(String username, String password) {
        return userDAOWithoutEncryption.existed(username, password);
    }
}

public class CompositeUserDAOImpl implements UserDAO {
    private UserDAO userDAOWithoutEncryption = new UserDAOImpl();
    private UserDAO userDAOWithEncryption = new UserDAOEncryptedImpl();

    @Override
    public User add(User user) {
        userDAOWithoutEncryption.add(user);
        return userDAOWithEncryption.add(user.clone());
    }

    @Override
    public User update(User user) {
        userDAOWithoutEncryption.update(user.clone());
        return userDAOWithEncryption.update(user);
    }

    @Override
    public User get(String id) {
        return userDAOWithEncryption.get(id);
    }

    @Override
    public boolean delete(String id) {
        userDAOWithoutEncryption.delete(id);
        return userDAOWithEncryption.delete(id);
    }

    @Override
    public boolean existed(String username, String password) {
        return userDAOWithEncryption.existed(username, password);
    }
}

public class CompositeUserDAOImpl implements UserDAO {
    private UserDAO userDAOWithEncryption = new UserDAOEncryptedImpl();

    @Override
    public User add(User user) {
        return userDAOWithEncryption.add(user.clone());
    }

    @Override
    public User update(User user) {
        return userDAOWithEncryption.update(user);
    }

    @Override
    public User get(String id) {
        return userDAOWithEncryption.get(id);
    }

    @Override
    public boolean delete(String id) {
        return userDAOWithEncryption.delete(id);
    }

    @Override
    public boolean existed(String username, String password) {
        return userDAOWithEncryption.existed(username, password);
    }
}