Nim-lang: list comprehension with two variables - nim-lang
Confused on how to perform a list comprehension using two variables.
Here's what i'm trying to do so far:
let profile_row = lc[profile[r][c] | ( r <- 0..<4, c <- 0..<k ), int]
Here's the error:
greedy_motif_ba2d.nim(22, 40) Error: type mismatch: got <seq[int], float>
How is this correctly done?
Since Nim 1.2 lc has been removed so here's how to do this for anyone searching today:
let profile_row = collect(newSeq):
for r in 0..<4:
for c in 0..<4:
profile[r][c]
note collect removes the need to specify the type of of profile[r][c] but requires you to supply an initialization proc for the container profile_row
Turns out that the way I did it does actually work, just needed to change the type.
let profile_row = lc[profile[r][c] | ( r <- 0..<4, c <- 0..<k ), float]
Related
Can I use where in Haskell to find function parameter given the function output?
This is my program: modify :: Integer -> Integer modify a = a + 100 x = x where modify(x) = 101 In ghci, this compiles successfully but when I try to print x the terminal gets stuck. Is it not possible to find input from function output in Haskell?
x = x where modify(x) = 101 is valid syntax but is equivalent to x = x where f y = 101 where x = x is a recursive definition, which will get stuck in an infinite loop (or generate a <<loop>> exception), and f y = 101 is a definition of a local function, completely unrelated to the modify function defined elsewhere. If you turn on warnings you should get a message saying "warning: the local definition of modify shadows the outer binding", pointing at the issue. Further, there is no way to invert a function like you'd like to do. First, the function might not be injective. Second, even if it were such, there is no easy way to invert an arbitrary function. We could try all the possible inputs but that would be extremely inefficient.
Generator in Haskell list comprehension not working
I am trying to generate a list which will contain a list of solutions for the problem I am trying to solve. I am doing this using list comprehension, generating all possible combinations and then using a predicate to filter so that only solutions are included. Here is my code. solveRow :: Row -> [Row] solveRow (Row target rowCells) = [(cellsToRow target cls) | (cls <- (cellPermutations rowCells)), (result cls)==target] cellPermutations returns [[Cell]] and therefore cls should be of type [Cell]. When I try to compile I get an error. I thought <- passed each element of right hand side (in this case [Cell]) to the left hand side variable. Why am I getting a parse error for <-?
Don’t put brackets around cls <- (cellPermutations rowCells) — that’s a syntax error. You don’t need brackets around cellsToRow target cls either, although doing so isn’t an error. (And strictly speaking, you don’t need brackets around result cls either, but I personally think that those brackets make it more readable.) So your example should be: solveRow :: Row -> [Row] solveRow (Row target rowCells) = [cellsToRow target cls | cls <- (cellPermutations rowCells), (result cls)==target]
Passing Variables in Function and compare each?
I'm trying to practice Haskell returns and datatypes. I'm trying to pass the following information into the program: worm = 1:2:3:worm eel = [1,2,3,1,2,3,1,2,3] snake = 3:2:1:snake whale = [1..100] And i want to create a function that has a switch function to get the data and match it to its definition. For example, in Python: def compare(str): #for one case and using string to clarify if str == "1:2:3:worm": return "worm" I know the datatypes are lists but causes a lot of confusion. My code is giving me an error of Could not deduce (Num Char) Arising from use of worm My code: which :: [a] -> String which x | x == [1,2,3,1,2,3,1,2,3] = "worm" | x == 3:2:1:snake = "snake" | otherwise = "F" Is there another approach i'm missing? and why is my function giving me that error?
Two problems: You can't have a function that returns a list of numbers sometimes and a string other times. That's literally the entire point of a strongly typed language. If you want something like that, you need to use a sum type. You can't compare infinite lists. You can try, but your program will never finish.
Translate list comprehension to Prolog
I have a list comprehension in Haskell that I want to translate to Prolog. The point of the list comprehension is rotating a 4 by 4 grid: rotate :: [Int] -> [Int] rotate grid = [ grid !! (a + 4 * b) | a <- [0..3], b <- [0..3] ] Now in Prolog, I translated it like this: rotateGrid([T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15], [T0,T4,T8,T12,T1,T5,T9,T13,T2,T6,T10,T14,T3,T7,T11,T15]). Can we do better?
We can use findall/3 for list comprehensions (Cf. the SWI-Prolog Documentation). E.g., ?- findall(X, between(1,10,X), Xs). Xs = [1,2,3,4,5,6,7,8,9,10] Xs is a list holding all values that can unify with X when X is a number between 1 and 10. This is roughly equivalent to the Haskell expression let Xs = [x | x <- [1..10]](1). You can read a findall/3 statement thus: "find all values of [First Argument] such that [Conditions in Second Argument] hold, and put those values in the list, [Third Argument]". I've used findall/3 to write a predicate rotate_grid(+Grid, ?RotatedGrid). Here is a list of the approximate Haskell-Prolog equivalences I used in the predicate; each line shows the relation between the value that the Haskell expression will evaluate to and the Prolog variable with the same value: a <- [0..3] = A in between(0, 3, A) b <- [0..3] = B in between(0, 3, B) (a + 4 * d) = X in X is A + 4 * D <Grid> !! <Index> = Element in nth0(Index, Grid, Element) Then we simply need to find all the values of Element: rotate_grid(Grid, RotatedGrid) :- findall( Element, ( between(0,3,A), between(0,3,B), Index is A + 4 * B, nth0(Index, Grid, Element) ), RotatedGrid ). To verify that this produces the right transformation, I down-cased the Prolog code from the question and posed the following query: ?- rotate_grid([t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15], [t0,t4,t8,t12,t1,t5,t9,t13,t2,t6,t10,t14,t3,t7,t11,t15]). | true. Footnotes: (1): between/3 isn't actually the analogue of [m..n], since the latter returns a list of values from m to n where between(M,N,X) will instantiate X with each value between M and N (inclusive) on backtracking. To get a list of numbers in SWI-Prolog, we can use numlist(M,N,Ns). So a stricter analogue for x <- [1.10] would be the conjunction member(X, Ns), numlist(1, 10, Ns).
You want a permutation of a list. The concrete elements are not considered. Therefore, you can generalize your Haskell signature to rotate :: [x] -> [x] This is already a very valuable hint for Prolog: the list's elements will not be considered - elements will not even be compared. So a Prolog solution should be able to handle variables directly, like so: ?- rotateGrid(L,R). L = [_A,_B,_C,_D,_E,_F,_G,_H,_I,_J,_K,_L,_M,_N,_O,_P], R = [_A,_E,_I,_M,_B,_F,_J,_N,_C,_G,_K,_O,_D,_H,_L,_P]. And your original definition handles this perfectly. Your version using list comprehensions suggests itself to be realized via backtracking, certain precautions have to be taken. Using findall/3, as suggested by #aBathologist will rename variables: ?- length(L,16),rotate_grid(L,R). L = [_A,_B,_C,_D,_E,_F,_G,_H,_I,_J,_K,_L,_M,_N,_O,_P], R = [_Q,_R,_S,_T,_U,_V,_W,_X,_Y,_Z,_A1,_B1,_C1,_D1,_E1,_F1]. The built-in predicate bagof/3 addresses this problem. Note that we have to declare all local, existential variables explicitly: rotate_grid2(Grid, RotatedGrid) :- bagof( Element, A^B^Index^ % declaration of existential variables ( between(0,3,A), between(0,3,B), Index is A + 4 * B, nth0(Index, Grid, Element) ), RotatedGrid). For lists that are shorter than 16 elements, the Haskell version produces a clean error, but here we get pretty random results: ?- L=[1,2,3,4],rotate_grid(L,R). L = [1,2,3,4], R = [1,2,3,4]. ?- L=[1,2,3,4,5],rotate_grid(L,R). L = [1,2,3,4,5], R = [1,5,2,3,4]. This is due to the unclear separation between the part that enumerates and "generates" a concrete element. The cleanest way is to add length(Grid, 16) prior to the goal bagof/3. List comprehensions in Prolog Currently, only B-Prolog offers a form of list comprehensions: R#=[E: A in 0..3,B in 0..3,[E,I],(I is A+4*B,nth0(I,L,E))]. However, it does not address the second problem: | ?- L = [1,2,3], R#=[E: A in 0..3,B in 0..3,[E,I],(I is A+4*B,nth0(I,L,E))]. L = [1,2,3] R = [1,2,3] yes
Use a loop predicate foreach/4
If the comprehension should retain variables, which is for example important in constraint programming, a Prolog system could offer a predicate foreach/4. This predicate is the DCG buddy of foreach/2.
Here is how variables are not retained via findall/3, the
result R contains fresh variables according to the ISO
core semantics of findall/3:
Welcome to SWI-Prolog (threaded, 64 bits, version 7.7.1)
SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free software.
?- functor(L,foo,5), findall(X,
(between(1,5,N), M is 6-N, arg(M,L,X)), R).
L = foo(_5140, _5142, _5144, _5146, _5148),
R = [_5210, _5204, _5198, _5192, _5186].
And here is how variables can be retained via foreach/4,
the resulting list has the same variables as the compound
we started with:
Jekejeke Prolog 3, Runtime Library 1.3.0
(c) 1985-2018, XLOG Technologies GmbH, Switzerland
?- [user].
helper(N,L) --> [X], {M is 6-N, arg(M,L,X)}.
Yes
?- functor(L,foo,5), foreach(between(1,5,N),helper(N,L),R,[]).
L = foo(_A,_G,_M,_S,_Y),
R = [_Y,_S,_M,_G,_A]
Using foreach/4 instead of bagof/3 might seem a little bit over the top. foreach/4 will probably only show its full potential when implementing Picat loops, since it can build up constraints, what bagof/3 cannot do.
foreach/4 is an implementation without the full materialization of all solution that are then backtracked. It shares with bagof/3 the reconstruct of variables, but still allows backtracking in the conjunction of the closures.
OCaml : need help for List.map function
I need to create a function that basically works like this :
insert_char("string" 'x') outputs "sxtxrxixnxg".
So here is my reasoning :
Create a list with every single character in the string :
let inserer_car(s, c) =
let l = ref [] in
for i = 0 to string.length(s) - 1 do
l := s.[i] :: !l
done;
Then, I want to use List.map to turn it into a list like ['s', 'x', 't', 'x' etc.].
However, I don't really know how to create my function to use with map. Any help would be appreciated!
I'm a beginner in programming and especially in ocaml! so feel free to assume I'm absolutely ignorant.
If you were using Core, you could write it like this: open Core.Std let insert_char s c = String.to_list s |> (fun l -> List.intersperse l c) |> String.of_char_list Or, equivalently: let insert_char s c = let chars = String.to_list s in let interspersed_chars = List.intersperse chars c in String.of_char_list interspersed_chars This is just straightforward use of existing librariies. If you want the implementation of List.intersperse, you can find it here. It's quite simple.
A map function creates a copy of a structure with different contents. For lists, this means that List.map f list has the same length as list. So, this won't work for you. Your problem requires the full power of a fold. (You could also solve the problem imperatively, but in my opinion the reason to study OCaml is to learn about functional programming.) Let's say you're going to use List.fold_left. Then the call looks like this: let result = List.fold_left myfun [] !l Your function myfun has the type char list -> char -> char list. In essence, its first parameter is the result you've built so far and its second parameter is the next character of the input list !l. The result should be what you get when you add the new character to the list you have so far. At the end you'll need to convert a list of characters back to a string.