2015-12-22T00:11:02Z Riastradh joined #scheme 2015-12-22T00:12:49Z Beluki quit (Read error: Connection reset by peer) 2015-12-22T00:16:15Z Fare quit (Ping timeout: 240 seconds) 2015-12-22T00:20:24Z lritter quit (Quit: Leaving) 2015-12-22T00:30:45Z emma joined #scheme 2015-12-22T00:39:44Z mmc quit (Ping timeout: 255 seconds) 2015-12-22T00:49:18Z n_blownapart joined #scheme 2015-12-22T00:54:56Z jcowan joined #scheme 2015-12-22T00:55:01Z n_blownapart quit 2015-12-22T00:56:34Z amca joined #scheme 2015-12-22T00:57:41Z jcowan quit (Client Quit) 2015-12-22T00:58:01Z jcowan joined #scheme 2015-12-22T01:12:28Z neoncontrails quit (Remote host closed the connection) 2015-12-22T01:16:21Z Necrosporus joined #scheme 2015-12-22T01:21:37Z Necrosporus: (define ((p)) +) (((p)) 2 5) 2015-12-22T01:21:42Z Necrosporus: What does this code do? 2015-12-22T01:21:53Z dpk: nothing, it's invalid 2015-12-22T01:22:04Z dpk: i think? 2015-12-22T01:22:12Z Necrosporus: dpk, it works 2015-12-22T01:22:17Z Necrosporus: in Guile at least 2015-12-22T01:22:33Z dpk: afaik you can only have a symbol as the first item of the list which is the first argument to define 2015-12-22T01:23:11Z jcowan: In the standard, yes. Some systems may extend that. 2015-12-22T01:23:12Z adu joined #scheme 2015-12-22T01:23:49Z Necrosporus: dpk, I have found out that a variable behaves differently than nullary function 2015-12-22T01:24:30Z Necrosporus: for example (define y 5) (define (x) y) (define y 0) (x) returns 0 2015-12-22T01:24:32Z pjb: Necrosporus: you can resolve it by mere substitution. 2015-12-22T01:25:04Z Necrosporus: While (define y 5) (define x y) (define y 0) x returns 5 2015-12-22T01:25:04Z pjb: (define ((p)) +) means ((p)) == + therefore (((p)) 2 5) == (+ 2 5) 2015-12-22T01:25:48Z jcowan: Guile 2.0.9 cannot in fact handle that 2015-12-22T01:25:49Z dpk: hmm, when i try it in Guile i get "source expression failed to match any pattern in form (define ((p)) +)" 2015-12-22T01:25:52Z jcowan: Yes. 2015-12-22T01:25:54Z pjb: Necrosporus: define implements a simplistic currying, where you can write parentheses around the function name and parameters to replace a lambda form: (define (f a) b) == (define f (lambda (a) b)) 2015-12-22T01:25:55Z dpk: (2.0.11) 2015-12-22T01:25:58Z Necrosporus: but seems that foo is different thing from (foo) and ((foo)) 2015-12-22T01:26:18Z pjb: Necrosporus: so (define ((p)) +) == (define (p) (lambda () +)) == (define p (lambda () (lambda () +))) 2015-12-22T01:26:27Z pjb: p is a function returning a function that returns +. 2015-12-22T01:26:40Z pjb: (p) returns a function that returns + 2015-12-22T01:26:42Z jcowan: pjb: In what Scheme does that work 2015-12-22T01:26:46Z pjb: All. 2015-12-22T01:27:04Z pjb: Well, I mean, all r5rs at least. I don't know since then they had it. 2015-12-22T01:27:12Z pjb: ((p)) returns + 2015-12-22T01:27:31Z dpk: R5RS? 2015-12-22T01:27:39Z dpk raises eyebrow and goes to read the spec 2015-12-22T01:28:16Z evhan: Not R5RS, but a very common feature. 2015-12-22T01:28:42Z dpk: http://www.schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-8.html#%_sec_5.2 indeed, not in R5RS 2015-12-22T01:28:42Z rudybot: http://teensy.info/R6Ll0tKq4D 2015-12-22T01:28:51Z Necrosporus: dpk, so, if you just (define x 5) it is not same as you defining a function that returns 5? 2015-12-22T01:28:56Z pjb: Yes, R5RS, it comes directly from 5.2 Definitions. 2015-12-22T01:29:11Z dpk: rudybot: thank you for posting the exact link i just posted, but in a more fragile version 2015-12-22T01:29:13Z rudybot: dpk: I don't want to destory your fragile ego, proped up only by your purchse of an aluminum computer. 2015-12-22T01:29:41Z dpk: don't worry, my ego's story is perfectly intact 2015-12-22T01:29:49Z pjb: Necrosporus: no, there's no parentheses around x. 2015-12-22T01:31:27Z dpk: oh wait. it *is* R5RS 2015-12-22T01:31:36Z evhan: pjb: I suppose it does indeed, unless is defined incompatibly somewhere. 2015-12-22T01:31:36Z dpk: because of the way it's defined to expand 2015-12-22T01:31:52Z dpk: (define ( ) ) == (define (lambda () )) 2015-12-22T01:32:44Z dpk: so (define ((f) x) x) becomes (define (f) (lambda (x) x)) becomes (define f (lambda () (lambda (x) x))) 2015-12-22T01:32:46Z dpk: or similar 2015-12-22T01:32:54Z pjb: Well, ok, It uses and it's defined in chapter 7 as being an identifier. 2015-12-22T01:33:14Z pjb: So it's not strictly in r5rs, but it's an extension. 2015-12-22T01:33:40Z pierpa: it comes for free with the obvious expander for define 2015-12-22T01:34:34Z pjb: Yes. 2015-12-22T01:34:35Z stepnem quit (Ping timeout: 240 seconds) 2015-12-22T01:35:11Z Necrosporus: Are there dialects of lisp which get rid of at least outer part of parens? 2015-12-22T01:35:30Z dpk: ah right 2015-12-22T01:36:06Z dpk: Necrosporus: Scheme has several implementations of "oh god, please make there be less parentheses" 2015-12-22T01:36:51Z dpk: SRFIs 49, 110, 119, and arguably 105 are all variations on this theme 2015-12-22T01:37:39Z Necrosporus: I do not know what are those numbers... Right now I'm reading first part of SICP 2015-12-22T01:38:05Z jcowan: Of the 49 Schemes in my test suite, it works in the following Schemes: Racket, Gauche, MIT, KSi, SIOD, Rep, UMB, Elk, Sagittarius, Picrin. 2015-12-22T01:38:20Z mmos quit (Ping timeout: 250 seconds) 2015-12-22T01:38:38Z jcowan: So it's not very portable at all. None of R[2-7]RS actually allow it except as an extension. 2015-12-22T01:38:46Z dpk: Necrosporus: SRFIs are like PEPs in Python or what-have-you. fairly informal specification procedure for proposed extensions to Scheme 2015-12-22T01:39:01Z dpk: you can see 'em all here http://srfi.schemers.org/final-srfis.html 2015-12-22T01:39:10Z dpk: but you don't especially need to worry about that for doing SICP 2015-12-22T01:40:27Z jcowan nods 2015-12-22T01:41:17Z jcowan: Some SRFIs got merged into R6RS and R7RS-small, and R7RS-large will be mostly made of SRFIs. 2015-12-22T01:42:12Z dpk: wow, there's a lot of draft SRFIs right now 2015-12-22T01:42:50Z sethalves quit (Remote host closed the connection) 2015-12-22T01:44:35Z pjb: Necrosporus: for lispers, it's not interesting to get rid of parentheses. However, it is trivial to write a repl that allows you to remove outer parentheses. Basically: #|CL:|# (loop (print (eval (read-from-string (concatenate 'string "(" (read-line) ")"))))) 2015-12-22T01:45:34Z pjb: (I would also advise against using brackets in scheme.) 2015-12-22T01:48:27Z psy_ joined #scheme 2015-12-22T01:49:10Z psy_ quit (Max SendQ exceeded) 2015-12-22T01:49:15Z Necrosporus: but why does scheme use different scoping for variables and functions? 2015-12-22T01:49:25Z jcowan: It doesn't. 2015-12-22T01:49:28Z psy_ joined #scheme 2015-12-22T01:49:36Z jcowan: There are only variables, some of which are bound to functions. 2015-12-22T01:49:44Z Necrosporus: It seems that (define foo bar) is completely different operation from (define (foo) bar) 2015-12-22T01:49:47Z jcowan: There is different scoping for let and define, if that's what you mean. 2015-12-22T01:50:12Z jcowan: It's different, because the first defines foo to be the value of bar, whereas the second defines foo to be a function that returns the value of bar. 2015-12-22T01:50:50Z dpk: jcowan: http://srfi.schemers.org/srfi-134/srfi-134.html is interesting; what are you using to implement it? a finger tree? 2015-12-22T01:51:15Z Necrosporus: but if you change bar later, then first foo will be same, while second (foo) will return different result 2015-12-22T01:51:24Z jcowan: I'll be using a two-stack implementation to start with, that may be replaced by a finger-tree implementation by Kevin Wortman in the future. 2015-12-22T01:51:35Z jcowan: Necrosporus: Yes. 2015-12-22T01:51:49Z jcowan: That is not a distinction of scope, though. 2015-12-22T01:52:05Z jcowan: dpk: The two-stack implementation is easier to put together quickly. 2015-12-22T01:52:13Z jcowan: (er, two-list in the Scheme context) 2015-12-22T01:52:40Z Necrosporus: jcowan, (define foo bar) substitutes bar while (define (foo) bar) does not substitute bar 2015-12-22T01:52:43Z Necrosporus: Why? 2015-12-22T01:54:22Z dpk: Necrosporus: in (define foo bar) you are taking a thing called bar and giving it the (additional) name of foo 2015-12-22T01:54:45Z dpk: in (define (foo) bar) you are making a new thing called foo, and that thing is a function which returns the thing called bar 2015-12-22T01:57:19Z Necrosporus: But lexical scope is possible 2015-12-22T01:57:29Z Necrosporus: it's implemented in OCaml for example 2015-12-22T01:57:39Z dpk: yes, and Scheme has lexical scope 2015-12-22T01:58:34Z bb010g quit (Quit: Connection closed for inactivity) 2015-12-22T01:58:54Z Necrosporus: I mean... why would not (define (foo) bar) work same way as first one and return whatever bar was referencing in the time of defining? 2015-12-22T01:59:37Z Necrosporus: Not leave bar unexpanded until later calls of foo 2015-12-22T02:00:05Z Necrosporus: Or opposite, (define foo bar) could have been used to make foo alias of bar 2015-12-22T02:00:16Z Necrosporus: so foo and bar will always mean same thing 2015-12-22T02:00:18Z pjb: For that, you would do (define foo (let ((bar bar)) (lambda () bar))) 2015-12-22T02:00:30Z pierpa: in this regard, Scheme is exactly identical to OCaml 2015-12-22T02:00:48Z pjb: (define bar 42) (define foo (let ((bar bar)) (lambda () bar))) (set! bar 33) (list (bar) bar) --> (42 33) 2015-12-22T02:00:59Z pjb: (define bar 42) (define foo (lambda () bar)) (set! bar 33) (list (bar) bar) --> (33 33) 2015-12-22T02:01:13Z pierpa: (define x y) === let x = y 2015-12-22T02:01:28Z pierpa: (define (x) y) === let x () = y 2015-12-22T02:01:37Z pjb: Notice that in the first case, to get (42 33), I had to create a new lexical scope with a new variable (which I named bar too by the way). 2015-12-22T02:02:06Z pjb: (define foo (let ((old-bar bar)) (lambda () old-bar))) 2015-12-22T02:04:25Z neoncontrails joined #scheme 2015-12-22T02:05:09Z dpk: jcowan: i'm looking at http://srfi.schemers.org/srfi-121/srfi-121.html again and it strikes me that the naming conventions used are the opposite of elsewhere in Scheme. is that deliberate? 2015-12-22T02:05:41Z dpk: e.g. (make-[whatever] …) is usually reserved for procedures that make an empty/uninitialized instance of the type [whatever] 2015-12-22T02:05:41Z bogdanm quit (Ping timeout: 255 seconds) 2015-12-22T02:06:06Z dpk: and ([whatever] . args) does what make-generator does here 2015-12-22T02:06:08Z magine joined #scheme 2015-12-22T02:06:29Z bogdanm joined #scheme 2015-12-22T02:06:47Z dpk: along the same lines, make-iota-generator would be generator-iota, make-range-generator would be generator-range 2015-12-22T02:07:11Z dpk: make-coroutine-generator and friends may be correctly named, though. unsure 2015-12-22T02:07:19Z Necrosporus: pierpa, not the same, if you use let x () = y and redefine y later, x still would return value y had in the time when x () was defined 2015-12-22T02:08:24Z cemerick joined #scheme 2015-12-22T02:09:29Z Necrosporus: So, OCaml has consistent static scoping; While scheme has static scope for variable definition and dynamic for function definitions 2015-12-22T02:09:31Z dpk: i notice that generator-fold, generator-for-each and so on obey the normal naming convention 2015-12-22T02:09:56Z dpk: (by which i mean the naming convention which i consider to be the normal one, heh) 2015-12-22T02:09:58Z jcowan: Necrosporus: No, you're misinterpreting what you see. 2015-12-22T02:10:05Z jcowan: dpk: Good moment to bring this up. 2015-12-22T02:10:13Z emacsomancer joined #scheme 2015-12-22T02:10:30Z Necrosporus: jcowan, possibly 2015-12-22T02:10:37Z jcowan: dpk: However, there is no notion of mutating a generator. 2015-12-22T02:10:57Z dpk: does that effect a different convention? 2015-12-22T02:11:10Z jcowan: But you have a point that generator might be better than make-generator. 2015-12-22T02:11:20Z jcowan: dpk: Sometimes 2015-12-22T02:11:38Z Necrosporus: I do not understand code of pjb, as he used (set!) which I did not learn about yet 2015-12-22T02:12:21Z jcowan: set! actually changes the value of a variable. 2015-12-22T02:12:51Z jcowan: At the top level, you can also use define to change the value of an existing variable, which allows redefinitions. 2015-12-22T02:13:00Z jcowan: set! is not used much.. 2015-12-22T02:13:46Z Necrosporus: Is there a way to get body of defined function? 2015-12-22T02:13:57Z jcowan: Necrosporus: Not portably and not usually 2015-12-22T02:14:17Z Necrosporus: in guile? 2015-12-22T02:14:42Z jcowan: There's nothing you can do with such a body anyway. 2015-12-22T02:15:28Z Necrosporus: jcowan, well, (define b 5) (define a b) sets value of a to 5, while (define (c) a) makes a function c which returns value of a whatever the value is in the moment 2015-12-22T02:15:50Z jcowan: It defines c, a variable, to be the value of that function, yes. 2015-12-22T02:16:24Z jcowan: So if a has been mutated, it will return that value. But if a has been bound to a new location, it will return the previous value. 2015-12-22T02:16:39Z jcowan: Necrosporus: What other PLs do you know? 2015-12-22T02:17:00Z Necrosporus: Tcl, OCaml, C, bash, some of python and Lua and 2015-12-22T02:17:05Z Necrosporus: a lot of them 2015-12-22T02:17:49Z aap_ joined #scheme 2015-12-22T02:19:13Z neoncontrails quit (Remote host closed the connection) 2015-12-22T02:20:33Z Necrosporus: jcowan, what am I misinterpreting? 2015-12-22T02:20:43Z dpk: hmph, http://srfi.schemers.org/srfi-122/srfi-122.html also violates the convention, in the other direction 2015-12-22T02:21:15Z dpk: i would expect a function like 'array' to be called 'make-array' 2015-12-22T02:21:24Z aap quit (Ping timeout: 272 seconds) 2015-12-22T02:21:28Z jcowan: Well, I hold no brief for SRFI 122 2015-12-22T02:21:43Z Necrosporus: It's the fact that function definition makes a function which retains variables in its body, while variable definitions make variables which have a fixed value 2015-12-22T02:21:44Z dpk nods 2015-12-22T02:22:44Z jcowan: Necrosporus: So in C, consider the difference between "int foo = bar" and "int foo() { return bar; }" 2015-12-22T02:22:49Z jcowan: It's exactly the same. 2015-12-22T02:24:02Z Necrosporus: jcowan, wouldn't it be illegal to use external variable within function unless it's global? 2015-12-22T02:24:28Z jcowan: No. 2015-12-22T02:25:00Z jcowan: However, I am assuming that both of these are defined at top level. Change it to "static int foo = bar" if it makes you see it more easily. 2015-12-22T02:25:12Z jcowan: And of course "bar" has to be defined at top level too. 2015-12-22T02:27:03Z Menche quit (Quit: Leaving) 2015-12-22T02:28:35Z aeth quit (Ping timeout: 246 seconds) 2015-12-22T02:29:31Z aeth joined #scheme 2015-12-22T02:30:05Z Necrosporus: error: ‘bar’ undeclared (first use in this function) 2015-12-22T02:30:16Z Necrosporus: So it's only legal if bar is a global variable 2015-12-22T02:30:33Z Necrosporus: I have tried defining bar within main() and it gives error 2015-12-22T02:31:32Z cemerick quit (Ping timeout: 272 seconds) 2015-12-22T02:32:18Z Necrosporus: jcowan, http://pastebin.com/GPTjwVTw 2015-12-22T02:34:07Z pilne quit (Quit: Quitting) 2015-12-22T02:34:15Z jcowan: Sure: something defined at top level can only depend on names also defined at top level. 2015-12-22T02:38:05Z pierpa quit (Ping timeout: 255 seconds) 2015-12-22T02:41:08Z Necrosporus: jcowan, so C has same inconsistent scoping as Scheme? 2015-12-22T02:41:26Z jcowan: It's not about scope and it's not inconsistent. 2015-12-22T02:42:27Z Necrosporus: binding? 2015-12-22T02:42:33Z jcowan: Scope is the part of your program in which a name is visible. Names declared at the top level have global scope (up to a point imposed by top-to-bottom execution). Locally bound names have scope only over part of the program. 2015-12-22T02:42:47Z jcowan: So far we are dealing only with locally scoped names. 2015-12-22T02:43:21Z Necrosporus: OK, maybe I should use term binding 2015-12-22T02:44:14Z Necrosporus: Though C vision of variables is different from functional languages 2015-12-22T02:45:04Z Necrosporus: C variable is a container for value, OCaml variable is a name for a value 2015-12-22T02:45:56Z Necrosporus: In C, foo = bar; copies value from bar to foo (like asm mov instruction) 2015-12-22T02:46:36Z Necrosporus: in OCaml let foo = bar; makes foo a name for thing which is now in bar 2015-12-22T02:47:36Z Necrosporus: in Scheme (define (foo) bar) makes a function which retrieves value from variable bar 2015-12-22T02:48:17Z Necrosporus: in OCaml let foo () = bar;; makes a function which returns whatever bar had in the time when function was defined 2015-12-22T02:49:48Z Necrosporus: In Scheme (let foo bar) copies value from bar to foo, like in OCaml and C 2015-12-22T02:50:13Z Necrosporus: almost 2015-12-22T02:50:14Z dpk: no, no copying is involved in a let expression 2015-12-22T02:50:21Z Necrosporus: * define 2015-12-22T02:50:26Z Necrosporus: (define foo bar) 2015-12-22T02:50:32Z dpk: or in a define expression 2015-12-22T02:50:58Z dpk: (define a '(1 2 3)) 2015-12-22T02:51:03Z dpk: (define b a) 2015-12-22T02:51:12Z dpk: (set-car! a 2) 2015-12-22T02:51:28Z dpk: a and b are now both (2 2 3) 2015-12-22T02:51:29Z jcowan: Yes, Scheme is not a functional language in that sense. 2015-12-22T02:52:39Z spew joined #scheme 2015-12-22T02:53:37Z dpk: (by the way, set-car! changes the first element of a list) 2015-12-22T02:53:58Z dpk: (set-car! a 2) is like a[0] = 2 in Python 2015-12-22T02:54:30Z Necrosporus: I wonder, what if I make some function definition (define (func) (some very long computation)), then each time when I call func, computation will be repeated, even if it does not depend on parameters (since func has none)? 2015-12-22T02:54:44Z dpk: yes, it will be repeated every time 2015-12-22T02:55:15Z dpk: because it could depend on external side-effects; indeed, since it has no arguments, the implication is that it does 2015-12-22T03:02:37Z Necrosporus: (define a '(1 2 3)) (define b a) (define a '(5 6 7)) "before:" a b (set-car! a 2) "after:" a b 2015-12-22T03:03:11Z Necrosporus: In this case b is unaffected by set-car! 2015-12-22T03:07:59Z badkins quit (Remote host closed the connection) 2015-12-22T03:18:56Z Menche joined #scheme 2015-12-22T03:24:06Z jcowan: Scheme is an imperative language 2015-12-22T03:24:32Z jcowan: you can use it functionally if you are careful, as it has much of the machinery of an eager functional language 2015-12-22T03:25:51Z jcowan: That's because a points to a data structure, then b points to the same data structure, then a is made to point to a new data structure (define at top-level is variable mutation), and that data structure is itself mutated, leaving the original data structure (now poijnted to solely by b) unchanged. 2015-12-22T03:26:46Z pjb quit (Ping timeout: 240 seconds) 2015-12-22T03:33:04Z Necrosporus: Are there functional dialects of Lisp? 2015-12-22T03:33:20Z Necrosporus: Or rather, functional languages with lisp-like syntax 2015-12-22T03:39:53Z pjb joined #scheme 2015-12-22T03:44:13Z ArneBab_ joined #scheme 2015-12-22T03:44:30Z jcowan: Owl Lisp is a pure functional subset of Scheme. 2015-12-22T03:45:57Z jcowan: But the REPL is not hyperstatic: that is, you can still redefine names interactively. 2015-12-22T03:46:09Z jcowan: s/names/top-level names/ 2015-12-22T03:47:03Z jcowan: See http://c2.com/cgi/wiki?HyperStaticGlobalEnvironment 2015-12-22T03:47:20Z ArneBab quit (Ping timeout: 246 seconds) 2015-12-22T03:48:21Z jcowan: Oh, no, I'm wrong, the Owl Lisp REPL *is* hyperstatic. 2015-12-22T03:49:04Z jcowan: But there is still a difference between a procedure and its value, because procedures are objects in Owl Lisp, unlike ML. 2015-12-22T03:49:29Z jcowan: ("object" in the Scheme sense of something available at runtime, not the OO sense) 2015-12-22T03:49:50Z jcowan: [cowan@vrici ~]$ ol 2015-12-22T03:49:50Z jcowan: You see a prompt 2015-12-22T03:49:50Z jcowan: > (define b 32) 2015-12-22T03:49:50Z jcowan: b 2015-12-22T03:49:50Z jcowan: > (define (a) b) 2015-12-22T03:49:50Z jcowan: a 2015-12-22T03:49:52Z jcowan: > (a) 2015-12-22T03:49:54Z jcowan: 32 2015-12-22T03:49:58Z jcowan: > (define b 45) 2015-12-22T03:50:00Z jcowan: b 2015-12-22T03:50:02Z jcowan: > (a) 2015-12-22T03:50:04Z jcowan: 32 2015-12-22T03:52:52Z Necrosporus: jcowan, I think that static binding is not by itself sign of functional language 2015-12-22T03:58:01Z Necrosporus: I would say that (define ...) in Scheme provides static binding to variables (resolves them before binding) but dynamic binding for functions (does not resolve them before binding), but seems like binding of operator is static in both case 2015-12-22T04:01:21Z Necrosporus: (define x (+ 2 2)) (define (y) (+ 2 2)) (define + -) x (y) yelds 4 0 2015-12-22T04:01:31Z Necrosporus: (define x (+ 2 2)) (define (y) (+ 2 2)) (y) (define + -) x (y) yelds 4 4 4 2015-12-22T04:02:02Z Necrosporus: It's like first call to function could alter results of subsequent calls 2015-12-22T04:06:47Z Fare joined #scheme 2015-12-22T04:08:45Z karswell quit (Ping timeout: 260 seconds) 2015-12-22T04:10:53Z Necrosporus: Have I found a bug in Guile or Scheme is that weird? 2015-12-22T04:18:17Z psy_ quit (Remote host closed the connection) 2015-12-22T04:18:35Z adu quit (Quit: adu) 2015-12-22T04:22:18Z Niac joined #scheme 2015-12-22T04:46:59Z spew quit (Read error: Connection reset by peer) 2015-12-22T04:47:36Z magine quit (Ping timeout: 264 seconds) 2015-12-22T04:50:20Z adu joined #scheme 2015-12-22T04:50:57Z adu quit (Client Quit) 2015-12-22T04:59:12Z jcowan: Every time you do a top-level define you redefine the state of the world. 2015-12-22T04:59:23Z jcowan: (define x (+ 2 2)) binds x to 4 on the spot. 2015-12-22T04:59:55Z jcowan: (define (y) (+ 2 2)) binds y to a function which when called computes (+ 2 2) 2015-12-22T05:00:08Z jcowan: Then you mutate (not bind) + to the current value of - 2015-12-22T05:00:28Z jcowan: (Oops, before that you invoke the procedure bound to y, which will return 4 2015-12-22T05:00:30Z jcowan: ) 2015-12-22T05:00:42Z Riastradh quit (Ping timeout: 250 seconds) 2015-12-22T05:01:11Z jcowan: Necrosporus: Oh, wait, you have two series. Did you do them in the same REPL or different REPLs? 2015-12-22T05:06:48Z Necrosporus: jcowan, I guess different 2015-12-22T05:07:18Z jcowan: Okay, let's examine the first one. Remember that each top-level expression changes the state of the world. 2015-12-22T05:07:45Z jcowan: So (define x (+ 2 2)) binds x to 4 2015-12-22T05:08:12Z jcowan: (define (y) (+ 2 2)) binds y to a procedure, which if invoked will return the value of (+ 2 2). 2015-12-22T05:08:33Z jcowan: Then (define + -) will rebind + to the current value of - 2015-12-22T05:08:44Z jcowan: Then evaluating x gives 4 2015-12-22T05:08:57Z jcowan: Then calling the function y gives 0, because + has been mutated. 2015-12-22T05:09:06Z jcowan: Second series: 2015-12-22T05:09:48Z Necrosporus: first two parts are same 2015-12-22T05:10:20Z Necrosporus: (y) returns value (+ 2 2) which is 4 2015-12-22T05:10:21Z jcowan: then invoking y will return 4 2015-12-22T05:11:11Z jcowan: Ah, I see. It's because GUile compiles y when it is invoked for the first time, thus locking in the current value of + 2015-12-22T05:12:14Z jcowan: whereas Chibi, for example, compiles at definition time, thus locking in the value of + at that time. 2015-12-22T05:12:33Z jcowan: Technically these are deviations from the standard. 2015-12-22T05:13:49Z Necrosporus: jcowan, is Chibi hyperstatic? 2015-12-22T05:14:02Z jcowan: No. 2015-12-22T05:14:45Z jcowan: It compiles when a lambda expression is evaluated, and since (define (y) (+ 2 2)) means (define y (lambda () (+ 2 2))), the value of + is locked in then. 2015-12-22T05:15:48Z jcowan: The top level is not very standardized, as you can see. 2015-12-22T05:16:04Z jcowan: There is a tradeoff between consistency and convenience. 2015-12-22T05:16:19Z Necrosporus: Can I enter some non-top level in repl? 2015-12-22T05:16:31Z Necrosporus: So I would get consistent results 2015-12-22T05:17:06Z jcowan: Sure, just wrap everything in (begin ...) 2015-12-22T05:17:42Z jcowan: But make sure that all defines come before all expressions, and realize that you will only get one value back. 2015-12-22T05:17:55Z jcowan: so use (list x (y)) instead of x (y) 2015-12-22T05:18:08Z Necrosporus: That's not what I want 2015-12-22T05:18:24Z jcowan: Like I said, the REPL is convenient. 2015-12-22T05:18:52Z jcowan: Anyway, bedtime for me.... 2015-12-22T05:18:54Z jcowan quit (Quit: Leaving) 2015-12-22T05:33:14Z oleo_ quit (Quit: Verlassend) 2015-12-22T05:57:44Z nilg` joined #scheme 2015-12-22T06:04:00Z foof joined #scheme 2015-12-22T06:16:38Z Menche quit (Quit: Leaving) 2015-12-22T06:25:10Z mrowe is now known as mrowe_away 2015-12-22T06:30:15Z cdidd joined #scheme 2015-12-22T06:37:20Z ecthiender joined #scheme 2015-12-22T07:15:46Z ecthiender quit (Read error: Connection reset by peer) 2015-12-22T07:15:55Z ecthiender joined #scheme 2015-12-22T07:25:43Z Necrosporus: I'm reading SICP, Ex. 1.5 says Ben Bitdiddle has invented a test to determine whether the interpreter he is faced with is using applicative-order evaluation or normal-order evaluation. He defines the following two procedures ... 2015-12-22T07:26:01Z Necrosporus: (define (p) (p)) (define (test x y) (if (= x 0) 0 y)) (test 0 (p)) 2015-12-22T07:26:04Z luxbock quit (Quit: ZNC - http://znc.in) 2015-12-22T07:26:13Z Necrosporus: I think that interpreter should hang in both cases 2015-12-22T07:26:32Z Necrosporus: So the test wouldn't work 2015-12-22T07:30:13Z luxbock joined #scheme 2015-12-22T07:32:48Z Necrosporus: in case of applicative order, it will hang immediately, in case of normal order it will hang when trying to replace p with its definition after substituting test 2015-12-22T07:33:51Z luxbock quit (Client Quit) 2015-12-22T07:40:14Z luxbock joined #scheme 2015-12-22T07:47:12Z lambda-11235 quit (Quit: Bye) 2015-12-22T07:47:53Z nilg quit (Remote host closed the connection) 2015-12-22T07:48:18Z mmos joined #scheme 2015-12-22T07:50:03Z luxbock quit (Quit: ZNC - http://znc.in) 2015-12-22T07:53:26Z mmos quit (Quit: Leaving.) 2015-12-22T07:59:41Z magine_ joined #scheme 2015-12-22T08:00:11Z magine_ is now known as magine 2015-12-22T08:31:09Z sz0 joined #scheme 2015-12-22T08:41:15Z gravicappa joined #scheme 2015-12-22T08:43:18Z Fare quit (Ping timeout: 272 seconds) 2015-12-22T09:08:08Z cdidd quit (Ping timeout: 250 seconds) 2015-12-22T09:10:33Z ASau quit (Ping timeout: 265 seconds) 2015-12-22T09:13:20Z cdidd joined #scheme 2015-12-22T09:27:53Z bogdanm quit (Ping timeout: 246 seconds) 2015-12-22T09:29:03Z stepnem joined #scheme 2015-12-22T09:29:05Z neoncontrails joined #scheme 2015-12-22T09:30:25Z bogdanm joined #scheme 2015-12-22T09:31:11Z amz3` joined #scheme 2015-12-22T09:35:09Z bogdanm quit (Ping timeout: 245 seconds) 2015-12-22T09:40:05Z gravicappa quit (Ping timeout: 260 seconds) 2015-12-22T09:47:06Z wolfcore quit (Ping timeout: 240 seconds) 2015-12-22T09:57:11Z wolfcore joined #scheme 2015-12-22T09:57:36Z wolfcore is now known as Guest4677 2015-12-22T10:06:49Z neoncontrails quit 2015-12-22T10:08:32Z bogdanm joined #scheme 2015-12-22T10:17:02Z szgyg joined #scheme 2015-12-22T10:18:07Z biubiubiu joined #scheme 2015-12-22T10:18:49Z biubiubiu: hi there, what do you think this version of fibonacci: http://paste.ubuntu.com/14136217/ 2015-12-22T10:19:44Z biubiubiu: is that ok ? 2015-12-22T10:27:00Z nilg` quit (Read error: Connection reset by peer) 2015-12-22T10:29:19Z wasamasa: why call/cc? 2015-12-22T10:34:31Z biubiubiu: just a simple example to show the usage of call/cc :) 2015-12-22T10:35:19Z wasamasa: >_> 2015-12-22T10:35:54Z biubiubiu: call/cc can do break, return, goto, loop, so awesome 2015-12-22T10:36:04Z biubiubiu: but goto is really awesome 2015-12-22T10:36:50Z biubiubiu: but lots of language don't support goto except c AFAIK 2015-12-22T10:39:02Z wasamasa: and asm and php and CL 2015-12-22T10:46:58Z cibs quit (Read error: Connection reset by peer) 2015-12-22T10:48:57Z magine quit (Remote host closed the connection) 2015-12-22T10:52:01Z cibs joined #scheme 2015-12-22T10:59:11Z fikusz quit (Quit: Leaving) 2015-12-22T10:59:44Z cibs quit (Read error: Connection reset by peer) 2015-12-22T11:04:48Z cibs joined #scheme 2015-12-22T11:12:43Z mmc joined #scheme 2015-12-22T11:18:49Z cibs quit (Read error: Connection reset by peer) 2015-12-22T11:18:49Z cibs_ joined #scheme 2015-12-22T11:23:20Z cibs_ quit (Ping timeout: 272 seconds) 2015-12-22T11:23:51Z cibs joined #scheme 2015-12-22T11:25:00Z cibs quit (Read error: Connection reset by peer) 2015-12-22T11:28:50Z cibs joined #scheme 2015-12-22T11:42:54Z ecthiender quit (Quit: gotta go) 2015-12-22T11:57:20Z gravicappa joined #scheme 2015-12-22T12:08:15Z taylan: biubiubiu: FYI delimited continuations are preferred over call/cc nowadays 2015-12-22T12:08:48Z biubiubiu: taylan: what's FYI ? 2015-12-22T12:09:45Z taylan: For Your Information 2015-12-22T12:09:58Z biubiubiu: taylan: I heard of delimited continuations, there're three kind of ? 2015-12-22T12:10:31Z biubiubiu: taylan: shift/reset prompt/ and I forget 2015-12-22T12:12:31Z taylan: biubiubiu: there's shift/reset, and prompt/control. I don't remember a third well-known kind, but Guile has call-with-prompt/abort-to-prompt. 2015-12-22T12:13:03Z biubiubiu: and just a few implement support delimited continuations AFAIK 2015-12-22T12:13:53Z taylan: (call-with-prompt/abort-to-prompt are semantically like prompt/control, just look a bit different in how they're used) 2015-12-22T12:16:11Z biubiubiu: taylan: I see continuation introduce from http://community.schemewiki.org/?call-with-current-continuation, and coroutines is really make my brain twisted 2015-12-22T12:17:34Z biubiubiu: why scheme is too difficult to learn 2015-12-22T12:20:06Z taylan: biubiubiu: call/cc makes some things more complicated than they need be 2015-12-22T12:20:18Z taylan: biubiubiu: delimited continuations can implement some things more naturally 2015-12-22T12:21:01Z taylan: biubiubiu: also, I think Guile's call-with-prompt is the most easiest to understand. I find shift/reset and control/prompt more difficult to understand. 2015-12-22T12:21:19Z biubiubiu: taylan: does shift/reset equal prompt/control ? why there're two different delimited conitinuations ? 2015-12-22T12:22:09Z biubiubiu: taylan: I see shift/rest introduce on wikipedia and schemewiki 2015-12-22T12:25:35Z turtleman_ joined #scheme 2015-12-22T12:25:42Z taylan: biubiubiu: the Guile manual explains the difference in a friendly way 2015-12-22T12:26:23Z taylan: http://www.gnu.org/software/guile/manual/html_node/Prompts.html 2015-12-22T12:26:39Z biubiubiu: taylan: ok, my english is not good, and gnu docs is really not make people easy to understand I think 2015-12-22T12:27:16Z taylan: I think the Guile manual is one of the more easy to understand ones on this. (GNU manuals are all written by different people.) 2015-12-22T12:27:37Z taylan: but it's still not very easy to understand, because it's a difficult concept. 2015-12-22T12:32:42Z Beluki joined #scheme 2015-12-22T12:36:02Z biubiubiu: taylan: I'll see it later, now I'm thinking how to make loop in call/cc 2015-12-22T12:36:32Z biubiubiu: without function call 2015-12-22T12:37:12Z biubiubiu: in (call/cc ...) and not after (call/cc ...), I'm stuck in closure now 2015-12-22T12:38:22Z biubiubiu: and some lexical sugar make me confuse ;( 2015-12-22T12:52:11Z taylan quit (Disconnected by services) 2015-12-22T12:52:23Z taylan joined #scheme 2015-12-22T12:54:15Z biubiubiu: taylan: http://paste.ubuntu.com/14136885/ I did it! write loop with continuation 2015-12-22T13:06:54Z psy_ joined #scheme 2015-12-22T13:28:40Z biubiubiu quit (Quit: ERC (IRC client for Emacs 24.5.1)) 2015-12-22T13:35:08Z spew joined #scheme 2015-12-22T13:45:01Z davexunit joined #scheme 2015-12-22T14:07:08Z psy_ quit (Ping timeout: 250 seconds) 2015-12-22T14:08:02Z gravicappa quit (Remote host closed the connection) 2015-12-22T14:14:55Z pierpa joined #scheme 2015-12-22T14:29:06Z turtleman_ quit (Read error: No route to host) 2015-12-22T14:40:30Z joneshf-laptop quit (Ping timeout: 272 seconds) 2015-12-22T14:47:28Z davexunit quit (Ping timeout: 272 seconds) 2015-12-22T14:55:11Z davexunit joined #scheme 2015-12-22T14:56:14Z turtleman_ joined #scheme 2015-12-22T14:59:40Z oleo joined #scheme 2015-12-22T14:59:40Z oleo quit (Changing host) 2015-12-22T14:59:40Z oleo joined #scheme 2015-12-22T15:02:03Z m1dnight_ quit (Quit: WeeChat 1.4-dev) 2015-12-22T15:03:59Z m1dnight_ joined #scheme 2015-12-22T15:12:15Z szgyg quit (Ping timeout: 240 seconds) 2015-12-22T15:16:11Z lritter joined #scheme 2015-12-22T15:21:46Z Riastradh joined #scheme 2015-12-22T15:34:13Z badkins joined #scheme 2015-12-22T15:44:47Z Niac quit (Quit: Lost terminal) 2015-12-22T16:07:13Z jcowan joined #scheme 2015-12-22T16:10:52Z sethalves joined #scheme 2015-12-22T16:17:36Z nzambe quit (Quit: http://www.kiwiirc.com/ - A hand crafted IRC client) 2015-12-22T16:26:40Z ecraven: what do people here use for simple scripts (stuff you'd usually write in bash)? I'd love to use some Scheme, but most servers don't have any, and don't even have recent versions packaged 2015-12-22T16:28:37Z mario-goulart: Don't they have a C compiler? 2015-12-22T16:28:45Z davexunit: ecraven: I use Guile 2015-12-22T16:28:51Z davexunit: it has a good POSIX interface 2015-12-22T16:29:54Z davexunit quit (Read error: Connection reset by peer) 2015-12-22T16:30:47Z Riastradh quit (Ping timeout: 264 seconds) 2015-12-22T16:31:54Z LeoNerd quit (Remote host closed the connection) 2015-12-22T16:32:13Z LeoNerd joined #scheme 2015-12-22T16:32:38Z ecraven: hm.. I'll have to check what version of guile/chicken exactly is available on RHEL 7 2015-12-22T16:33:29Z Beluki quit (Quit: Beluki) 2015-12-22T16:35:25Z wasamasa: I use chicken 2015-12-22T16:35:45Z wasamasa: but mind you, I'm not religiously rewriting all the stuff that's been programmed in bash/python/ruby 2015-12-22T16:39:13Z aap_ is now known as aap 2015-12-22T16:40:05Z cemerick joined #scheme 2015-12-22T16:40:08Z ecraven: wasamasa: I don't want that (yet) :) just something for some basic data processing that doesn't suck.. 2015-12-22T16:40:17Z civodul joined #scheme 2015-12-22T16:40:52Z wasamasa: just the things where it makes sense and everything new that's more complex than one or two lines of bash 2015-12-22T16:41:34Z wasamasa: I'd probably compile everything that matters locally on RHEL and add the relevant directory to PATH 2015-12-22T16:41:51Z mario-goulart: ecraven: if your servers have a C toolchain and GNU make installed, building CHICKEN is trivial. 2015-12-22T16:42:29Z zwdr: you could use scsh 2015-12-22T16:42:49Z zwdr: I dont know too much about it though 2015-12-22T16:44:45Z davexunit joined #scheme 2015-12-22T16:53:24Z ecraven: mario-goulart: I know, but that's one more thing to remember to do, compared to just requiring latest in puppet :-/ 2015-12-22T16:53:40Z mario-goulart: ah, ok. 2015-12-22T16:54:07Z ecraven: also, this is for 8 or so vms, I'd prefer not to do it all 8 times :) 2015-12-22T16:54:50Z mario-goulart: I see. I thought it was some kind of server on which you don't have admin privileges or something. 2015-12-22T16:55:20Z mario-goulart: If you can install whatever you want, just pick your favorite language implementation. :-) 2015-12-22T16:57:14Z ecraven: mario-goulart: that's the problem, none of the usual suspects (ruby, python, lua, ..) is what I want to use :) so some Scheme it will be 2015-12-22T16:57:25Z lambda-11235 joined #scheme 2015-12-22T16:57:27Z ecraven: right now I'm writing things in bash that just shouldn't be :) 2015-12-22T16:58:08Z mario-goulart: Doesn't MIT Scheme do the trick? (that's what you use, right?) 2015-12-22T16:58:10Z cemerick quit (Ping timeout: 260 seconds) 2015-12-22T17:00:39Z amz3` quit (Quit: WeeChat 1.0.1) 2015-12-22T17:23:50Z mmc quit (Ping timeout: 260 seconds) 2015-12-22T17:25:45Z Necrosporus: guile> (log (fib 132105)) yelds +inf.0. Why is it so while it should compute to a relatively small number? 2015-12-22T17:26:12Z Necrosporus: Near one hundred thousands 2015-12-22T17:27:38Z ecraven: mario-goulart: that suffers from its own problems.. if I didn't have so much code in it that I use, I might investigate switching :-/ but the SLIME-support alone is worth a lot 2015-12-22T17:27:52Z jcowan: Necrosporus: Show us your definition of fib 2015-12-22T17:28:27Z Necrosporus: jcowan, it's from SICP, slightly modified. And if I use it without log, it is fine 2015-12-22T17:29:09Z Necrosporus: (define (fib n) (fib-iter 1 0 (- n 1))) (define (fib-iter a b count) (if (= count 0) a (fib-iter (+ a b) a (- count 1)))) 2015-12-22T17:29:31Z Necrosporus: (linearized so it could fit in one line of chat) 2015-12-22T17:29:38Z jcowan: Okay. In that case the problem is that log converts its argument to an inexact number, and since (fib 132105) is bigger than the biggest inexact number available, you get (log +inf.0), which is +inf.0. 2015-12-22T17:30:36Z Necrosporus: How could I count digits in that number? Convert it to string and run some string length function instead? 2015-12-22T17:30:52Z blackwolf joined #scheme 2015-12-22T17:31:09Z jcowan: Exactly 2015-12-22T17:31:18Z jcowan: (string-length (number->string (fib 132105))) 2015-12-22T17:31:47Z Necrosporus: Is there something like shell time too? 2015-12-22T17:32:07Z Necrosporus: to calculate execution time. Visually it's something like 0.5 seconds for me 2015-12-22T17:33:43Z jcowan: Call get-internal-run-time before and after, compute the difference, and divide by the variable internal-time-units-per-second to get seconds. This is Guile-specific. 2015-12-22T17:39:10Z mmc joined #scheme 2015-12-22T17:40:16Z Necrosporus: Thanks 2015-12-22T17:48:55Z jkraemer quit (Ping timeout: 240 seconds) 2015-12-22T17:58:05Z mutbuerger quit (Remote host closed the connection) 2015-12-22T18:02:08Z jkraemer joined #scheme 2015-12-22T18:02:23Z mmc quit (Ping timeout: 255 seconds) 2015-12-22T18:11:29Z sethalves quit (Remote host closed the connection) 2015-12-22T18:11:46Z scoofy quit (Ping timeout: 240 seconds) 2015-12-22T18:15:21Z Menche joined #scheme 2015-12-22T18:18:52Z jcowan_ joined #scheme 2015-12-22T18:22:32Z jcowan quit (Ping timeout: 276 seconds) 2015-12-22T18:22:45Z duggiefresh joined #scheme 2015-12-22T18:26:10Z Riastradh joined #scheme 2015-12-22T18:31:28Z micmus joined #scheme 2015-12-22T18:34:11Z sethalves joined #scheme 2015-12-22T18:42:02Z DGASAU quit (Read error: Connection reset by peer) 2015-12-22T18:42:55Z DGASAU joined #scheme 2015-12-22T18:43:42Z Riastradh quit (Ping timeout: 272 seconds) 2015-12-22T18:47:52Z Shadox joined #scheme 2015-12-22T18:54:24Z jcowan joined #scheme 2015-12-22T18:56:06Z jcowan_ quit (Ping timeout: 240 seconds) 2015-12-22T19:21:31Z Beluki joined #scheme 2015-12-22T19:23:19Z psy_ joined #scheme 2015-12-22T19:24:23Z tessier_ quit (Ping timeout: 265 seconds) 2015-12-22T19:25:11Z tessier joined #scheme 2015-12-22T19:25:12Z tessier quit (Changing host) 2015-12-22T19:25:12Z tessier joined #scheme 2015-12-22T19:35:34Z duggiefresh quit (Remote host closed the connection) 2015-12-22T19:36:53Z duggiefresh joined #scheme 2015-12-22T19:49:13Z badkins_ joined #scheme 2015-12-22T19:50:32Z badkins quit (Ping timeout: 246 seconds) 2015-12-22T20:07:41Z cemerick joined #scheme 2015-12-22T20:11:06Z emacsomancer quit (Ping timeout: 272 seconds) 2015-12-22T20:36:52Z mutbuerger joined #scheme 2015-12-22T20:38:55Z leppie quit 2015-12-22T20:41:03Z leppie joined #scheme 2015-12-22T20:48:57Z duggiefresh quit (Remote host closed the connection) 2015-12-22T21:06:55Z karswell joined #scheme 2015-12-22T21:18:13Z mumptai joined #scheme 2015-12-22T21:18:33Z pilne joined #scheme 2015-12-22T21:35:42Z davexunit quit (Quit: Later) 2015-12-22T21:41:07Z Necrosporus quit (Disconnected by services) 2015-12-22T21:41:32Z Necrosporus joined #scheme 2015-12-22T21:48:29Z cemerick quit (Ping timeout: 246 seconds) 2015-12-22T21:57:26Z teurastaja joined #scheme 2015-12-22T21:58:25Z teurastaja: hey. i want to implement cons in c using macros. so far i have#define CAR(x, y) x 2015-12-22T21:58:38Z teurastaja: #define CDR(x, y) y 2015-12-22T21:59:28Z teurastaja: but i dont know how to define CONS 2015-12-22T22:06:06Z ASau joined #scheme 2015-12-22T22:07:52Z teurastaja: ahem 2015-12-22T22:09:17Z lambda-11235: If you don't mind using an extra APPLY macro you could do http://lpaste.net/147689. 2015-12-22T22:10:43Z duggiefresh joined #scheme 2015-12-22T22:11:26Z lambda-11235: Note that I ran that raw in CPP, so you might want to put the last two expressions in printf calls. 2015-12-22T22:12:48Z wildlander joined #scheme 2015-12-22T22:12:49Z leppie quit (Read error: Connection reset by peer) 2015-12-22T22:14:58Z leppie joined #scheme 2015-12-22T22:21:28Z mrowe_away is now known as mrowe 2015-12-22T22:21:32Z hiroakip joined #scheme 2015-12-22T22:27:34Z spew quit (Quit: leaving) 2015-12-22T22:29:48Z teurastaja: same in c? 2015-12-22T22:30:59Z teurastaja: is there a way to eliminate the apply? 2015-12-22T22:33:02Z badkins joined #scheme 2015-12-22T22:33:51Z badkins_ quit (Ping timeout: 265 seconds) 2015-12-22T22:35:01Z duggiefresh quit (Remote host closed the connection) 2015-12-22T22:39:12Z lambda-11235: Sorry, on further inspection the APPLY isn't necessary. See http://lpaste.net/147689. 2015-12-22T22:40:10Z lambda-11235: And yes, in C you would just wrap the last two statements in printf's and a main function. 2015-12-22T22:40:40Z lambda-11235: I just prefer using cpp from the command line. 2015-12-22T22:42:10Z teurastaja: and are the _PRE macros really necessary? 2015-12-22T22:42:47Z mmc joined #scheme 2015-12-22T22:46:03Z teurastaja: maybe by passing 3 parameters? 2015-12-22T22:46:12Z teurastaja: im just not sure how to 2015-12-22T22:54:10Z lritter quit (Remote host closed the connection) 2015-12-22T23:00:18Z mmc quit (Quit: Leaving.) 2015-12-22T23:00:35Z mmc joined #scheme 2015-12-22T23:03:17Z davexunit joined #scheme 2015-12-22T23:08:48Z duggiefresh joined #scheme 2015-12-22T23:08:59Z adu joined #scheme 2015-12-22T23:12:32Z taylan quit (Disconnected by services) 2015-12-22T23:12:43Z taylan joined #scheme 2015-12-22T23:14:12Z benaiah: I'm having trouble connecting a source file to chicken with geiser - C-x C-e isn't executing in the repl context, and doesn't appear to be executing at all. I started chicken with M-x run-chicken in the source buffer - is there something I'm missing to connect the two buffers 2015-12-22T23:14:15Z benaiah: *? 2015-12-22T23:17:06Z teurastaja: benaiah: (define (connect buffer1 buffer2) ...) 2015-12-22T23:18:45Z benaiah: teurastaja: I want to be able to evaluate code from the source code buffer in the repl context so I can use definitions in the source buffer in the repl buffer 2015-12-22T23:18:56Z benaiah: *definitions from 2015-12-22T23:19:23Z benaiah: as far as I understand the geiser docs, what I did should be working 2015-12-22T23:20:35Z teurastaja: i dont know either geiser nor chicken but you mean you want to pipe your source file to that thing? 2015-12-22T23:21:51Z teurastaja: oh you mean you want to (load file) ? 2015-12-22T23:23:52Z teurastaja: like evaluating the contents of a text file in a repl? 2015-12-22T23:29:37Z benaiah: teurastaja: no, I could do that, but geiser is supposed to hook that up automatically so I can eval specific expressions and don't have to explicitly save and load the file 2015-12-22T23:30:38Z hiroakip quit (Ping timeout: 276 seconds) 2015-12-22T23:32:29Z teurastaja: sounds like a library 2015-12-22T23:32:42Z teurastaja: or a startup script 2015-12-22T23:35:15Z benaiah: no, it's an emacs package that tries to create a live coding environment 2015-12-22T23:35:27Z benaiah: it's just not working correctly. I've also asked on #emacs 2015-12-22T23:35:31Z karswell quit (Ping timeout: 260 seconds) 2015-12-22T23:37:31Z wasamasa: benaiah: FWIW, the one guy who added chicken support to geiser happens to hang out on #chicken 2015-12-22T23:38:01Z teurastaja: vive #freenode 2015-12-22T23:38:12Z teurastaja: i mean freenode 2015-12-22T23:38:12Z benaiah: wasamasa: thanks 2015-12-22T23:38:30Z wasamasa: so you might be lucky enough to get first-class support 2015-12-22T23:38:44Z wasamasa: otherwise just describe the issue as clearly as you can and hand in a ticket on github 2015-12-22T23:39:20Z benaiah: wasamasa: geiser doesn't have an official github AFAICT 2015-12-22T23:39:25Z benaiah: wasamasa: it's on savannah 2015-12-22T23:39:40Z wasamasa: I've handed in three tickets there already :> 2015-12-22T23:40:10Z benaiah: wasamasa: hm. I'll do some more looking then 2015-12-22T23:40:21Z wasamasa: https://github.com/jaor/geiser/issues?q=is%3Aissue+author%3Awasamasa+is%3Aclosed 2015-12-22T23:40:21Z rudybot: http://teensy.info/lJjHNeNzRV 2015-12-22T23:42:45Z benaiah: it doesn't appear to be chicken-specific, fwiw. I also get a "this buffer has no geiser repl" with racket 2015-12-22T23:47:06Z jcowan quit (Ping timeout: 240 seconds) 2015-12-22T23:48:49Z civodul quit (Quit: ERC (IRC client for Emacs 24.5.1)) 2015-12-22T23:48:53Z oleo_ joined #scheme 2015-12-22T23:52:05Z oleo quit (Ping timeout: 276 seconds) 2015-12-22T23:56:08Z Guest4677 quit (Changing host) 2015-12-22T23:56:08Z Guest4677 joined #scheme 2015-12-22T23:56:15Z Guest4677 is now known as wolfcore 2015-12-22T23:58:54Z ASau quit (Read error: Connection reset by peer) 2015-12-22T23:59:06Z teurastaja_ joined #scheme