sputnik13 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
mat_bug has quit [Ping timeout: 252 seconds]
mat_bug has joined #ruby
mat_bug has quit [Ping timeout: 252 seconds]
mat_bug has joined #ruby
hutch has joined #ruby
x0f_ has quit [Ping timeout: 252 seconds]
mat_bug has quit [Ping timeout: 252 seconds]
ur5us has quit [Remote host closed the connection]
mat_bug has joined #ruby
ur5us has joined #ruby
Eiam has joined #ruby
thoraxe has joined #ruby
thoraxe has quit [Quit: WeeChat 2.2]
ur5us has quit [Read error: Connection reset by peer]
hutch has quit [Ping timeout: 250 seconds]
mat_bug has quit [Ping timeout: 252 seconds]
orbyt_ has joined #ruby
mat_bug has joined #ruby
donofrio has joined #ruby
<Scriptonaut>
I'm having some really strane behavior with overriding a setter method on an object, I've explained the error in the gist I'm about to post, but I'll summarize here. I call super in a method override for a setter method. When I call that method, I get "NoMethoderror: super: no superclass method". However the original method is defined, when I comment out the method override definition I can call it just
<Scriptonaut>
also when I comment out the method override, my_object.methods includes my method. So the error is complaining that there is no superclass method, when there definitely is a superclass method
uplime has quit [Ping timeout: 258 seconds]
x0f has joined #ruby
AJA4350 has quit [Ping timeout: 268 seconds]
SuperL4g is now known as SuperLag
AJA4350 has joined #ruby
mat_bug has quit [Ping timeout: 252 seconds]
donofrio has quit [Ping timeout: 268 seconds]
mat_bug has joined #ruby
uplime has joined #ruby
<phaul>
Scriptonaut: what's GlobalUser.superclass and what is GlobalUser.superclass.instance_methods.grep /receive_direct_message/
<Scriptonaut>
superclass is PgsqlDatabase(abstract), and result of that grep is []. I'm not trying to call a method on the super class though, I'm trying to call the method that existed there before it was overrode
<phaul>
doesn't matter. super calls superclass
mat_bug has quit [Ping timeout: 252 seconds]
<Scriptonaut>
hmm, this is so odd, isn't there a way to call the method that a certain method overrode?
<Scriptonaut>
ya, you're right, I wonder what I was thinking. I confused something here
<Scriptonaut>
I guess there probably isn't a way
<phaul>
there is module prepend and rails used to do method alias chain
<phaul>
quick google I havent actually read this, but should point you in the right direction anyway
<leftylink>
I seem to recall a way to preserve the old one before overriding it, mabe it was something to do with `method(:receive_direct_message_alerts=)` . sorry I don't have the exact stuff right now
<Scriptonaut>
ya, me too, I could have sworn there was a common way to do this
<phaul>
module prepend is the modern way of doing this
<Scriptonaut>
I think maybe I just got so used to using it in descended classes that I started to think I could use it everywhere
<phaul>
override it in a module that you prepend, and in that module you *can* call super
<leftylink>
considerably more janky, it is true that module prepend is a less jank way
<Scriptonaut>
I think I figured out where I got confused. This is a text-based json column for an active record object. Normally I do this, but rather than super I call read_attribute(:blah)
cthulchu has quit [Ping timeout: 246 seconds]
<Scriptonaut>
since this column already comes with a getter/setter out of the gate that parses the json text, I can't simply get rid of it and rely on read_attribute
bmurt has joined #ruby
mat_bug has joined #ruby
<phaul>
&>> class X; def f; 1; end; end; module Y; def f; super * 10; end; end; X.prepend(Y); X.new.f
<Scriptonaut>
ya that will work for sure. I think it that level of confusion won't be worth it, I can just rename the original getter/setter, and then keep the current name for the setter override, and add a getter override as well
<Scriptonaut>
I think that level**
<Scriptonaut>
people won't think to look at the bottom of the file for X.prepend
<Scriptonaut>
unless there's a way to do: def self.included(klass); klass.prepend my_method; end
mat_bug has quit [Ping timeout: 252 seconds]
mat_bug has joined #ruby
<phaul>
it doesn't have to be at the bottom of the file it can be right next to your method
<feep[work]>
how do I access a method defined in a required file from within a class that defines an accessor method with the same name?
<baweaver>
Have an example?
<baweaver>
Ideally you don't do that. Also that's quite a mouthful to say out loud
<feep[work]>
ikr
<feep[work]>
also I figured out a workaround by just aliasing the thing
<baweaver>
That'd work.
<feep[work]>
uh it's kinda specific, we're using ruby/rake for building, and we have a helper function called unittest and I'm defining a class with a list of unittest source files also called unittest
<feep[work]>
so I'm just gonna alias the function to unittest_, lol
<feep[work]>
or run_unittests, that's probably better
za1b1tsu has joined #ruby
sauvin has quit [Quit: Leaving]
tdy has quit [Ping timeout: 258 seconds]
sauvin has joined #ruby
aupadhye has joined #ruby
tdy has joined #ruby
aupadhye is now known as aupadhye|afk
paranoicsan has quit [Quit: paranoicsan]
mat_bug has joined #ruby
porg has quit [Remote host closed the connection]
porg has joined #ruby
za1b1tsu has quit [Remote host closed the connection]
feep[work] has left #ruby [#ruby]
porg has quit [Ping timeout: 250 seconds]
krawchyk has joined #ruby
krawchyk_ has quit [Ping timeout: 246 seconds]
clemens3_ has joined #ruby
BH23 has joined #ruby
djdduty has quit [Ping timeout: 258 seconds]
cd has quit [Quit: cd]
mat_bug has quit [Remote host closed the connection]
ur5us has joined #ruby
wildermind has joined #ruby
kapil____ has quit [Quit: Connection closed for inactivity]
bairyn has joined #ruby
ByronJohnson has quit [Ping timeout: 268 seconds]
jmcgnh has quit [Read error: Connection reset by peer]
jmcgnh has joined #ruby
ua has joined #ruby
xrexeon has joined #ruby
xrexeon has quit [Max SendQ exceeded]
xrexeon has joined #ruby
arekushi has joined #ruby
mikecmpbll has joined #ruby
aupadhye|afk is now known as aupadhye
tdy has quit [Ping timeout: 244 seconds]
cnsvc has quit [Ping timeout: 256 seconds]
lxsameer has joined #ruby
jacksop has joined #ruby
venmx has joined #ruby
sylario has joined #ruby
ur5us has quit [Remote host closed the connection]
xrexeon has quit [Ping timeout: 268 seconds]
sarink has quit [Remote host closed the connection]
za1b1tsu has joined #ruby
za1b1tsu has quit [Ping timeout: 250 seconds]
esrse has quit [Quit: bye]
d^sh has quit [Ping timeout: 246 seconds]
wildermind has quit [Quit: Connection closed for inactivity]
d^sh has joined #ruby
paranoicsan has joined #ruby
za1b1tsu has joined #ruby
conta has quit [Ping timeout: 250 seconds]
jacksop has quit [Remote host closed the connection]
jacksop has joined #ruby
fanta7531 has joined #ruby
jacksop has quit [Remote host closed the connection]
BH23 has quit [Ping timeout: 258 seconds]
jacksop has joined #ruby
conta has joined #ruby
BH23 has joined #ruby
paranoicsan is now known as paranoicsan[Away
paranoicsan[Away is now known as paranoicsan
lxsameer has quit [Ping timeout: 246 seconds]
lxsameer has joined #ruby
jacksop has quit [Remote host closed the connection]
jacksop has joined #ruby
chichou has joined #ruby
chichou has quit [Client Quit]
clemens3_ has quit [Ping timeout: 258 seconds]
jacksop has quit []
foxxx0 has quit [Ping timeout: 250 seconds]
Nicmavr has quit [Read error: Connection reset by peer]
ua has quit [Ping timeout: 245 seconds]
Nicmavr has joined #ruby
djdduty has joined #ruby
foxxx0 has joined #ruby
jaddison_ has joined #ruby
mikecmpb_ has joined #ruby
mikecmpbll has quit [Ping timeout: 272 seconds]
jaddison has quit [Ping timeout: 244 seconds]
lxsameer has quit [Ping timeout: 268 seconds]
akem__ has joined #ruby
lxsameer has joined #ruby
akem has quit [Ping timeout: 252 seconds]
clemens3_ has joined #ruby
lxsameer has quit [Ping timeout: 258 seconds]
lxsameer has joined #ruby
yokel has quit [Remote host closed the connection]
<ruby[bot]>
please post the full error output, including the command invocation that produces it and any mentioned log files to https://gist.github.com
<ruby[bot]>
noob69: we in #ruby do not like pastebin.com, it loads slowly for most, has ads which are distracting and has terrible formatting. Please use https://gist.github.com
<ponzii>
I read that Ruby modules don't have instances yet in many gem sources I see instance variables all over the place.
<phaul>
Hoffman: you are using a private API which I don't think was meant to be used to check for equality. There diff description is "empty", only a newline.
<ponzii>
I'm even seeing @variable outside module scope, ie. in file/main scope, in, for example Nokogiri source.
<Hoffman>
phaul: how can I tell the API is private
gothicsouth has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
<Hoffman>
phaul: ah, need to submit an errata thing to Packt I guess
<Hoffman>
phaul: can you tell me what you mean by 'There diff description is "empty", only a newline'
<Hoffman>
those 2 things are opposites; a newline is content and thus not empty
<phaul>
I mean looking at the diffing method it seems they try to format for RSpec output only considering how it would look if it has to print a diffable object mismatch. They don't seem to care about extra newlines not being in the actual strings they are diffing.
<phaul>
I meant on that gihub project page the first sentence is : Not intended for direct use.
<Hoffman>
yea, tryna find out what they replaced it with
gothicsouth has joined #ruby
dellavg_ has quit [Ping timeout: 250 seconds]
kmossco has joined #ruby
cd has joined #ruby
sarink has quit [Remote host closed the connection]
<phaul>
ponzii: yes modules cannot be instatiated. But they can be mixed in into classes. In that case their instance variables will belong to the instance of the class
<Hoffman>
yeah cant find if they replaced it with anything
<ponzii>
phaul: Isn't this kind of tying implementation a code smell in most languages?
<Hoffman>
after moving it into RSpec::Support
<Hoffman>
real shame
Fernando-Basso has joined #ruby
<ponzii>
phaul: Isn't a module, in the ordinary definition, a self-contained unit not something which makes assumptions about how it will be used?
<ponzii>
phaul: As I mentioned, I'm even seeing instance variables outside module scope. What gives?
<phaul>
hm there are two kind of modules. Modules that are meant to be mixed in and modules that are meant to be used on their own. (and some whacky ones that can do both). Bot each kind is a self contained unit that's sensible on its own.
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<phaul>
But*
conta1 has quit [Quit: conta1]
<phaul>
Just the ones that are mixins exist to be mixed in. There is some tying there sometimes with what the mixing in class should implement. That's usually well documented. Examples: Comparable wants <=>. Enumerable wants each.
<ponzii>
phaul: I can't see how anything which makes assumptions about its usage can be self-contained.
<phaul>
maybe not self contained but the best option for what it does: implement some common aspect of classes that would have been replicated in all classes otherwise, but something that is tightly coupled with the class. Like being Comparable is a good example. Common task, but the actual class know how to do <=>.
<phaul>
let's talk about the other question you asked. instance vars outside of Module scope. can you link the line on github?
<ponzii>
phaul: Better language design would have been to distinguish Module and Mixin.
<ponzii>
phaul: At which point I realise my suspicions about OOP were justified. I need to get back to procedural/functional programming.
<al2o3-cr>
ponzii: yeah, ok.
<ponzii>
phaul: So much of OOP is just needless complexity for zero gain.
<phaul>
np. If that's how you feel, Im not trying to convince you otherwise
<ponzii>
phaul: These are just senseless contortions.
<devil_tux>
anyone might dropping their preffered version?
<phaul>
devil_tux: definately second out of the two
<devil_tux>
phaul: roger
<devil_tux>
dunno what is wrong with me
<SeepingN>
I like the rubyness of the 2nd, but like the similarity in the two possible outcomes for the 1st snip
<SeepingN>
Q you have to wonder was consdiered or expected implicitly: if @instance << x fails somehow, then what does it do
Dbugger has quit [Remote host closed the connection]
<devil_tux>
SeepingN: yea its needless `if` tbh
<devil_tux>
just another tick to cpu
<devil_tux>
but it reads so easier/cleaner for me
<SeepingN>
something wonkyh happens to @instance and you fail to append "...", you get an exception.
donofrio_ has joined #ruby
cd has quit [Remote host closed the connection]
sarink has joined #ruby
cd has joined #ruby
<Hoffman>
devil_tux: what is this function supposed to do?
<Hoffman>
IE what data does it operate on
<devil_tux>
Hoffman: I don't follow?
<devil_tux>
its pretty self-explanatory
<leftylink>
that `if @instance << x` seems deceptive if the expectation is that it will always be truthy. if it absolutely must be on one line, perhaps `false.tap { @instance << x}` instead?
<Hoffman>
devil_tux: I mean it looks like you're using a bitwise operator to operate on strings
<Hoffman>
?
<leftylink>
or I guess you can go all the way with the tapping, so `@instance.include?(x).tap { |b| @instance << x unless b }`
<Hoffman>
ah, I guess my documentation was outdated
sarink has quit [Ping timeout: 240 seconds]
<ponzii>
quit
ponzii has quit [Quit: [BX] Hanson uses BitchX. Mommy, can we dress like boys again?]
<SeepingN>
ahead = false
<devil_tux>
leftylink: thats cool :)
<phaul>
or be perly ( if it's even perly) on the last line: @instance << x and return false
<devil_tux>
phaul: that works?
<phaul>
yes
<devil_tux>
isn't that read as AND operator
<SeepingN>
so use &&
<devil_tux>
same?
<devil_tux>
; might work
<phaul>
no. use and
<SeepingN>
no
<phaul>
that's the point
<SeepingN>
"else" what
<leftylink>
I'd prefer `;` in the situation. `and` is still implying that the truthiness of `@instance << x` matters
<leftylink>
when we expect it to not
<SeepingN>
returns nil, though more likely crashes with exception
<al2o3-cr>
doesn't matter in that instance but whatever.
<SeepingN>
I assumed it did matter
<phaul>
and precedence is such it is meant to chain thing like do this and do that. && is meant to be used for &&ing booleans
<al2o3-cr>
SeepingN: it doesnn't
donofrio_ has quit [Ping timeout: 272 seconds]
brandonkal has joined #ruby
ellcs has quit [Ping timeout: 250 seconds]
<al2o3-cr>
SeepingN: you might be thinking of bitwise left shift.
sgen has quit [Ping timeout: 252 seconds]
<al2o3-cr>
it's a method call.
<SeepingN>
uh what
<SeepingN>
moving on
<devil_tux>
leftylink: good points
<al2o3-cr>
devil_tux: just do what is readable.
<SeepingN>
and correct
<phaul>
going back to version 2. we haven't talked about why you disliked it.. To me that is the obvious solution
<leftylink>
also since it was never explicitly stated... there *was* a bit of uncertainty about `@instance` but I suppose the assumption in most of my statements was that it was either an array or a string, therefore `<<` will always be truthy
<al2o3-cr>
leftylink: wrong.
<devil_tux>
leftylink: yeah, its array of strings
<phaul>
but if it's not always truthy the two programs are not even doing the same!
<phaul>
because obviously you want to append '...' to all those ( including nil )
donofrio_ has joined #ruby
<al2o3-cr>
phaul: obviously not.
<al2o3-cr>
leftylink: i should of read your answer more clearly ;(
<leftylink>
recall that for the given code to make sense we also have to intersect that set with the set of things that have `include?` ... also that I assumed that `includes?` in the original was misspelled
r29v has quit [Quit: r29v]
jenrzzz has joined #ruby
<al2o3-cr>
leftylink: it still understandable. it was me flashing through it ;)
<al2o3-cr>
still, @instance could of been anything.
donofrio_ has quit [Ping timeout: 244 seconds]
<phaul>
well, sometimes you don't formally establish the preconditions, just go with your gut feeling of what they probably meant
<al2o3-cr>
phaul: i generally do.
RedNifre has joined #ruby
s3nd1v0g1us has joined #ruby
venmx has joined #ruby
<Hoffman>
[16:46:42] phaul or be perly ( if it's even perly) on the last line: @instance << x and return false
<Hoffman>
or last line !(@instance << x) :D
<Hoffman>
oops devil_tux^
<phaul>
yeah. and is more idiomatic there but don't do any of that
<Hoffman>
in general though you have a boolean method with side effects
lxsameer has joined #ruby
<al2o3-cr>
it's ruby do whatever you like :P
<Hoffman>
which affects objects in-place
<Hoffman>
so youd need the method to be skip!?
<Hoffman>
:D
<Hoffman>
no but maybe break it out into 2 methods to make it clear that the boolean method doesn't change objects in place, and the object-changing method doesnt need to return a boolean
cnsvc has quit [Ping timeout: 256 seconds]
<al2o3-cr>
Hoffman: `a = [1,2,3,4]; a << a.shift' is that worthy?
profetes has quit [Quit: Leaving]
<al2o3-cr>
is that a bang?
<Hoffman>
al2o3-cr: sorry, is this a separate question to devil_tux's?
<Hoffman>
s/question/scenario/
<Hoffman>
not sure what youre wondering when you mean worthy but the object being modified in-place would probably spur me to use a bang
<al2o3-cr>
Hoffman: nm. ponzii
<Hoffman>
I guess if it's all defined within the method, including a, it wouldnt use one
<phaul>
Hoffman: bang does not mean self modifiying or destructive methods.
<Hoffman>
correct
<Hoffman>
oh I see what you are saying, yea you are right
<Hoffman>
since its not modifying the args in place
<Hoffman>
still, I am of the personal opinion that it shouldnt do that 1) because it's supposed to do nothing but return a boolean, and 2) I dont like side effects :P
<al2o3-cr>
Hoffman: never args only objects.
<al2o3-cr>
Hoffman: no booleans in Ruby.
<Hoffman>
I beg your pardon?
mat_bug has joined #ruby
<Hoffman>
Ruby doesn't have the concept of trueness or falseness?
<Hoffman>
no matter how implemented, if so, it has booleans, theyre just implemented in one way or another
<devil_tux>
leftylink: uh, not a Ruby per se :>
<Hoffman>
I feel like this might be a semantic debate though
donofrio_ has joined #ruby
<al2o3-cr>
C as 0 or 1
<phaul>
there are booleans, true and false. and apart from that values are either truthy and falsy
<Hoffman>
right
RedNifre has quit [Ping timeout: 252 seconds]
<al2o3-cr>
no, no booleans
<Hoffman>
al2o3-cr: well Ill leave it to you and phaul to work out, then
<phaul>
al2o3-cr: you want to start the philosophical discussion of what it means to be a boolean. Ok what's the definition of a boolean
<Hoffman>
seems like "no booleans" is an idiomatic phrase intended to confuse newbies
<al2o3-cr>
Hoffman: ruby as baboons, only.
<phaul>
Here's my definition: booleans are true and false and they exist in Ruby
<Hoffman>
phaul: literally any representation of trueness or falseness, implemented in any way
bmurt has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
mat_bug has joined #ruby
donofrio_ has quit [Ping timeout: 258 seconds]
sarink has joined #ruby
gothicsouth has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
mat_bug has quit [Ping timeout: 252 seconds]
* al2o3-cr
is hanging out with a baboon
<phaul>
btw nil << '...' is not falsey
<phaul>
it doesn't even run. That't not what falsey is
donofrio_ has joined #ruby
twobitsprite has quit [Ping timeout: 240 seconds]
clemens3_ has joined #ruby
mat_bug has joined #ruby
krawchyk has quit [Quit: krawchyk]
RiPuk has joined #ruby
<al2o3-cr>
phaul: true.
krawchyk has joined #ruby
<al2o3-cr>
it raises as it should do.
<phaul>
sure, in the heat of the discussion it was said as a falsey example. thats all
mat_bug has quit [Ping timeout: 252 seconds]
<al2o3-cr>
phaul: i think they were simply implying if @instance was nil.
polishdub has quit [Remote host closed the connection]
<phaul>
in which case neither code works
<al2o3-cr>
exactly.
clemens3_ has quit [Ping timeout: 246 seconds]
<SeepingN>
yes
prestorium has quit [Quit: prestorium]
<devil_tux>
omg guyz u still discussing?
<Hoffman>
?
jenrzzz has quit [Read error: Connection reset by peer]
<SeepingN>
apparently
<devil_tux>
classic #ruby :]
jenrzzz has joined #ruby
<SeepingN>
look, answer, code for 10 minutes, repeat
<al2o3-cr>
or any other object for that matter that doesn't respond to #<<
Nicmavr has quit [Read error: Connection reset by peer]
<Hoffman>
debate is the heart of dialecticism and epistemology
<phaul>
right. so from the which code is better you managed to conclude that the question was incomplete, and the methods are all broken. Congrats to all
<havenwood>
devil_tux: I don't like the idea of mutation in a predicate method.
Nicmavr has joined #ruby
krawchyk has quit [Quit: krawchyk]
<Hoffman>
^
mat_bug has joined #ruby
donofrio_ has quit [Remote host closed the connection]
donofrio_ has joined #ruby
RiPuk has quit [Ping timeout: 244 seconds]
<havenwood>
devil_tux: Folk might be able to provide better suggestions if you can zoom out and show a bit more context around where that code s being used.
mat_bug has quit [Ping timeout: 252 seconds]
Puffball has joined #ruby
ua has quit [Ping timeout: 246 seconds]
<phaul>
he said it. he wants to append '...' to string arrays. its just that the channel is really found itself being pedantic on preconditions for instance variable values all of a sudden
cnsvc has joined #ruby
jenrzzz has quit [Ping timeout: 250 seconds]
Aqo has quit [Quit: ChatZilla 0.9.92-rdmsoft [XULRunner 35.0.1/20150122214805]]
jenrzzz has joined #ruby
<havenwood>
&>> class Symbol; def << other; to_proc << other.to_proc end end; [1, 2, 3].map &:abs2 << :abs2
<al2o3-cr>
require 'fiddle'; include Fiddle; r = (1..10); include Fiddle; [16,24].zip([rand(100).__id__, rand(100).__id__]).each { |b, v| Pointer[dlwrap r][b] = v }; r
mat_bug has quit [Ping timeout: 252 seconds]
<al2o3-cr>
&>> require 'fiddle'; include Fiddle; r = (1..10); include Fiddle; [16,24].zip([rand(100).__id__, rand(100).__id__]).each { |b, v| Pointer[dlwrap r][b] = v }; r
<phaul>
al2o3-cr: you really are the fiddling wizzard :) now iterate it
<havenwood>
al2o3-cr: maybe also randomly frozen and tainted
<havenwood>
and exlcude_end for good measure
<Hoffman>
al2o3-cr: what does including Fiddle twice do
<al2o3-cr>
havenwood: based on your snippet :)
<havenwood>
al2o3-cr: :)
<al2o3-cr>
Hoffman: requiring the lib, then including the module.
<phaul>
you have double include
<Hoffman>
^
<Hoffman>
I wasnt sure if it was some neat quirk with redefining stuff or something
<al2o3-cr>
oh, shit so i do :(
<Hoffman>
or just a simply typo
<Hoffman>
simple*
<al2o3-cr>
my fault.
<Hoffman>
<--- noob
<al2o3-cr>
first 16 bytes are always RBasic.
<al2o3-cr>
so doing obj.object_id is where it is memory.
<al2o3-cr>
anyway i'm watching snooker now ;)
<al2o3-cr>
selby or ronnie for sure.
devil_tux has quit [Ping timeout: 268 seconds]
mat_bug has joined #ruby
<phaul>
I was rooting for Ronnie for a long time, but these days I'm less interested in snooker.. two much depends on a single bad or unfortunate shot. usually there is no coming back at top level
donofrio_ has joined #ruby
<al2o3-cr>
phaul: the talent these days are unblievable.
sgen has joined #ruby
mat_bug has quit [Ping timeout: 252 seconds]
mikecmpbll has quit [Quit: inabit. zz.]
<al2o3-cr>
havenwood: good!
<al2o3-cr>
selby is awesome!!
jenrzzz has quit [Ping timeout: 272 seconds]
mat_bug has joined #ruby
s3nd1v0g1us has quit [Quit: WeeChat 2.2]
<al2o3-cr>
&>> require'fiddle'; a = {}; Fiddle::Pointer[Fiddle.dlwrap a].to_s == Fiddle::Pointer[a.object_id<<1].to_s