higher-order-functions

I was messing around with the functional programming in Swift 2.1, trying to implement the Church encoding pair/cons function ( cons = λx λy λf f x y in untyped lambda calculus ), which I had read couldn't be done in earlier versions of Swift. With generics it looks like func cons<S,T,U>(x:S,_ y:T) -> ((S,T) -> U) -> U { return { (f:((S,T) -> U)) -> U in return f(x,y)} } cons(1,2) //error: cannot invoke 'cons' with an argument list of type '(Int, Int)' //note: expected an argument list of type '(S, T)' which doesn't work, and gives an error I cannot understand (surely parameter list of type

I have an array of "Dog" where i want to print the name of all dogs older then 5 years. I tried something like Dogs.filter{ it.age > 5 }.forEach { it.name } This gives me the value i need, but how do I store and return it as a list of strings? I tried things like adding .join(",") but since I don't get any array in return it wont work. I think you're looking for the map operator: val dogNames: List<String> = dogs.filter { it.age > 5 }.map { it.name } 来源： https://stackoverflow.com/questions/49427606/how-to-return-member-values-in-a-array-of-objects-using-lambda-expressions

I am not sure what the promises are doing in R If one runs a = lapply(seq_len(2), function(n) { function() {n}}) b = lapply(seq_len(2), function(n) {n}) we can see that a[[1]]() # == 2 b[[1]] # == 1 I understand that R uses promise's object and lazily evaluates an expression in its environment, but I dont understand why the different environments created for each function would not contain their own value for n. [[1]] function () { n } <environment: 0x7f9b2416ad18> [[2]] function () { n } <environment: 0x7f9b2416ab20> as.list(environment(a[[1]])) $n [1] 2 as.list(environment(a[[2]])) $n [1] 2

Update: It is acceptable if this method is not thread safe, but I'm interested in learning how I would make it thread safe. Also, I do not want to lock on a single object for all values of key if I can avoid it. Original Question: Suppose I want to write a higher order function that takes a key and a function, and checks if an object has been cached with the given key. If is has, the cached value is returned. Otherwise, the given function is run and the result is cached and returned. Here's a simplified version of my code: public static T CheckCache<T>(string key, Func<T> fn, DateTime expires)

I want to repeatedly apply a function simplify' until the result is "stable" (i.e. simplify'(x) == x ): simplify :: Expr -> Expr simplify expr = let iterations = iterate simplify' expr neighbours = zip iterations (tail iterations) simplified = takeWhile (\(a, b) -> a /= b) neighbours in snd $ last ((expr, expr) : simplified) simplify' :: Expr -> Expr This seems to be a common problem to me. Is there a more elegant solution? Update: I found a much simpler solution, but I'm still looking for a more elegant solution :) simplify expr = let next = simplify' expr in if next == expr then expr else