-
|
I am struggling with reified predicates in the In the following simulation of a "log rate limiter" which admits duplicate log messages at most once every 10 units (seconds?).
In case that was confusing, here is the full problem text: /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
https://leetcode.com/problems/logger-rate-limiter/description/
https://leetcode.ca/2016-11-23-359-Logger-Rate-Limiter/
359. Logger Rate Limiter
Design a logger system that receives a stream of messages along with their timestamps.
Each unique message should only be printed at most every 10 seconds
( i.e. a message printed at timestamp t will prevent other identical messages from being printed until timestamp t + 10).
All messages will come in chronological order. Several messages may arrive at the same timestamp.
Implement the Logger class:
Logger() Initializes the logger object.
bool shouldPrintMessage(int timestamp, string message) Returns true if the message should be printed in the given timestamp,
otherwise returns false.
Example 1:
Input
["Logger", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage"]
[[], [1, "foo"], [2, "bar"], [3, "foo"], [8, "bar"], [10, "foo"], [11, "foo"]]
Output
[null, true, true, false, false, false, true]
Explanation
Logger logger = new Logger();
logger.shouldPrintMessage(1, "foo"); // return true, next allowed timestamp for "foo" is 1 + 10 = 11
logger.shouldPrintMessage(2, "bar"); // return true, next allowed timestamp for "bar" is 2 + 10 = 12
logger.shouldPrintMessage(3, "foo"); // 3 < 11, return false
logger.shouldPrintMessage(8, "bar"); // 8 < 12, return false
logger.shouldPrintMessage(10, "foo"); // 10 < 11, return false
logger.shouldPrintMessage(11, "foo"); // 11 >= 11, return true, next allowed timestamp for "foo" is 11 + 10 = 21
Constraints:
0 <= timestamp <= 109
Every timestamp will be passed in non-decreasing order (chronological order).
1 <= message.length <= 30
At most 104 calls will be made to shouldPrintMessage.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */I noticed in the I could not figure out how to do this without resorting to using :- use_module(library(assoc)).
:- use_module(library(clpz)).
:- use_module(library(reif)).
data_time_message_t(Assoc0, Time, Message, Truth, Assoc) :-
assoc:get_assoc(Message, Assoc0, Time0),
#MustBeGreaterThan #= #Time0 + 10,
if_( #MustBeGreaterThan #< #Time,
( Truth=true,
assoc:put_assoc(Message, Assoc0, Time, Assoc)
),
( Truth=false,
Assoc=Assoc0
)
).
data_time_message_t(Assoc0, Time, Message, Truth, Assoc) :-
\+ assoc:get_assoc(Message, Assoc0, _),
Truth=true,
assoc:put_assoc(Message, Assoc0, Time, Assoc).
?- data_time_message_t(t("foo",2,-,t,t), 3, "foo", Truth, Assoc).
%@ Truth = false, Assoc = t("foo",2,-,t,t)
%@ ; false.To be fair, I couldn't solve this with :- use_module(library(assoc)).
:- use_module(library(clpz)).
:- use_module(library(dif)).
:- use_module(library(reif)).
:- use_module(library(lists)).
data_time_message_t(Data0, Time, Message, Truth, Data) :-
memberd_t([Message, Time0], Data0, true),
if_( #Time0 + 10 #< #Time,
( Truth=true,
select([Message, Time0], Data0, Data1),
append([[Message, Time]], Data1, Data)
),
( Truth=false,
Data=Data0
)
).
data_time_message_t(Data0, Time, Message, true, Data) :-
\+ member([Message, _Time0], Data0),
append([[Message, Time]], Data0, Data).
%% works as expected
?- data_time_message_t([["foo",2]], 13, "foo", Truth, Data).
%@ Truth = true, Data = [["foo",13]]
%@ ; false.but with data_time_message_t(Data0, Time, Message, true, Data) :-
memberd_t([Message, _Time0], Data0, false),
append([[Message, Time]], Data0, Data).
% doesn't work as expected :(
?- data_time_message_t([["foo",2]], 13, "foo", Truth, Data).
%@ Truth = true, Data = [["foo",13]]
%@ ; Truth = true, Data = [["foo",13],["foo",2]], dif:dif(["foo",2],["foo",_A]).so, maybe the problem is the user, not Edit: The answer selected is just the information organized into one place. Credit goes to @haijinSk for asking the right questions, @triska for the BIG clue, and @bakaq spelling it out for me. 😅 Any remaining mistakes are mine. |
Beta Was this translation helpful? Give feedback.
Replies: 8 comments 28 replies
-
|
I'm a very naive beginner, I apologize. I have myself a question in context of this question. Is bad using negation, if my predicate is not intended to be a true relation, meaning working in bi-directional mode? If membership is the question and everything is grounded (no free variables), isn't it a classical (whatever it means) negation? Like: if I know that something is not here, then |
Beta Was this translation helpful? Give feedback.
-
|
Only programming to what "is true" is the same thing in digital circuit design, too. So for instance when trying to implement XOR from logic gates, even though the table has results for zero, you dont ever say "if result is zero" -- you just ignore those completely and design for when "if result is one" and focus exclusively on that. Then, if the result is NOT one, it just happens to be zero, and somehow that always works. An example of this style of design is what they call this "Sum of Products" logic. It's not necessarily the same as how Prolog logic works but it's the closest thing I can think of. Let's say your truth table has inputs A and B and output Z. Here's a possible scenario:
In this case, Z is '1' when:
Therefore, the SOP implementation for Z would be: Z = (NOT A AND B) OR (A AND B) Notice we ignore the first and third rows completely. Prolog is kind of the same way. At least thats the closest thing I can think of to compare it to, as much as I understand it so far. |
Beta Was this translation helpful? Give feedback.
-
|
More I study Prolog (I admit: in an ad hoc, fragmental, and intuitive fashion), more I see that "classical theory of Prolog", the "horn-&-herbrand" things ("things" with respect/without irony) are not very useful for a naive user as I am. And even some not naive, CS & math people see it in that light. A naive user see for example this: is the provable negation. In other words, to love Prolog, I have to study some "heretical" things. To love a programming language, I need a theory/philosophy; the right words (for my mind), concepts, metaphors, yes, even people and history... |
Beta Was this translation helpful? Give feedback.
-
Yes, in that case, but if I want to use Prolog as/for "knowledge-oriented" system, I'm not sure whether I want/can ignore "no". Or, what if I want to say something exactly when something is not in my data-set/collection or particular "data-table". |
Beta Was this translation helpful? Give feedback.
-
|
For instance, is there any ?- \+ member(X, "abc"). false. No? But in fact there is! ?- \+ member(n, "abc"). true. Is there a solution, or not? In fact, there are infinitely many solutions for We can easily express "not-member" using ?- maplist(dif(X), "abc"). dif:dif(X,a), dif:dif(X,b), dif:dif(X,c). Perfectly correct: Every |
Beta Was this translation helpful? Give feedback.
-
|
Thank you very much for the response; yes I want the generalizations every time I know how to have it, with hope that it will be in an elegant way... Thank you very much for showing the "maplist + dif" approach. That made my Prolog day... |
Beta Was this translation helpful? Give feedback.
-
|
Now, if I use the Markus @triska's "maplist+dif not-member": then again: So, as I (mis)understand it, it simply shows that (with the actual "code/query configuration") there is yet another solution... Or, what exactly is the expected result; only one/the first answer? |
Beta Was this translation helpful? Give feedback.
-
I really appreciate you asking these questions because I have the same questions. Ok, as I read it, this second answer is not valid. It's saying So I'm not sure why that answer is reported because of the logical contradiction, but it leads me to think at least there's a way to rewrite this so that it does not report the contradiction answer. |
Beta Was this translation helpful? Give feedback.
-
This is not what the residual goal says! It says: only if there is an The answer we get is obviously more general than you intend it to be, so you must add constraints that rule out the cases you intend to rule out. In your specific example, it is apparently not enough to restrict the list to not contain |
Beta Was this translation helpful? Give feedback.
-
|
I was able to cobble this together, which works as expected: :- use_module(library(assoc)).
:- use_module(library(clpz)).
:- use_module(library(dif)).
:- use_module(library(reif)).
:- use_module(library(lists)).
first([X|_], X).
data_time_message_t(Data0, Time, Message, Truth, Data) :-
memberd_t([Message, Time0], Data0, true),
if_( #Time0 + 10 #< #Time,
( Truth=true,
select([Message, Time0], Data0, Data1),
append([[Message, Time]], Data1, Data)
),
( Truth=false,
Data=Data0
)
).
data_time_message_t(Data0, Time, Message, true, Data) :-
maplist(first, Data0, Keys),
maplist(dif(Message), Keys),
append([[Message, Time]], Data0, Data).
?- data_time_message_t([], 13, "foo", Truth, Data).
%@ Truth = true, Data = [["foo",13]].
?- data_time_message_t([["foo",2]], 13, "foo", Truth, Data).
%@ Truth = true, Data = [["foo",13]]
%@ ; false.But I feel like I am missing a significant concept from @triska 's comment:
My original formulation was data_time_message_t(Data0, Time, Message, true, Data) :-
memberd_t([Message, _], Data0, false),
append([[Message, Time]], Data0, Data).because I really didn't care what the "value" was, I was only trying to check for the existence of the "key" data_time_message_t(Data0, Time, Message, true, Data) :-
maplist(dif([Message, _Time0]), Data0),
% ... snip ...was " I am happy that I found a solution that works for lists, which can probably be adapted to an |
Beta Was this translation helpful? Give feedback.
-
|
What you do with ?- maplist(dif(["a", _Time0]), [["a", 1]]).
% Can't be decided! This could actually be both true or false!
dif:dif(["a",_Time0],["a",1]).
?- maplist(dif(["a", _Time0]), [["a", 1]]), _Time0 = 1.
false.
?- maplist(dif(["a", _Time0]), [["a", 1]]), _Time0 = 2.
_Time0 = 2.The right way of expressing "does not contain key |
Beta Was this translation helpful? Give feedback.
-
|
As an aside, now that I have a somewhat working version, it can be written in the following heretical format: first([X|_], X).
cond_t([], false).
cond_t([Goals,Effects|Conds], Truth) :-
if_(Goals,
( Effects, Truth=true
),
cond_t(Conds, Truth)
).
cond(CondGoals) :-
cond_t(CondGoals, true).
else_(true).
data_time_message_t(Data0, Time, Message, Truth, Data) :-
cond([( memberd_t([Message, Time0], Data0),
#Time0 + 10 #< #Time
),
( Truth=true,
select([Message, Time0], Data0, Data1),
append([[Message, Time]], Data1, Data)
),
memberd_t([Message, Time0], Data0),
( Truth=false,
Data=Data0
),
else_,
( maplist(first, Data0, Keys),
maplist(dif(Message), Keys),
append([[Message, Time]], Data0, Data)
)
]).although I'm sure this is probably the preferred version: data_time_message_t(Data0, Time, Message, Truth, Data) :-
member([Message, Time0], Data0),
#Time0 + 10 #< #Time,
Truth=true,
select([Message, Time0], Data0, Data1),
append([[Message, Time]], Data1, Data).
data_time_message_t(Data0, Time, Message, Truth, Data) :-
member([Message, Time0], Data0),
#Time0 + 10 #>= #Time, % requires this extra qualifier
Truth=true,
Data=Data0.
data_time_message_t(Data0, Time, Message, true, Data) :-
maplist(first, Data0, Keys),
maplist(dif(Message), Keys),
append([[Message, Time]], Data0, Data). |
Beta Was this translation helpful? Give feedback.
-
I see. Ok I think I understand what you are saying, I accidentally left an unresolved "degree of freedom" in the answer. Thank you for helping me understand that a bit further. In my mind, it was an Yes yes. Much to consider. Chop wood, carry water... |
Beta Was this translation helpful? Give feedback.
-
|
Regarding what was said above: The constraint "does not contain Likewise, the following does not rule out ?- dif(a-B, X-Y), X = a. X = a, dif:dif(a-B,a-Y). Using an anonymous variable instead of ?- dif(a-_, X-Y), X = a.
X = a, dif:dif(a-_A,a-Y).
|
Beta Was this translation helpful? Give feedback.
-
|
So based on the prior conversations, with some heavy clues, that would indicate that this would be a possible way to test for "contains keys" in a :- use_module(library(assoc)).
:- use_module(library(clpz)).
:- use_module(library(dif)).
:- use_module(library(reif)).
:- use_module(library(lists)).
first([X|_], X).
data_time_message_t(Assoc0, Time, Message, Truth, Assoc) :-
assoc:get_assoc(Message, Assoc0, Time0),
#MustBeGreaterThan #= #Time0 + 10,
if_( #MustBeGreaterThan #< #Time,
( Truth=true,
assoc:put_assoc(Message, Assoc0, Time, Assoc)
),
( Truth=false,
Assoc=Assoc0
)
).
data_time_message_t(Assoc0, Time, Message, true, Assoc) :-
findall(Key, assoc:gen_assoc(Key, Assoc0, _), Keys),
maplist(dif(Message), Keys),
assoc:put_assoc(Message, Assoc0, Time, Assoc).
?- data_time_message_t(t, 2, "foo", Truth, Data).
%@ Truth = true, Data = t("foo",2,-,t,t).
?- Data0 = t("foo",2,-,t,t), data_time_message_t(Data0, 13, "foo", Truth, Data).
%@ Data0 = t("foo",2,-,t,t), Truth = true, Data = t("foo",13,-,t,t)
%@ ; false.
However, I'm not super thrilled to use Does anyone have any better ideas? |
Beta Was this translation helpful? Give feedback.
-
|
Ok, here's one more formulation that does not linearly scan the keys, but it requires a fourth case: :- use_module(library(assoc)).
:- use_module(library(clpz)).
:- use_module(library(dif)).
:- use_module(library(reif)).
:- use_module(library(lists)).
data_time_message_t(Assoc0, Time, Message, true, Assoc) :-
assoc:get_assoc(Message, Assoc0, Time0),
#MustBeGreaterThan #= #Time0 + 10,
#MustBeGreaterThan #< #Time,
assoc:put_assoc(Message, Assoc0, Time, Assoc).
data_time_message_t(Assoc0, Time, Message, false, Assoc) :-
assoc:get_assoc(Message, Assoc0, Time0),
#MustBeGreaterThan #= #Time0 + 10,
#MustBeGreaterThan #>= #Time,
Assoc=Assoc0.
data_time_message_t(Assoc0, Time, Message, true, Assoc) :-
assoc:get_assoc(Key, Assoc0, _),
dif(Key, Message),
assoc:put_assoc(Message, Assoc0, Time, Assoc).
data_time_message_t(t, Time, Message, true, Assoc) :-
assoc:put_assoc(Message, Assoc0, Time, Assoc).
?- data_time_message_t(t, 2, "foo", Truth, Data).
%@ Truth = true, Data = t("foo",2,-,t,t).
?- data_time_message_t(t("foo",2,-,t,t), 4, "foo", Truth, Data).
%@ Truth = false, Data = t("foo",2,-,t,t)
%@ ; false.
?- data_time_message_t(t("foo",2,-,t,t), 13, "foo", Truth, Data).
%@ Truth = true, Data = t("foo",13,-,t,t)
%@ ; false. |
Beta Was this translation helpful? Give feedback.
-
|
Hmmm... I find this very questionable data_time_message_t(Assoc0, Time, Message, true, Assoc) :-
assoc:get_assoc(Key, Assoc0, _),
dif(Key, Message),
assoc:put_assoc(Message, Assoc0, Time, Assoc).I think this might mean "there exists a |
Beta Was this translation helpful? Give feedback.
-
|
No, no, this is all wrong. There are a lot of errors with this. grumble. |
Beta Was this translation helpful? Give feedback.
-
|
So while working out the contains_t(_, t, _, false).
contains_t(Key, Assoc, Value, true) :-
get_assoc(Key0, Assoc, Value0),
( dif(Key0, Key)
; dif(Value0, Value)
).
?- contains_t(1, t, 2, Truth).
%@ Truth = false
%@ ; false. |
Beta Was this translation helpful? Give feedback.
-
|
Whoops, that would be "not contains". |
Beta Was this translation helpful? Give feedback.
-
|
Can you use |
Beta Was this translation helpful? Give feedback.
-
|
Probably -- I think there are some nuances with This caught me by surprise: :- use_module(library(assoc)).
:- use_module(library(lambda)).
?- Assoc2+\( put_assoc(a,t,1,Assoc0),
put_assoc(b,Assoc0,2,Assoc1),
put_assoc(c, Assoc1, 3, Assoc2)
).
%@ Assoc2 = t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)).
?- get_assoc(K, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), V).
%@ false.
?- gen_assoc(K, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), V).
%@ K = a, V = 1
%@ ; K = b, V = 2
%@ ; K = c, V = 3
%@ ; false. |
Beta Was this translation helpful? Give feedback.
-
|
Ok, this is as close as I've gotten. contains_key_assoc_t(Key, t, false).
contains_key_assoc_t(Key, t(K,V,Rel,L,R), true) :-
get_assoc(Key, t(K,V,Rel,L,R), _).
contains_key_assoc_t(Key, t(K,V,Rel,L,R), Found) :-
contains_key_assoc_t_(Key, t(K,V,Rel,L,R), Found).
contains_key_assoc_t_(Key, t(K,V,_,L,R), Found) :-
Assoc=t(K,V,_,L,R),
min_assoc(Assoc, Kmin, _),
max_assoc(Assoc, Kmax, _),
compare(Minrel, Kmin, Key), % Key should be @< Kmin if exists
compare(Maxrel, Kmax, Key), % Key should be @> Kmax if exists
if_(( Minrel=(<)
; Maxrel=(>)
),
Found=false,
( compare(Rel, Key, K),
contains_key_assoc_t(Rel, Key, V, L, R, Found)
)
).
contains_key_assoc_t(<, Key, _, Tree, _, Found) :-
contains_key_assoc_t(Key, Tree, Found).
contains_key_assoc_t(>, Key, _, _, Tree, Found) :-
contains_key_assoc_t(Key, Tree, Found).
?- contains_key_assoc_t(a, t, T).
%@ T = false.
?- contains_key_assoc_t(b, t(a,1,-,t,t), T).
%@ T = false.
?- contains_key_assoc_t(a, t(a,1,-,t,t), T).
%@ T = true
%@ ; false.
?- Assoc+\( put_assoc(a, t, 1, Assoc0),
put_assoc(b, Assoc0, 2, Assoc1),
put_assoc(c, Assoc1, 3, Assoc)
).
%@ Assoc = t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)).
?- contains_key_assoc_t(a, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), T).
%@ T = true
%@ ; T = false.
?- contains_key_assoc_t(b, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), T).
%@ T = true
%@ ; T = false.
?- contains_key_assoc_t(c, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), T).
%@ T = true
%@ ; T = false.
?- contains_key_assoc_t(d, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), T).
%@ T = false.There's a defaulty issue somewhere that I'm returning a |
Beta Was this translation helpful? Give feedback.
-
|
Oh wow, can someone double check this? It seems to be working, except it's not fully general because of the :- use_module(library(assoc)).
:- use_module(library(clpz)).
:- use_module(library(dif)).
:- use_module(library(reif)).
:- use_module(library(lists)).
:- use_module(library(lambda)).
contains_key_assoc_t(Key, t, false).
contains_key_assoc_t(Key, t(K,V,Rel,L,R), Found) :-
contains_key_assoc_t_(Key, t(K,V,Rel,L,R), Found).
contains_key_assoc_t_(Key, t(K,V,_,L,R), Found) :-
Assoc=t(K,V,_,L,R),
min_assoc(Assoc, Kmin, _),
max_assoc(Assoc, Kmax, _),
compare(Minrel, Kmin, Key), % Key should be (@<) Kmin if exists
compare(Maxrel, Kmax, Key), % Key should be (@>) Kmax if exists
if_((Minrel=(>);Maxrel=(<)),
Found=false,
( compare(Rel, Key, K), % could be (<) or (>),
contains_key_assoc_t(Rel, Key, V, L, R, Found)
)
).
contains_key_assoc_t(<, Key, _, t(K,V,Rel,L,R), _, Found) :-
Tree=t(K,V,Rel,L,R),
contains_key_assoc_t(Key, Tree, Found).
contains_key_assoc_t(>, Key, _, _, t(K,V,Rel,L,R), Found) :-
Tree=t(K,V,Rel,L,R),
contains_key_assoc_t(Key, Tree, Found).
contains_key_assoc_t(=, Key, _, _, _, true).
?- contains_key_assoc_t(a, t, T).
%@ T = false.
?- contains_key_assoc_t(b, t(a,1,-,t,t), T).
%@ T = false.
?- contains_key_assoc_t(a, t(a,1,-,t,t), T).
%@ T = true.
?- Assoc+\( put_assoc(a, t, 1, Assoc0),
put_assoc(b, Assoc0, 2, Assoc1),
put_assoc(c, Assoc1, 3, Assoc)
).
%@ Assoc = t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)).
?- contains_key_assoc_t(a, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), T).
%@ T = true.
?- contains_key_assoc_t(b, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), T).
%@ T = true.
?- contains_key_assoc_t(c, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), T).
%@ T = true.
?- contains_key_assoc_t(d, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), T).
%@ T = false.
?- contains_key_assoc_t(Key, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), T).
%@ T = false. |
Beta Was this translation helpful? Give feedback.
-
|
There seems to be no need to inspect |
Beta Was this translation helpful? Give feedback.
-
|
We used to call that the "shotgun" method. In this case I was "shotgunning" trying to remove redundant choicepoints 😅 |
Beta Was this translation helpful? Give feedback.
-
|
Please focus on writing an elegant program, we have the Prolog engine to automate indexing and remove choicepoints for us. |
Beta Was this translation helpful? Give feedback.
-
|
Of course -- the behavior is still not obvious to me and I'm still building up my intuition inductively, it will probably be a long time before I'm writing elegant Prolog and I appreciate all the guidance along the way 🙏 I'm still trying to determine which inspections are necessary and which are not. |
Beta Was this translation helpful? Give feedback.
-
|
I'm about ready to call QED on this. @triska regarding ..., this was the configuration I could achieve with the minimum number of introspections that admitted no redundant choicepoints. :- use_module(library(assoc)).
:- use_module(library(clpz)).
:- use_module(library(dif)).
:- use_module(library(reif)).
:- use_module(library(lists)).
:- use_module(library(lambda)).
contains_key_assoc_t(Key, t, false).
contains_key_assoc_t(Key, t(K,V,Rel,L,R), Found) :-
Assoc= t(K,V,Rel,L,R),
( ground(Key) ->
contains_key_assoc_t_(Key, Assoc, Found)
; gen_assoc(Key, Assoc, _), Found=true
).
contains_key_assoc_t_(Key, t(K,V,_,L,R), Found) :-
Assoc=t(K,V,_,L,R),
min_assoc(Assoc, Kmin, _),
max_assoc(Assoc, Kmax, _),
compare(Minrel, Kmin, Key), % Key should be (@<) Kmin if exists
compare(Maxrel, Kmax, Key), % Key should be (@>) Kmax if exists
if_((Minrel=(>);Maxrel=(<)),
Found=false,
( compare(Rel, Key, K), % could be (<) or (>),
contains_key_assoc_t(Rel, Key, V, L, R, Found)
)
).
contains_key_assoc_t(<, Key, _, Tree, _, Found) :-
contains_key_assoc_t(Key, Tree, Found).
contains_key_assoc_t(>, Key, _, _, Tree, Found) :-
contains_key_assoc_t(Key, Tree, Found).
contains_key_assoc_t(=, Key, _, _, _, true).
?- contains_key_assoc_t(a, t, T).
%@ T = false.
?- contains_key_assoc_t(b, t(a,1,-,t,t), T).
%@ T = false.
?- contains_key_assoc_t(a, t(a,1,-,t,t), T).
%@ T = true.
?- Assoc+\( put_assoc(a, t, 1, Assoc0),
put_assoc(b, Assoc0, 2, Assoc1),
put_assoc(c, Assoc1, 3, Assoc)
).
%@ Assoc = t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)).
?- contains_key_assoc_t(a, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), T).
%@ T = true.
?- contains_key_assoc_t(b, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), T).
%@ T = true.
?- contains_key_assoc_t(c, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), T).
%@ T = true.
?- contains_key_assoc_t(d, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), T).
%@ T = false.
?- contains_key_assoc_t(Key, t(b,2,-,t(a,1,-,t,t),t(c,3,-,t,t)), T).
%@ Key = a, T = true
%@ ; Key = b, T = true
%@ ; Key = c, T = true
%@ ; false.
?- contains_key_assoc_t(x, Assoc, false).
%@ Assoc = t
%@ ; Assoc = t(_A,_B,_C,t,t)
%@ ; Assoc = t(_A,_B,_C,t,t(_D,_E,_F,_G,t))
%@ ; Assoc = t(_A,_B,_C,t,t(_D,_E,_F,_G,t(_H,_I,_J,_K,t)))
%@ ; ... .
?- contains_key_assoc_t(x, Assoc, true).
%@ error('$interrupt_thrown',repl/0).
?- contains_key_assoc_t(Key, Assoc, true).
%@ error('$interrupt_thrown',repl/0).
?- contains_key_assoc_t(x, Assoc, false).
%@ Assoc = t
%@ ; Assoc = t(_A,_B,_C,t,t)
%@ ; Assoc = t(_A,_B,_C,t,t(_D,_E,_F,_G,t))
%@ ; Assoc = t(_A,_B,_C,t,t(_D,_E,_F,_G,t(_H,_I,_J,_K,t)))
%@ ; ... .
?- contains_key_assoc_t(x, Assoc, true).
%@ error('$interrupt_thrown',repl/0).
?- Assoc+\( put_assoc(d, t, 1, Assoc0),
put_assoc(b, Assoc0, 2, Assoc1),
put_assoc(x, Assoc1, 3, Assoc2),
put_assoc(c, Assoc2, 3, Assoc3),
put_assoc(9, Assoc3, 3, Assoc)
).
%@ Assoc = t(d,1,<,t(b,2,-,t(9,3,-,t,t),t(c,3,-,t,t)),t(x,3,-,t,t)).
?- T^Shouldbefalse+\(
( put_assoc(d, t, 1, Assoc0),
put_assoc(b, Assoc0, 2, Assoc1),
put_assoc(x, Assoc1, 3, Assoc2),
put_assoc(c, Assoc2, 3, Assoc3),
put_assoc(9, Assoc3, 3, Assoc),
contains_key_assoc_t_(d, Assoc, T),
contains_key_assoc_t_(b, Assoc, T),
contains_key_assoc_t_(x, Assoc, T),
contains_key_assoc_t_(c, Assoc, T),
contains_key_assoc_t_(9, Assoc, T),
contains_key_assoc_t(notfound, Assoc, Shouldbefalse)
)
).
%@ T = true, Shouldbefalse = false.
contains_key_assoc(Key, Assoc) :-
contains_key_assoc_t(Key, Assoc, true).
% edited with suggestions from @triska
% https://github.com/mthom/scryer-prolog/discussions/2577#discussioncomment-10786041
data_time_message_t(Assoc0, Time, Message, Assoc, Truth) :-
if_(contains_key_assoc_t(Message, Assoc0),
( get_assoc(Message, Assoc0, Time0),
if_( clpz_t(#Time0 + 10 #< #Time),
( Truth=true,
assoc:put_assoc(Message, Assoc0, Time, Assoc)
),
( Truth=false,
Assoc=Assoc0
)
)
),
( Truth=true,
put_assoc(Message, Assoc0, Time, Assoc)
)
).
?- data_time_message_t(t, 2, "foo", Assoc, Truth).
%@ Assoc = t("foo",2,-,t,t), Truth = true.
?- data_time_message_t(t("foo",2,-,t,t), 3, "foo", Assoc, Truth).
%@ Assoc = t("foo",2,-,t,t), Truth = false.
?- data_time_message_t(t("foo",2,-,t,t), 13, "foo", Assoc, Truth).
%@ Assoc = t("foo",13,-,t,t), Truth = true.
?- A2+\( (data_time_message_t(t, 2, "foo", A0, true),
data_time_message_t(A0, 3, "foo", A0, false),
data_time_message_t(A0, 1, "bar", A1, true),
data_time_message_t(A1, 14, "foo", A2, true),
data_time_message_t(A2, 2, "bar", A2, false))
).
%@ A2 = t("foo",14,<,t("bar",1,-,t,t),t). |
Beta Was this translation helpful? Give feedback.
-
|
Personally I find this: data_time_message_t(Assoc0, Time, Message, Assoc, Truth) :-
if_(contains_key_assoc_t(Message, Assoc0),
( assoc:get_assoc(Message, Assoc0, Time0),
#MustBeGreaterThan #= #Time0 + 10,
if_( #MustBeGreaterThan #< #Time,
( Truth=true,
assoc:put_assoc(Message, Assoc0, Time, Assoc)
),
( Truth=false,
Assoc=Assoc0
)
)
),
( Truth=true,
assoc:put_assoc(Message, Assoc0, Time, Assoc)
)
).pretty ugly and if anyone knows any better options, I'd be interested... at least until the smoke clears from this discussion on cond. |
Beta Was this translation helpful? Give feedback.
-
|
Several things can be removed immediately, for instance, there is no need for the |
Beta Was this translation helpful? Give feedback.
-
|
That's true. Although I don't mind the module namespacing, I personally prefer that syntax, I think it tends to help with readability. Overall though I would prefer something much flatter: cond_t([], false).
cond_t([Goals,Effects|Conds], Truth) :-
if_(Goals,
( Effects, Truth=true
),
cond_t(Conds, Truth)
).
cond(Goals) :-
cond_t(Goals, true).
contains_key_assoc_value_t(Key, Assoc, Value, Truth) :-
if_(contains_key_assoc_t(Key, Assoc),
( get_assoc(Key, Assoc, Value),
Truth=true
),
Truth=false
).
?- contains_key_assoc_value_t(a, t(a,1,-,t,t), V, T).
%@ V = 1, T = true.
?- contains_key_assoc_value_t(b, t(a,1,-,t,t), V, T).
%@ T = false.
else_(true).
data_time_message_t_cond(Assoc0, Time, Message, Assoc, Truth) :-
cond([( contains_key_assoc_value_t(Message, Assoc0, Time0),
#Time0 + 10 #< #Time
),
( Truth=true,
assoc:put_assoc(Message, Assoc0, Time, Assoc)
),
( contains_key_assoc_value_t(Message, Assoc0, Time0),
clpz_t(#Time0 + 10 #>= #Time)
),
( Truth=false,
Assoc=Assoc0
),
contains_key_assoc_t(Message, Assoc0),
( Truth=false,
Assoc=Assoc0
),
else_,
( Truth=true,
put_assoc(Message, Assoc0, Time, Assoc)
)
]).
?- data_time_message_t_cond(t, 2, "foo", Assoc, Truth).
%@ Assoc = t("foo",2,-,t,t), Truth = true.
?- data_time_message_t_cond(t("foo",2,-,t,t), 3, "foo", Assoc, Truth).
%@ Assoc = t("foo",2,-,t,t), Truth = false.
?- data_time_message_t_cond(t("foo",2,-,t,t), 13, "foo", Assoc, Truth).
%@ Assoc = t("foo",13,-,t,t), Truth = true.
?- A2+\(
( data_time_message_t_cond(t, 2, "foo", A0, true),
data_time_message_t_cond(A0, 3, "foo", A0, false),
data_time_message_t_cond(A0, 1, "bar", A1, true),
data_time_message_t_cond(A1, 14, "foo", A2, true),
data_time_message_t_cond(A2, 2, "bar", A2, false)
)
).
%@ A2 = t("foo",14,<,t("bar",1,-,t,t),t).I understand there are problems with this style of |
Beta Was this translation helpful? Give feedback.
-
|
Something like this would be really nice 🤤 , but I'm still studying the data_time_message_t_cond(Assoc0, Time, Message, Assoc, Truth) :-
( contains_key_assoc_value_t(Message, Assoc0, Time0),
#Time0 + 10 #< #Time
?? Truth=true,
assoc:put_assoc(Message, Assoc0, Time, Assoc)
:: contains_key_assoc_value_t(Message, Assoc0, Time0),
clpz_t(#Time0 + 10 #>= #Time)
?? Truth=false,
Assoc=Assoc0
:: contains_key_assoc_t(Message, Assoc0)
?? Truth=false,
Assoc=Assoc0
:: else_
?? Truth=true,
put_assoc(Message, Assoc0, Time, Assoc)
).I'm also not sure if it meets all the points discussed here yet. |
Beta Was this translation helpful? Give feedback.
I'm about ready to call QED on this. @triska regarding ..., this was the configuration I could achieve with the minimum number of introspections that admitted no redundant choicepoints.