libera/#commonlisp - IRC Chatlog

20:08:35 phantomics Sup everyone, was wondering if anyone had tried the Yale Haskell compiler

20:21:31 Lord_of_Life_ ** NICK Lord_of_Life

21:35:25 aeth_ ** NICK aeth

0:39:48 Andrew ** NICK LeetPeet

0:45:47 AndrewYu ** NICK Andrew

1:09:30 asarch How could I "put" the arguments of a function into a variable (e.g.: (format t "Se venden tacos") → (format foo))?

1:14:37 zacque If foo = '(t "Se venden tacos"), then you can invoke `format` like (apply #'format foo)

1:14:55 zacque You can test it out like: (apply #'format '(t "Se venden tacos"))

1:15:20 zacque Or: (let ((foo '(t "Se venden tacos"))) (apply #'format foo))

1:16:05 zacque asarch: The result should be what you have in mind

1:17:38 asarch Is there a way to do it with a macro (e.g. (format `(,taco)))?

1:18:47 zacque Yup, then you simply have to build the require form. More like `(format ,@taco)`

1:19:02 asarch How would you declare the macro?

1:19:21 White_Flame you shouldn't use a macro where a function suffices

1:19:39 White_Flame declare the function inline, if inlining is the major reason

1:20:03 asarch ?

1:20:18 asarch How would you do it?

1:20:47 White_Flame the macro or the function? both would be as zacque already pointed out:

1:21:17 White_Flame (defun out (&rest args) (apply #'format args))

1:21:29 White_Flame or (defun out (list) (apply #'format list))

1:21:44 White_Flame (defmacro out (list) `(format ,@list))

1:22:14 asarch format should be out of the macro

1:22:26 zacque asarch: What are you trying to do here?

1:24:03 zacque What do you mean by "format should be out of the macro"? Can you move it out by yourself?

1:24:07 asarch Let's say taco = t "Se venden ~d tacos". I would like to do: (format foo 10) → (format t "Se venden ~d~%" 10)

1:25:20 asarch I mean, the macro should be expanded as: (format t "Se venden ~d tacos" 10)

1:26:10 asarch The args t and "Se venden ~d tacos" must be inside the foo var so I could easy type: (format foo 10)

1:27:19 White_Flame (apply #'format (append taco args))

1:42:06 jmercouris there's some sort of uiop:write-string-to-file or something

1:42:09 jmercouris I can't remember what it is

1:42:12 jmercouris I just want to dump a string to a file

1:42:58 jmercouris sorry, seems it was alexandria

1:43:02 asarch (defmacro taco() t "Se venden ~d tacos")

1:43:17 jmercouris for anyone curious it is alexandria:write-string-into-file

1:44:13 asarch (format `(,(taco)) 10)

1:44:23 asarch But t is not expanded

1:47:08 zacque asarch: Can you try pasting your code into a pastebin: https://plaster.tymoon.eu/

1:47:18 asarch That's all my code

1:47:26 asarch Those two lines

1:47:35 zacque Is it two lines or one line?

1:47:40 zacque Oh

1:47:52 asarch 1. (defmacro taco() t "Se venden ~d tacos")

1:48:00 asarch 2. (format `(,(taco)) 10)

1:49:40 imjim I just ran that in `clisp` and got "FORMAT: The control-string must be a string, not 10"

1:51:30 asarch Those two lines should become into: (format t "Se venden ~d tacos" 10)

1:52:02 zacque asarch: You can either: (defmacro taco (num) `(format t "Se venden ~d tacos" ,num)) or (defun taco2 (num) (apply #'format (list t "Se venden ~d tacos" num)))

1:52:33 zacque As White_Flame said, you are advised to use a function

1:53:24 zacque I think you should check out how to write a macro: https://gigamonkeys.com/book/macros-defining-your-own.html

1:53:49 asarch Then I could easily write (defun beer(pizza) (format t "Se venden ~d tacos" pizza)) and then I just (beer 10), right?

1:53:57 asarch But that's not what I need

1:55:30 zacque So, what exactly are you trying to do?

1:55:41 zacque You want something like this: (format `(,(taco)) 10)?

1:58:23 zacque You can't do that in Common Lisp, it's not the way it works

1:58:30 zacque The equivalent way to do that is: (apply #'format (append taco args))

1:59:01 zacque It does what you have in mind, but according to rules of the game

1:59:34 zacque Here: taco = '(t "Se venden ~d tacos")

2:00:25 zacque Maybe you should try it out in a REPL?

2:01:24 zacque Maybe the question you should ask is why (format `(,(taco)) 10) works as you think

2:01:40 zacque And understanding that question will bring you further

2:08:08 asarch I need something a la C' macros (with arguments and all) so I could write a full mixture of them: (format foo 10 bar baz(10)…) → (format t "Se venden ~d tacos" 10 …)

2:08:09 asarch :(

2:10:50 zacque How about (apply #'format (append foo 10 bar (baz 10) ...)))?

2:11:16 zacque Are you trying to write Lisp or C?

2:11:23 zacque Or write C in Lisp?

2:11:49 zacque For the later check out: https://github.com/dundalek/awesome-lisp-languages

2:15:13 hayley Better check https://gist.github.com/no-defun-allowed/4f0a06e17b3ce74c6aeac514281f350f

2:16:14 zacque Oh, come to think of that, maybe a symbol macro will help

2:19:19 pillton asarch: Macros in common lisp are nothing like C macros. The word macro in common lisp is actually short for macro function. Furthermore, there are actually many types of macros: reader macros, symbol macros and macro functions. Reader macros are executed when forms are being created from a character string or a character stream. Symbol macros and macro functions are expanded or invoked during compilation or evaluation.

2:32:19 zacque hayley: I don't really get what the article is trying to say

2:32:29 hayley Nor do I.

2:32:35 zacque Lol

2:32:58 hayley Sturgeon's law applies to the Lisp family?

2:34:52 zacque Like not all programming language with S-exp are Lisp?

2:35:26 zacque But there are other arguments in it as well

2:36:17 hayley There's no real definition for Lisp, so we can argue all day about what languages are "Lisp" or not. But most are terrible.

2:36:25 zacque It only says "not all programming languages with S-exp are Lisp" but didn't say what exactly is Lisp to him/her

2:36:49 zacque Agree

2:37:58 hayley I don't think I said anything about any languages not being Lisp.

2:43:01 asarch Thank you, thank you very much :-)

2:45:27 hayley But I guess I am confused as to how we jumped to "Are you trying to write Lisp or C?"

2:47:19 zacque My bad, I saw asarch said he wants "something a la C' macros" and in the format example, there is a "baz(10)"

2:47:49 hayley Okay.

2:48:40 asarch #define abs((x)(y)) …

2:48:50 White_Flame (defmacro abs (x y) ..)

2:49:02 hayley Even if we had the right syntax, say (format foo 10 bar (baz 10) …) I don't see how you get to (format t "Se venden ~d tacos" 10 …), unless we use how the C preprocessor can replace a macro form with zero or multiple forms.

2:49:11 White_Flame and shockingly you can just use normal lisp code to generate the expansion, instead of a separate template language ;)

2:49:16 hayley And...I guess I am happy that Lisp macros cannot do that.

2:49:52 zacque We can using symbol-macros...

2:50:40 zacque Oh, we can't

2:52:53 asarch Anyway, have a nice day gentlemen. See you later :-)

3:01:53 beach Good morning everyone!

3:03:34 phantomics Morning beach

3:11:50 phantomics Asking this again as more are around: Has anyone ever used the Yale Haskell compiler? It's supposed to be implemented in CL but it appears to use Pseudoscheme, a Scheme implementation compiling to CL which I downloaded but couldn't get working, the build process is obviously very old

3:15:35 hayley I might know someone who has.

3:16:54 hayley Still, <https://github.com/fiddlerwoaroof/yale-haskell-reboot> looks self-contained and doesn't mention a Pseudoscheme dependency.

3:19:39 hayley Or rather <https://github.com/haskell-lisp/yale-haskell> looks like the original repository. Hm.

3:23:09 phantomics Oh cool, I didn't find the reboot. The second repo is the original

3:24:06 phantomics It's an interesting piece for Lisp archaeologists

3:30:47 zacque Interesting, seems like it's the implementation of Haskell 1.2/1.3?

3:30:53 zacque Based on what I read here: https://encyclopedia2.thefreedictionary.com/Yale+Haskell

3:34:17 phantomics I was thinking it could be neat to build an April-style interface to it so you could invoke Haskell in the middle of CL code

3:38:05 ldb phantomics: YHC actually builds on T language, which is a dialect of lisp in the linage of Scheme but more focus on low level

3:39:08 phantomics ldb: The repo page says it doesn't work with T

3:40:20 ldb Yes at sometime they try to mimic T on lisp/scheme and the compatibility was broken

3:41:48 phantomics So they tried to port it from T to CL (or Scheme?) and broke it?

3:44:28 ldb They ported it to Common Lisp following an older standard (Lucid Common Lisp), and today's CL is no longer fully compatible with that.

3:45:44 phantomics Gotcha, I'll try the fiddlerwoaroof reboot, wonder what it would take to get working again

3:49:02 ldb The parser is actually not very good, and besides that it's all about high level code transformations, the runtime is just "lazy eval based on lisp closures".

3:50:02 phantomics Right, parsing a vector language is complicated enough

4:17:25 Guest74 surprised nobody mentioned formatter.  But who knows what was trying to be accomplished.

4:35:09 semz_ ** NICK semz

5:05:39 lispy hi guys

5:06:08 lispy I wrote this function : https://plaster.tymoon.eu/view/3017#3017

5:06:08 lispy I keep getting an error on the last progn saying the variable "ELEMENT" is not defined (its supposed to be a plist)

5:06:18 lispy If I just remove element it works but I am trying to return it

5:06:28 lispy I don't understand what the problem is :\

5:08:09 lispy if I give it something self evaluating (like 40) it works, but with the variable element it doesn't

5:09:17 beach I don't get any error like that.

5:09:39 beach Oh, you mean when you run it?

5:09:59 beach The variable ELEMENT is defined. So the error must say something else.

5:10:20 lispy weird

5:10:22 lispy sec

5:11:47 lispy I tried it again and it worked....... i think i maybe had the wrong region shaded and it caused the error, awkward.

5:11:50 lispy Thanks.

5:11:59 beach Sure.

5:17:42 lispy I guess I am still having a problem with that function but now its a logical problem

5:19:38 beach Your code is strange. It looks like in the `then' branch of the IF, you should be able to use T rather than MEMBER-P.

5:19:50 lispy if I call "(add-element '(:colored "Red" :price 15))"

5:19:51 lispy and then call "(gethash 1 *id-hash-table*)"

5:19:51 lispy I get (:COLORED "Red" :PRICE 15)

5:19:52 lispy But when I call "(gethash '(COLORED "RED" :PRICE 15) *value-hash-table*" i just get NILs

5:20:01 AndrewYu ** NICK Andrew

5:20:41 lispy I think its a naming issue, member-p isnt a boolean

5:20:58 beach Then your code is weird in many other ways.

5:20:59 lispy It was when I first wrote the function but I should change it

5:21:18 lispy sure, whats the problem

5:21:18 beach IF should be given a Boolean as a test, and the variable should not be called MEMBER-P.

5:21:34 lispy does it need to be a boolean ? Its either NIL or anything else no ?

5:22:00 beach I am not talking about semantics. I am talking about the message you sent to people who read your code, in this case me.

5:22:30 lispy Right, what would you suggest I use other than an if here ? if its either nil or some value

5:22:56 beach Then I would use (if (null ...) ... ...) and reverse the branches.

5:23:30 lispy sure

5:23:33 lispy anything else weird or ?

5:23:50 beach There is a mysterious blank line between the two IF branches.

5:24:03 lispy I have it there for readability

5:24:16 beach I am sorry to hear that.

5:24:25 beach This is not how Common Lisp code is written.

5:24:56 beach If you have it there for readability, then extract each branch to a function, remove the PROGNs.

5:25:32 lispy so the expectation is to have the if inline ? like (if () () ) or the issue is the blank line only ?

5:25:39 beach The latter.

5:25:57 lispy right

5:25:59 beach Look at existing Common Lisp code. You see a blank line only between top-level forms.

5:25:59 lispy Anything else ?

5:26:54 beach Well, I don't really understand the code, so it is hard to say. I would probably abstract out the explicit hash tables and use a "dictionary"-type interface.

5:27:14 lispy hmm

5:27:35 lispy I have two hash tables one where the id is the key and the value is the value and another where its the opposite

5:27:57 lispy forget the "T" branch for now for the first F

5:27:59 lispy if*

5:28:03 beach And I would remove the HASH-TABLE part of the names of the special variables.

5:28:20 lispy why isnt the NIL Branch saving the value to id hash ?

5:29:42 beach It looks like it is.

5:30:01 lispy "(gethash '(COLORED "RED" :PRICE 15) *value-hash-table*" returns 2 NILs :(

5:30:19 beach Are you using the right :TEST for your hash tables?

5:30:28 lispy im using default, which is EQL

5:30:33 lispy should be fine since the lists arent strings no ?

5:30:48 beach Try (eql '(COLORED "RED" :PRICE 15) '(COLORED "RED" :PRICE 15))

5:31:19 lispy hmm

5:31:33 lispy so i need to use equal.. ok

5:31:48 beach What makes you think two lists constructed at different times by the reader would be EQL?

5:32:35 lispy Im kinda new to lisp, more used to other languages, I don't know what the difference between EQL and equal is exactly

5:32:49 beach clhs eql

5:32:49 specbot http://www.lispworks.com/reference/HyperSpec/Body/a_eql.htm

5:32:55 beach clhs equal

5:32:55 specbot http://www.lispworks.com/reference/HyperSpec/Body/f_equal.htm

5:32:56 lispy Yep, reading up on it right now :)

5:36:07 lispy Alright, ill try it, thanks.

5:37:02 beach Pleasure.

5:38:34 lispy Huge, its working, thanks for all the tips but I must go start work now.

5:38:53 beach Good luck!

5:45:06 hashfunc14a0 why is (/ #xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F #x02) giving me 115792089237316195423570985008687907853269984665640564039457584007908834671663/2 ?

5:45:10 hashfunc14a0 why am i not getting a sane result?

5:47:02 White_Flame why isn't it sane? you're giving it precise numbers, it's giving you a lossless/precise result

5:47:34 aeth isn't that the exact answer? not going to run it to check if it's a compiler/CPU bug

5:47:45 White_Flame clearly it's an odd number, so division by 2 would either yield an imprecise int, or imprecise float

5:48:06 White_Flame thus a rational is most sane

5:48:33 aeth if you don't want the exact answer, you have to tell it how to round. ROUND, TRUNCATE, FLOOR, CEILING. And if you want to turn it into a float, then FROUND, FTRUNCATE, FFLOOR, FCEILING

5:48:43 aeth and specifically for powers of two, you can ASH

5:48:49 aeth if you want to shift

5:48:53 White_Flame or just plain (float *)

5:49:01 aeth well, no

5:50:36 aeth you'll get different answers if you do FLOAT or COERCE vs if you do it directly... probably a bit less efficient, perhaps with an intermediate bignum/bignum rational if the compiler doesn't expect it.

5:50:49 aeth e.g. (coerce (/ #xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F #x02) 'double-float)

5:50:52 aeth vs. (fround #xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F (coerce #x02 'double-float))

5:51:29 aeth Same answer, but it doesn't have to be. FROUND defaults to single-float unless you specify double-float, so you do have to do some coerce, but nothing that a helper function can't fix

5:51:30 White_Flame I meant converting the result to a float

5:51:39 White_Flame for display

5:52:28 White_Flame but still, I presume a large hex number would be the most desirable for this situation? then round + print in base 16

5:56:53 White_Flame hashfunc14a0: if this is the case, recall that the reader simply reads the big hex number as an integer, passing no knowledge that it was in a hex representation originally

6:00:07 hashfunc14a0 White_Flame: aeth: ah ok. thanks ya'll. that makes sense

6:17:15 Josh_2 Good morning

6:18:48 aeth yes, you'd usually want to manually use FORMAT anyway, so you can get the right amount of leading 0s

6:18:59 aeth since it wouldn't know how many to provide for a bignum

6:19:47 aeth e.g. (format t "#x~32,'0x" #xff)

6:20:27 aeth and half that is (format t "#x~32,'0x" (ash #xff -1))

6:20:48 jdz hashfunc14a0: An illustrative question is: what would you expect an answer to the following expression to be: (+ (/ 1 3) (/ 2 3)), which can also be written as (+ 1/3 2/3)?

6:25:52 beach It would be "interesting" if "sane" were to be defined as "what broken languages like C do".

6:54:47 ck_ not closely related, but I keep wanting to ask this question: where in the clhs, for example http://www.lispworks.com/documentation/HyperSpec/Body/22_cca.htm , does it say that you specify padchar 0 with '0 in the control-string?

6:58:03 semz clhs 22.3

6:58:03 specbot Formatted Output: http://www.lispworks.com/reference/HyperSpec/Body/22_c.htm

6:58:08 semz "Prefix parameters are notated as signed (sign is optional) decimal numbers, or as a single-quote followed by a character."

7:00:44 ck_ thank you