Here’s a functional implementation of the Sieve of Eratosthenes, as presented in Odersky’s “Functional Programming Principles in Scala” Coursera course : // Sieving integral numbers def sieve(s: Stream[Int]): Stream[Int] = { s.head #:: sieve(s.tail.filter(_ % s.head != 0)) } // All primes as a lazy sequence val primes = sieve(Stream.from(2)) // Dumping the first five … Read more
A few footnotes to Lee’s answer: However, the bind function looks pretty weird. Why are f and g nested the other way around? Because bind is backwards. Compare (>>=) and its flipped version (=<<): (>>=) :: Monad m => m a -> (a -> m b) -> m b (=<<) :: Monad m => (a … Read more
What about: [ (x,y) | (x:rest) <- tails xs , y <- rest ]
I want to propose a lazier version of merge: merge [] ys = ys merge (x:xs) ys = x:merge ys xs For one example use case you can check a recent SO question about lazy generation of combinations. The version in the accepted answer is unnecessarily strict in the second argument and that’s what is … Read more
Disclaimer: A lot of this doesn’t really work quite right when you account for ⊥, so I’m going to blatantly disregard that for the sake of simplicity. A few initial points: Note that “union” is probably not the best term for A+B here–that’s specifically a disjoint union of the two types, because the two sides … Read more
No, Ruby doesn’t perform TCO. However, it also doesn’t not perform TCO. The Ruby Language Specification doesn’t say anything about TCO. It doesn’t say you have to do it, but it also doesn’t say you can’t do it. You just can’t rely on it. This is unlike Scheme, where the Language Specification requires that all … Read more
As @ljedrz points out, to make it work you only need to reference the composed functions again: let finally = compose(&*multiply_and_add, &*divide_and_subtract); (Note that in Rust, convention dictates that variable names should be in snake_case) However, we can make this better! Since Rust 1.26, we can use abstract return types (previously featured gated as #![feature(conservative_impl_trait)]). … Read more
Suppose a function has side effects. If we take all the effects it produces as the input and output parameters, then the function is pure to the outside world. So, for an impure function f’ :: Int -> Int we add the RealWorld to the consideration f :: Int -> RealWorld -> (Int, RealWorld) — … Read more
I would use findFirst instead: return Arrays.stream(Type.values()) .filter(e -> e.s.equals(val)) .findFirst() .orElseThrow(() -> new IllegalStateException(String.format(“Unsupported type %s.”, val))); Though a Map could be better in this case: enum Type{ X(“S1”), Y(“S2”); private static class Holder { static Map<String, Type> MAP = new HashMap<>(); } private Type(String s) { Holder.MAP.put(s, this); } public static Type find(String … Read more
A function literal is an alternate syntax for defining a function. It’s useful for when you want to pass a function as an argument to a method (especially a higher-order one like a fold or a filter operation) but you don’t want to define a separate function. Function literals are anonymous — they don’t have … Read more