If the aim is to run a sequence of shell commands, you may be able to achieve this as follows: # note: no dash before commands some_stuff: &some_stuff |- a b c combined_stuff: – *some_stuff – d – e – f This is equivalent to: some_stuff: “a\nb\nc” combined_stuff: – “a\nb\nc” – d – e – … Read more
Legacy. List was originally defined to be functional-languages-looking: 1 :: 2 :: Nil // a list list1 ::: list2 // concatenation of two lists list match { case head :: tail => “non-empty” case Nil => “empty” } Of course, Scala evolved other collections, in an ad-hoc manner. When 2.8 came out, the collections were … Read more
General principle Suppose you have the following range function: (defun range (start end &optional (step 1)) (loop for x from start below end by step collect x)) You can accept another parameter, a function, and call it for each element: (defun range-generator (callback start end &optional (step 1)) (loop for x from start below end … Read more
To see why you get the particular answers that arise, the desugaring explanations are very helpful. Let me supplement them with a little general advice about developing perceptions of Haskell code. Haskell’s type system makes no distinction between two separable “moral” purposes: [x] the type of values which are lists with elements drawn from x … Read more
Gavin’s answer is simple and elegant. But if there are many columns, a much faster solution would be: lapply(seq_len(ncol(x)), function(i) x[,i]) The speed difference is 6x in the example below: > x <- matrix(1:1e6, 10) > system.time( as.list(data.frame(x)) ) user system elapsed 1.24 0.00 1.22 > system.time( lapply(seq_len(ncol(x)), function(i) x[,i]) ) user system elapsed 0.2 … Read more
Interesting non-trivial problem! MAJOR UPDATE With all that’s happened, I’ve rewrote the answer and removed some dead ends. I also timed the various solutions on different cases. Here’s the first, rather simple but slow, solution: flatten1 <- function(x) { y <- list() rapply(x, function(x) y <<- c(y,x)) y } rapply lets you traverse a list … Read more
The paper that Logan points to is great, but it’s a little difficult. (Just ask my students.) It’s also a great deal about ‘how stream fusion works’ and only a fraction ‘what stream fusion is and how you can use it’. The problem that stream fusion solves is that functional codes as written often allocate … Read more
SWI-Prolog offers exclude/3 and other such meta-predicates. Your original problem can be coded like this: are_identical(X, Y) :- X == Y. filterList(A, In, Out) :- exclude(are_identical(A), In, Out). Usage example: ?- filterList(A, [A, B, A, C, D, A], Out). Out = [B, C, D].
You’re going need to iterate over it. JSF 2 offers three iteration components out the box. Provided that the User entity look like below, @Entity public class User { private @Id Long id; private String username; private String email; private LocalDate birthdate; // Add/generate getters+setters. } and that the search results are assigned as a … Read more
The code as you’ve posted it is (almost) OK. The order of clauses just needs to be swapped (in order to make this predicate definition productive, when used in a generative fashion): append( [], X, X). % (* your 2nd line *) append( [X | Y], Z, [X | W]) :- append( Y, Z, W). … Read more