IRC channel logs


back to list of logs

<zacts>lo #guile
<mark_weaver>hi zacts!
<zacts>I'm having a mocha at my favorite cafe
<zacts>next is the college and then I'll have a look into FreeBSD lang/guile2.
<george2>how do I denote comments in guile scheme, and what are the accepted commenting conventions?
<george2>eg, are inlines acceptable, or should they be avoided? etc.
<george2>I see both ;;; and ; being used in this file, is there a difference?
<dsmith-work>george2: Have you ever seen the emacs lisp conventions?
<dsmith-work>Emacs *does* have such convetiontions. I suspect Guile people have carried that over. I don't remember if Guile also has them.
<dsmith-work>george2: Check out the manual. And the README and HACKING
<dsmith-work>george2: Also
<mark_weaver>george2: different numbers of semicolons are auto-indented differently by emacs. the usual convention is that a single semicolon is used to write a comment to the right on the same line as code, two semicolons are used to write comments on their own lines within code (indented the same amount as the code), and three are sometimes used at the top-level, outside of any code.
<george2>dsmith-work, mark_weaver: ok, thanks, I'll look into those.
<george2>This is probably heresy, but I'm using vim, not emacs.
<zacts>I can help
<zacts>with vim
<zacts>I can get you all set-up with a nice vim + scheme setup
<zacts>eventually I hope to submit upstream patches to evil-mode, but until then I know of some nice hacks to get vim working for you
<zacts>george2: /msg me
<dsmith-work>george2: Heretic!
<zacts>dsmith-work: it's ok, I hope to improve evil-mode and get a lot of vim users to convert to it.
<dsmith-work>There ya go. And then they can use geiser
<zacts>I <3 modal editing, it's just that emacs has the best out-of-box support for lispy languages, and it has things like org-mode
<zacts>so I'm using both emacs and vim currently
<rlb>george2: and fwiw the commenting convetion is *old* afaik, and broader than elisp -- think I learned it via common-lisp, but not sure.
<rlb>so do dialects built on the il share the core data structures (I'd guess)?
<DeeEff>hey #guile, just wondering what the typical use of *unspecified* is and whether you should use it in a function?
<DeeEff>specifically, if I write a function ONCE that takes in a function and executes it onces, should I return #f or *unspecified* after the function returns?
<nalaginrut>morning guilers~
<DeeEff>morning. Hey nalaginrut, any input into my question above? Is it typically better to return #f or *unspecified* when a function should effectively return no specific value?
<george2>rlb: ok, good to know. This is my first foray into lisp beyond a brief stint with hy, so I don't know conventions for any lisps at this point.
<nalaginrut>DeeEff: if your function has no intended return value, just leave it alone, it'll return unspecified. But I confess I don't understand your question clearly ;-
<nalaginrut>s/it'll return/it may return
<zacts>george2: what project are you working on?
<DeeEff>The question is basically about higher order functions
<rlb>DeeEff: I think most lispish code doesn't worry about the return value if it doesn't matter, i.e. doesn't explicitly try to return nil/unspecified, etc.
<rlb>but you'd document that the return value is unspecified.
<DeeEff>ok then, I think I'll stick with unspecified. Though it does feel somewhat wrong considering other scheme implementations don't have unspecified as a specific value
<DeeEff>guile is also the only scheme I know of that has an `unspecified?' predicate
<george2>zacts: Just a final project for a programming languages course. It's pretty open-ended, we're just supposed to show some understanding of basic language concepts, and explore a new language. We've chosen to implement a simple calculator REPL with a few functions that demonstrate unique features of Scheme.
<rlb>DeeEff: fwiw, I didn't mean you'd return unspecified -- you'd just let it return whatever the final form returns.
<DeeEff>well I'm not, it's more like I'm returning whatever (if (predicate) true-cond) returns if predicate evaluates to #f
<rlb>right -- other code wouldn't normally used unspecified? either.
<DeeEff>if you don't specify a false-cond, then it just returns *unspecified*
<DeeEff>the question is whether or not that's a good idea.
<rlb>in most cases, pretend like unspecified? doesn't exist.
<nalaginrut>DeeEff: don't return unspecified explicitly, it's useless. But I think you'd better design your interface before coding, include the return value convention. There's no standard convention for this question, it depends on programmer
<zacts>george2: oh cool
<rlb>the only reason I'd consider explcitly returning nil/#f/*unspecified* is if it was performance critical, and I happened to know that the compiler would see that and do something "smarter".
<rlb>(for any function where the return value isn't relevant)
<zacts>george2: you may also like the Structure and Interpretation of Computer Programs book and MIT lectures
<george2>zacts: thanks, I'll add it to my book list. :)
<rlb>george2: you likely won't forget sicp...
<george2>I forget everything :P
<rlb>I just meant figuratively -- time of course takes its toll.
<zacts>george2: it's an amazing book, and it will open your mind to new possibilities
<zacts>it can revolutionize the way you think about programming forever
<zacts>or so I've heard, I'm still reading the beginnings of it, and love it so far
<DeeEff>or it can scare you into never attempting math ever again. I've seen both ;)
<rlb>(it might also make you a scheme snob)
<rlb>fair warning
<george2>I've really enjoyed learning Haskell, despite the moans of my classmates. I expect to feel the same about lisp as soon as I get more into it. :)
<zacts>rlb: what's wrong with that? (it is doing that to me)
<george2>Also, I'm terrible at math, so don't worry about that part. :D
<zacts>george2: check out the little schemer, the reasoned schemer, and the seasoned schemer books also.
<rlb>george2: it's also freely available:
<DeeEff>yeah, wait until you've taken at least first year calc courses before you attempt SICP.
<zacts>they look like childrens book, but they are more than that
<rlb>DeeEff: maybe -- but I suspect you can still get a lot of value from even parts of the book -- come back to the rest later.
<george2>DeeEff: heh, I'm graduating from DiffEq in a few weeks. Calc I, II and III are behind me. :)
<zacts>rlb: well george2 could start by watching the lectures to get the ideas into his subconcious
<DeeEff>george2: I wouldn't call that terrible at math then
<rlb>but yes -- I suspect it won't be a light read
<DeeEff>chapters 1, 2, and 3 take the most time to get through tbh
<DeeEff>4 and 5 fly by a little faster
<george2>DeeEff: I'm extremely good at bull****ing my way through math.
<zacts>george2: after you study sussman for a while, you will fundamentally understand math at a core level
<zacts>like this book..
<zacts>I hope to read that after I finish SICP
<zacts>sussman is no joke
<george2>so many books... I wish I had more time.
<george2>maybe this summer I'll actually be able to read
<zacts>yeah, I'm starting college also, right now I'm part time, but soon I'll be full time and busy as hell
<zacts>so I'm trying to get all of my promised projects completed before the fall
<george2>indeed. I'm full time now, plus 2 jobs, some orgs and user groups, and whatnot.
<zacts>wow, impressive =)
<zacts>can you study at work, like at a library, or is it a job where you have to constantly be moving?
<nalaginrut>hey guys! If you really want to read SICP after finish all relative math books, you'll become a mathematics or a hater first ;-D
<george2>it's rather depressing, honestly. Every time I have an idea for a new project I put it on my todo list, but I haven't been able to take anything off the list.
<zacts>george2: hehe, sounds like me kind of
<george2>zacts: one job is network administration, the other is research. Both involve software development, but neither leaves me with any free time to explore things on my own.
<zacts>george2: here is my blog in progress, I hope to post stuff on scheme eventually..
<mark_weaver>zacts: ooh, I didn't know about that new sussman book, thanks for the pointer!
<george2>hehe, a blog on heroku? what type of app is that?
<zacts>mark_weaver: np!
<zacts>george2: well, I'm looking for a different hosting service, but it's a homemade perl mojolicious app + markdown I made from scratch
<george2>aw, I was hoping it would be scheme :(
<zacts>george2: I'm going to probably switch to using chicken scheme eventually
<zacts>I'll post it to my gitorious if I do that.
<george2>I highly recommend host1plus/host1free btw. those guys are awesome.
<zacts>oh thanks
<george2>their VPSs are unbelievably cheap
<george2>less than half the cost of digitalocean
<zacts>wow, $2 a month for the plus account
<zacts>thanks for the link!
<zacts>mark_weaver: yeah, and they use scheme to teach the concepts in that book
<george2>np. They're sponsoring a project I work on, giving us almost half off a ~200euro/month server cost.
<george2>dunno why, I guess they're just that awesome.
<nalaginrut>oh, which book is sussman's new book?
<zacts>george2: well if you only read one book on scheme, read SICP.
<george2>will do. It's on my list :)
<DeeEff>If you want a cheap vps on kvm, I suggest
<DeeEff>I think their cheapest is around $2
<DeeEff>mind you, I don't use them much, but still.
<george2>looks pretty good. about equal prices with digitalocean I think.
<zacts>or if you want a physical copy -
<nalaginrut>zacts: thanks~oh it's math book this time ;-)
<zacts>nalaginrut: but it uses scheme to teach it
<george2>that's an interesting way to teach math
<zacts>like it teaches you the concepts at a fundamental intellectual level, and then it teaches the mathematical notation after you learn the concepts
<zacts>and you get to tinker and play with the math
<zacts>which is good if you are looking for a topic to talk about on a date, I guess. :D
<george2>only at an engineering school :p
*zacts imagines he is the university nerd who tutors people, and gets dates.
<DeeEff>dates at engineering schools are between men.
<DeeEff>not that there's anything wrong with that, but remember your audience
<george2>The part that really sucks is when you get here expecting everyone to be like these little 12-year-old comp sci geniuses you find in IRC, then most of the comp sci majors are just a bunch of "uhh.. videogames?"
<nalaginrut>Now that I'm married, it's safer to learn Scheme and maths without dating with men...
<DeeEff>nalaginrut: just avoid engineering schools
<DeeEff>( ⊙‿⊙)
<DeeEff>george2: there is no such thing as 12-year-old comp sci geniuses
<DeeEff>most people who graduate from comp-sci in the states can't even program fizzbuzz last I read
<george2>but some of the people I've met come close
<george2>Indeed, it seems the education system here is terrible.
<george2>luckily I was homeschooled, so I never had to deal with that.
<george2>With the amount of graduating seniors in my classes that still know so little, I wouldn't doubt that, either.
<nalaginrut>In China, most of the students study CS because it easier to find a job, but most of them are really hate programming. Well, maybe the teachers are suck too..
<nalaginrut>If you are forced to learn C in your first touch programming, and you have to control pointers well or you can't pass the exam, anyone could be the hater of programming...
<george2>That's sad. :( We need more real Tao programmers, not just a bunch of mindless C# and Java drones.
<george2>I learned C as one of my first languages
<george2>but I did it on my own time, from TCPL, not in some awful class
<nalaginrut>george2: well, so you don't have the pressure of exam ;-)
<DeeEff>Eh, I learned C++98 in my first programming class
<DeeEff>still turned out fine overall. Some people just have a different drive
<george2>All of the mechanical engineers here are forced to go through C++. I haven't talked to one who liked it, and from the material I've seen, I don't blame them.
<DeeEff>C++11 and later is fine
<DeeEff>anything earlier is a pretty shitty walk
<george2>Well it's not like they're taught the language. They're taught iostream and fstream, and how to make basic functions and if trees.
<george2>They don't even touch on lambdas, and most of them still can't tell you the difference between an object and a class by the time they get out.
<nalaginrut>99% CS guys here never heard of lambda
<nalaginrut>maybe 98%, whatever
<nalaginrut>here -> Shenzhen, maybe whole China
<adu>I just talked to someone who was an avid Haskell user, but had never heard of product types
<adu>and I was like, ok, what does "(Integer, Integer)" mean in Haskell? and he was like uhm, its a tuple, and I was like "it's a product type"
<nalaginrut>I think if there's no lambda in their mind, they should call themselves CE, E stands for engineering, there's no science anymore
<nalaginrut>alas, even engineering needs science...
<george2>well I don't know what a product type is, but I've only been using haskell for a few weeks. :)
<george2>I talked to a CE professor the other day who said none of his students know even basic programming, nor do they have any interest in it.
<adu>george2: it's ok, most people call them structs anyways
<george2>adu: structs, like C structs, or something different?
<adu>or guile record types?
<george2>well I know even less about guile than haskell :)
<george2>that's why I'm here
<george2>I'm afraid this is as far as I've gotten so far. :)
<nalaginrut>george2: you don't have to use read-line, read is enough
<george2>ha... even with 20 lines I'm doing things wrong :D
<adu>george2: try this... (let loop (loop (write (eval (read) *env*))))
<george2>bad let in form
<nalaginrut>well, you didn't eval it, so there'
<nalaginrut>there's no eval ;=)
<rlb>george2: read produces the "next form" form the input stream, hence the idiom "read/eval".
<george2>instructions unclear, pasted into guile :p
<rlb>read converts the text to a data-structure, and eval "does whatever it says".
<george2>this replaces the entire program, or what?
<rlb>and of course scheme defines what behaviors are produced by which data structures (speaking loosely)
<rlb>george2: if you're asking me, I suspect I don't know enough about what you're trying to do to answer.
<george2>I'm just unsure what to do with the (let loop (loop (write (eval (read) *env*))))
<rlb>(and I'm rusty wrt guile/scheme -- been off in the clojure/python/C/... world for a while)
<rlb>george2: well that's more or less a repl -- i.e. it reads a form, evaluates it, then prints the result.
<george2>Python is where I spend most of my time these days :)
<rlb>george2: python has some functional bits, but it's a bit hacked up -- i.e. comprehensions, itertools, etc.
<rlb>george2: repl == more or less what you see when you run guile from the comamnd line.
<george2>but how? Obviously pasting it into guile is wrong. And what is a form, anyway?
<rlb>You type something, and (read) pulls that from stdin and produces a data structure that's passed to (eval result) which "does it", and produces the result, which (write ...) prints to stdout.
<george2>rlb: yes, I usually use Python's OOP more than its functional bits, but those list comps come in very handy sometimes.
<rlb>george2: imagine (read) kinda like json.load()
<rlb>(in pythong)
<rlb>i.e. json.load(file) returns the next data-structure represented by the text in file.
<george2>same as ast.literal_eval
<rlb>and (read) returns the next sexp-based data-structure represented in (current-input-port)
<george2>so I'm passing my read into another function, because this is the way I found to check for #<eof>
<george2>is this wrong?
<rlb>"form" is normally used to refer to a complete sexp, i.e. "42", or "foo", or "(+ 5 2)".
<george2>currently, if I (eval input *env*), where input is the value from (read) passed to eval-input, I get an exception
<george2> Unbound variable: *env*
<rlb>dunno about *env*, but try this:
<rlb> echo 42 | guile -c "(write (eval (read) (current-module)))"
<george2>and how does exception handling work in Scheme? Haskell's is a little strange, with their monands and Left/Rights
<george2>returns 42
<george2>what is the second argument to eval?
<DeeEff>the environment
<DeeEff>holds environment variables
<rlb>and if you have r5rs-doc installed on a debian system, you can run "info r5rs" and "C-s" search for "procedure: read" to see the read docs.
<rlb>george2: it's the "(lexical) scope" for the evaluation.
<rlb>in python it'd be the chain of "dicts" from wherever you are back up to the global variables.
<george2>well I have a Kali install handy, that's close enough to Debian. :)
<rlb>george2: guile's exception handling (as I recall) is fairly "normal", i.e. you throw an object, and catch it elsewhere -- somewhat like python, though things are often more complicated in scheme since you can (unlike proabably most of the other languages you know) travel back *down* the stack, but don't worry about that for now.
<george2>I saw some argument to a read function of some sort that passed something like current-input-port. Is this the same idea?
<rlb>george2: no
<rlb>george2: the "port" is just which file you want to read from, just like the "fp" argument to json.load().
<rlb>when you're in python inside a function and you say "foo = 10", which foo do you mean?
<rlb>that's what the env is for
<george2>ok, that makes sense. So scheme lets you define the scope in which variables are searched for?
<rlb>actually bad example, given the way python behaves.
<rlb>pretend I said bar(foo, baz)
<rlb>(since assignment in python == declaration -- i.e. creates local bindings)
<rlb>george2: in guile at least, each module is a top-level "scope", and it's even possible to get hold of the local scope, i.e. an environment where looking up "foo" will find any local-variable (say inside a function or a let) declared to be foo).
<george2>argh, info keeps giving me trouble for pressing the wrong buttons. I'm used to man.
<george2>so can you pass in any function as a parameter to eval?
<rlb>george2: but top-level unless you're actually trying to play with eval, you generally want to avoid it.
<george2>or is it only certain objects?
<rlb>george2: eval doesn't accept "functions" it accepts data structures that represent code.
<rlb>i.e. (+ x y) is a list whose first item is the symbol +, whose second item is the symbol x, an whose third item is the symbol y.
<george2>well, I meant as the scope argument
<rlb>eval takes that and interprets it according to very specific rules that define the scheme language.
<nalaginrut>learn Scheme in Python way ;=D
<rlb>george2: here's the official doc, though I realize it may not be clear until you get further along.
<george2>keep in mind that I come from a purely procedural and OO background, and was only recently introduced to the wonderful world of functional languages. Even then, I've only been developing at all for 4 years or so.
<rlb>george2: if it helps, the use of the term "environment" (from a quick scan) here, appears to be roughly similar:
<rlb>george2: fair enough, but the environment (generally speaking) is somewhat orthogonal to "functional".
<george2>ok. I'll stop mixing the two terms then. :)
<rlb>or rather is very common, even in non-functional contexts
<rlb>though scheme has one of the more powerful specifications on that front.
<rlb>i.e. full closures, etc.
<rlb>(python has added something (iirc) weaker)
<george2>I recently realized that while I understand scoping models in several languages, I never learned the names for any of them, so I couldn't tell you the difference between lexical, static, or dynamic. Two of which, I believe, are different words for the same thing.
<rlb>or maybe it's just the lambda syntax that's weaker -- I forget offhand.
<rlb>shorthand: lexical is what you want most of the time -- though dynamic can be useful
<george2>I have the wikipedia page for full closures open, but haven't read it yet
<rlb>for me at least it helped to have a mental model of how things are implemented (or at least a related abstraction)
<rlb>then understanding the various scope beahviors, environments, closures, etc. was just understanding how the parts are wired together.
<george2>ack, I need to sleep or I'll never be awake for my 8am. Thank you all for putting up with my pestering, I have plenty of reading material now. :)
<george2>I'm sure I'll have more questions later
<rlb>Is it possible to make the reader (i.e. (read)) safe in guile (or is it already safe if you don't extend it)?
<nalaginrut>well, how safe is safe? ;-P
<rlb>...can't execute arbitrary code i.e. for side-effects
<rlb>though in my case I was just wondering about using it as a stopgap to read arbitrarily large integers without pulling the string into ram first -- but I suppose there's no guarantee that read doesn't do that anyway.
<rlb>and now that I think of it, probably can't rely on it for other reasons...
<taylanub>george2: lexical AKA static means that its directly apparent from the text (hence "lexical") what variable is bound where, hence the binding locations of variables can also be analyzed *statically* (without running the program). with dynamic scoping, code from any part of the program can (in principle) "dynamically" (at run-time) change the values of variables, without this being obvious from the textual/static sour
<taylanub><rlb> so do dialects built on the il share the core data structures (I'd guess)?
<taylanub>You mean different languages on the Guile VM ? If so, then yes, optimally they use as many same data types of libguile as possible.
<wingo>meep meep
<plotr>could someone point me to basic example which uses ?
<plotr>also, did I got it right that the right way to run guile app is by guile-gnome-2 lol.scm ?
<civodul>Hello Guilers!
<civodul>current master fails to build for me: it's stuck compiling eval.go
<lloda>it happens in the best families ;p
<wingo>civodul: your bdw-gc version?
<civodul>wingo: 7.4.0
<wingo>civodul: then you have been bitten by the 7.4.0 bug :)
<wingo>either pull from git bdw-gc
<wingo>or set GC_MARKERS=1 in your environment
<civodul>ah ok, that rings a bell
<civodul>what's wrong with the marker thread?
<davexunit>man it seems like every other release of bdw-gc breaks guile
<wingo>davexunit: why do you say that?
<civodul>yeah, so far that's been OK
<wingo>that's the problem ^
<davexunit>wingo: I remember when I first started using guile I had a bad version of libgc installed and I had to compile a particular version in order for things to work nicely.
<wingo>davexunit: that could be because you had a prerelease (too new and unstable) or a too-old version
<wingo>anyway i think we are settling down; master will probably require 7.2, which will be common by the time 2.2.0 is out
<wingo>which btw i am ready to cut 2.1.1 or whatever
<wingo>just have to update docs again
<wingo>but i have no blocker bugs
<wingo>functionality-wise anyway
<davexunit>oh boy
<davexunit>that is very exciting.
<davexunit>damn it feels good to be a guiler.
<taylanub>What was the status of expanding stacks on Guile ? Not that we also end up suffering from the "hot split" problem:
<davexunit>2.2 is coming 'round the mountain, guile-emacs is in GSoC, guix is coming along. a lot of things to look forward to.
<wingo>lots of merges from stable-2.0 unfortunately :/
<civodul>why is it unfortunate?
<wingo>because it's 4 months worth, or something like that
<civodul>wingo: could we add a configure check or something to have a built-in workaround for GC_MARKERS=1?
<civodul>aah, i see :-)
<wingo>civodul: perhaps, yes -- perhaps we could check for 7.4.0
<civodul>is there GC_set_markers or so?
<wingo>civodul: probably, and if not we can setenv("GC_MARKERS") :P
<wingo>i just mailed the bdw-gc list to ask for a release
<civodul>seems like it'll have to be setenv
<mark_weaver>there are still some blockers in 2.2
<mark_weaver>first of all, it only works on systems with 4K pages
<mark_weaver>and there's the unresolved issue about promising thread synchronization in I/O primitives
<mark_weaver>and the pseudo-hygiene for macro-introduced top level variables.
<mark_weaver>and thread-unsafe module loading
<mark_weaver>(the fix for which will probably be disruptive enough that we best do it between major releases)
<mark_weaver>that said, I'm _really_ excited about 2.2.
<civodul>we should start discussing on the list the points that we think need to be addressed before a 2.1 and a 2.2 release
<civodul>(not necessarily the same)
<mark_weaver>it's also worth mentioning that is almost all red for master
<mark_weaver>here's the last evaluation that was mostly complete:
<civodul>shouldn't unquote be a syntax parameter?
<wingo>civodul: good question!
<wingo>or not necessarily a parameter, but perhaps it should be bound
<mark_weaver>civodul: at least for quasiquote, 'unquote' is not a macro, because the contents of the quasiquote is not "evaluated".
<wingo>probably not a parameter actually, as it's usually used in contexts that aren't themselves macro-expanded
<mark_weaver>instead the quasiquote macro looks for occurrences of quasiquote in the quoted datum. so making it a syntax parameter wouldn't make any difference there.
<mark_weaver>and it seems to me that in most cases where unquote is used (but perhaps not all), the situation is similar.
<civodul>i guess i was just thinking out loud
<mark_weaver>unquote is more akin to something like => or 'else' in practice.
<mark_weaver>and certainly, the handling of those literals has never felt quite right to me, but it's not yet clear to me how to improve the situation.
<civodul>i'm looking to build a quotation mechanism to make build expressions in Guix, hence the question
***linas_ is now known as linas
<civodul>wingo: i pushed an ugly workaround for GC_MARKERS
<rlb>wingo: interesting post (re stacks)
<ijp>useless tidbit of the day: befunge has a stack-stack
<wingo>civodul: cool
<mark_weaver>I can work on merging stable-2.0 into master. most of the commits are mine anyway
<wingo>mark_weaver: that would be swell. i guess you'd have to fix the page-size thing tho
<mark_weaver>yeah, I'll take care of that too
<civodul>mark_weaver: i can help with (system base types)
<civodul>it should just need a trivial adjustment to the new type tags
<civodul>IIRC there's only one tag that differs
<wingo>would be nice to write a little script that generates that info from c somehow
<wingo>or at macro-expansion time, or something..
<mark_weaver>civodul: ah yes, help with that commit would be most welcome!
<civodul>wingo: i'd rather do the opposite
<civodul>but currently, you get a segfault or a test failure is there's a mismatch anyway :-)
<rlb>guile-2.0 2.0.11+1-1 has been uploaded to Debian unstable.
*rlb is *very* happy to have (a) guile upstream via git, and (b) no more dfsg split.
<rlb>(...and for anyone who might need it:
<rlb>Though I use git-dpm, so you'll need that if you want to follow along -- may be easier for many to just send me patches.
<davexunit>rlb: no more dfsg split? what happened?
<rlb>guile's docs changed
<rlb>(many thanks to whomever(s))
<mark_weaver>did guile's doc have an invariant section at some point?
<rlb>mark_weaver: iirc, yes.
<rlb>(I still have to handle that on the emacs front of course.)
<mark_weaver>ah, I didn't realize that you were the maintainer of the debian emacs packages.
<saul>Does Lisp have a predicate corresponding to Scheme's 'defined?' ?
<rlb>mark_weaver: indeed, and still running behind...
<rlb>mark_weaver: about to work on that, though.
<mark_weaver>saul: scheme doesn't have 'defined?'. it's guile-specific.
<davexunit>oh we had an invariant section that was removed. I see.
<civodul>sometime after 2.0.5 IIRC
<rlb>(may also attempt (again) to see if we can use triggers for emacsen-common)
*mark_weaver just noticed that the version of the debian 'emacs' metapackage is 45 (!)
<rlb>mark_weaver: it goes up to 11
<mark_weaver>heh :)
<saul>mark_weaver, interesting. (I don't recall ever using a Scheme that didn't have a 'defined?' procedure.)
<saul>(Though it appears SIOD didn't have one.)
<Fulax>(mzscheme (racket) and bigloo, at least, does not have a defined? procedure)
<dsmith-work>rlb: How long do you think it will take your upload to percolate into an armhf package?
<dsmith-work>uname -a
<dsmith-work>Linux beaglebone 3.8.13-bone47 #1 SMP Fri Apr 11 01:36:09 UTC 2014 armv7l GNU/Linux
<dsmith-work>2.0.11 make check pasess. Whoo
<dsmith-work>libgc 7.2e
<rlb>dsmith-work: you can keep an eye here:
<rlb>so far no failures
<dsmith-work>rlb: Thanks