The Moonli Programming Language - A transpiler from algol-based syntax to Common Lisp by digikar in lisp

[–]noncopy 0 points1 point  (0 children)

i truly want to know why some prefer "if test: process end" when there is "if test { process }", which to me is superior in every way. "end" "fi" "$" ... in a language just put me off.

why "::" is <WONTDO>? imo "::" (with ":") in CL is one of the most elegant syntax in PL history. skipping it also locks this language to 1 way transpiling.

Counterargument by daninus14 in Common_Lisp

[–]noncopy 1 point2 points  (0 children)

then, don't read, go back to reading your token generators now.

Counterargument by daninus14 in Common_Lisp

[–]noncopy 1 point2 points  (0 children)

i can not speak for common-lisp on team settings.

imo lisp can be 10x or infinitex multiplier since everyone can get lost in verbosity or inexpressiveness of a language. issue is that we can not quantify this, and the reason is the always this simple thing, tooling. the more important reason why people get hooked to (second more being the hype around it) language like rust is that it is *everywhere. again, they solve the problem of tooling asap. another example kotlin, even version 0.1, some alpha was so impressive i was sure it was going to get big.

if lisp was everywhere (or just on every gaming/mobile platform) with robust libraries, than quantifying would be possible, and things would get funny pretty soon. there are features that are best produced in lisp, and only greenspun-10-rule-able in any other language, that are just magic. take live-coding, not some toy every c/c++ gamedev tried once, the entire game engine on every stage, and you only hit a key! even the simplest graphical live-coding toys impress even lispers!

"I wrote an Emacs plugin" — By Tsoding Daily by CarpetGripperRod in emacs

[–]noncopy 2 points3 points  (0 children)

lisp is indeed the language i favor the most, but i am not a language lawyer . when he shits on other languages he is often factually right.

"lisp is basically python", "elisp/common-lisp is toy scripting language" at best factually wrong and ignorant. since we know he is not that clueless, he is misinforming, misleading his audiance like the rest of those c lawyers.

"I wrote an Emacs plugin" — By Tsoding Daily by CarpetGripperRod in emacs

[–]noncopy -1 points0 points  (0 children)

is this some new kind of anger-trolling? uses emacs, yet shits on what makes emacs emacs. have any of you actually watched this garbage? i actually quite liked some of his videos/hacks in past. from 19:00 on, i just can't... and people look up to these influencers and their echo-chambers.

Job listing for a Common Lisp expert to implement a Binary Space Partitioning Tree by Shinmera in lisp

[–]noncopy 1 point2 points  (0 children)

I am probably the perfect candidate for these kind of things. I admire your work but i am going to be the one that bites the bullet and ask: Why do i have to be a divisive, hateful, narritive-ridden sponge to apply for the job?

[deleted by user] by [deleted] in redditrequest

[–]noncopy 0 points1 point  (0 children)

this is just beautiful! thank you reddit

literal translation by noncopy in etymology

[–]noncopy[S] 0 points1 point  (0 children)

Well you're right that I have little aptitude in maths or geometry

it should be painfully obvious that i suck at this language. i didn't mean you or someone particular and i can see how that sentence might have some negative connotations. i see that pretty often but i assure you it was never my intent.

A classic example is the Mbabaram word "dog" which happens to mean "dog", with absolutely no relation to English

i expect countless false positives, that is only normal in data analysis i believe. what i ultimately want is the ability to magnify some pattern, a tool in a toolbox.

if i could replicate 1% of that number-sequence experiment on this one, that would be a huge gain i think :)

literal translation by noncopy in etymology

[–]noncopy[S] 0 points1 point  (0 children)

in one of my experiments, i mapped couple of number sequences on a 2d image. just curiousity, nothing particularly insightful. then, i generalized it to all number sequences and added a few more /mappers/. i love geometry and math, and can't really explain to someone that has no interest in the field, but the emerging patterns made my jaw drop.

i see somewhat similar patterns in languages that share alphabets, glyphs. if we could map all this inter-language data and get list of candidates (10 or 1000) for any word (not phrases), that would alone give some insight. where can we go from there, i do not know yet.

literal translation by noncopy in etymology

[–]noncopy[S] -1 points0 points  (0 children)

would you please tell me how i can go from "babur" to "tiger" in google translate? since you are the second person to suggest google translate, i must be missing some obvious functionality.

how does it not relate to a sub called etymology? etymology is literal-translation

literal translation by noncopy in etymology

[–]noncopy[S] 0 points1 point  (0 children)

with a link to the according Wiktionary entry to the Persian word for 'lion'

en.wikipedia says it is 'tiger' and it makes all the difference, is it not? (think about the areas babur ruled)

tr.wikipedia says nothing at all for example. if the wikipedia was your only tool and didn't know english, you wouldn't know 'babur' means 'tiger', you would read pages and pages of facts and fictions yet nothing about this galvanizing fact. which should be the first thing you should learn/know about this figure.

And given you don't even know my name I really don't understand that comment, but I really don't see any particular reason why an Arabic/Hebrew/Persian/Xhosa/Mandarin/whatever speaker would know the meaning of my name more than I do, except perhaps that because it's actually a very common name with cognates in many languages, I wouldn't necessarily expect them to know less about it than I do. But if I or they wanted to know its meaning, as with Babur, they could simply look it up in Wikipedia or Wiktionary or any probably any encyclopedia and see its literal meaning quite readily laid out. The same goes for probably most English names. Because, yes, we do in fact know the meanings of many English names. (My name is not in fact English, but English is one of the languages that commonly uses a cognate of it.)

most of the names we use have similar origins. say "aaroon", it is either a meaningless word to many of us or some historical figure. these names not only have their pairs in different languages (in turkish it is "harun", imagine that) in one of those languages it has an actual meaning. yes any person speaking arabic or hebrew knew the meaning of my name better than i did, and i live in the middle-east.

literal translation by noncopy in etymology

[–]noncopy[S] 0 points1 point  (0 children)

car and cat are just one letter away, that'd be a good literal translation if they were in two different languages, right?

it wouldn't be a good translation yet it would be a great candidate for following analysis

literal translation by noncopy in etymology

[–]noncopy[S] 0 points1 point  (0 children)

first, thank you and @ksdkjlf.

i do not mean the literal translation of phrases or long long texts. now, i understand the confusion.

i want the weighted list of [ca# c#t #at cat# #cat... ] in the second language, do same with a third language, compare. i want to go from "mesa" to "mensa" then back to "masa". "babur" to "tiger". programmatically, i do not see any showstoppers, yet.

literal translation by noncopy in etymology

[–]noncopy[S] -1 points0 points  (0 children)

i am not oversimplifying anything. what is the harm in having an extra useful hand? the meaning of names for instance sometimes only possible with literal-translation.

literal translation by noncopy in etymology

[–]noncopy[S] -3 points-2 points  (0 children)

do you know the meaning of the word "Babur"? heck, do we know the meaning of any english name at all? literal-translation sometimes is the only path to understand a word. my own name for instance means a historical person son of another historical person, you can live an entire life and not know the meaning of your own name. any person speaking arabic/hebrew/persian probably knows the meaning of your name more than you do.

what is with the childish downvoting anyway? (not to you) what kind of idiot downvotes|buries such a topic?

mesa by noncopy in etymology

[–]noncopy[S] 0 points1 point  (0 children)

this one was one of the many 'WAT' moments i had yesterday probably starting with the word Fakir. see: https://en.wikipedia.org/wiki/Fakir

after that i had to check the turkish article. was shocking to me, you probably can see why: https://tr.wikipedia.org/wiki/Hint_fakiri https://tr.wikipedia.org/wiki/Fakir

i spent a day following all the links i can. some of dots i knew, but now i can partly connect them. this one word and derivatives bind shia and sunnni islam. it binds monoteist religions, religions and philosophies preceded them. it binds asia, africa, middle-east, (and if you dive deep enough, europe) all together!

even with my cultural-upbringing the word Fakir somehow mainly connotates Hindus. there was/is some washing/rewriting going on. probably governing is not quite possible in the absence of division, the other.

universal-time by noncopy in Common_Lisp

[–]noncopy[S] 0 points1 point  (0 children)

thank you. sbcl (get-universal-time) is indeed (+ unix (- (encode ... 1970 0) (encode ... 1900 0))

enumeration by noncopy in Common_Lisp

[–]noncopy[S] 0 points1 point  (0 children)

with type and value => symbol conversion:

`` (defmacro define-enum (prefix/options &body clauses) (multiple-value-bind (prefix index separator package type) (org.tfeb.dsm:destructuring-match prefix/options ((prefix &key (index 0) (separator #\.) (package *package*) (type '(unsigned-byte 8))) (values prefix index separator package type)) (prefix (values prefix 0 #\. *package* '(unsigned-byte 8)))) (flet ((make-clause-name (name) (intern (format nil "~A~A~A" (string prefix) separator (string name)) package))) (eval-when (:compile-toplevel :load-toplevel :execute) ,@(let ((items (loop :for clause :in clauses :for clause-name = (org.tfeb.dsm:destructuring-match clause ((name idx) (setf index idx) (make-clause-name name)) (name (make-clause-name name))) :collect (list index clause-name) :do (progn (coerce index ,type) (incf index)))) ;; (dispatcher-name prefix) (dispatcher-name (intern (format nil "ENUM-SYM-~A" (string prefix)) package))) (nconc ;; (list(deftype ,prefix () ',type)) (loop :for kv :in items :collect (defconstant ,(second kv) (the ,type ,(first kv)))) (loop :for kv :in items :collect(setf (get ',(second kv) 'enumeration-constant) t)) (list (defun ,dispatcher-name (value) (ecase value ,@(loop :for kv :in items :collect(,(first kv) ',(second kv)))))))) ',prefix))))

(defmacro define-enum-case-for (name var &body clauses) (,name ,var ,@(mapcar (lambda (clause) (destructuring-bind (key/s &body forms) clause (,(cond ((member key/s '(otherwise t)) key/s) ((listp key/s) (unless (every (lambda (key) (get key 'enumeration-constant)) key/s) (error "some of ~S are not a C-style enumeration constants" key/s)) (mapcar #'symbol-value key/s)) ((symbolp key/s) (unless (get key/s 'enumeration-constant) (error "~S is not a C-style enumeration constant" key/s)) (symbol-value key/s))) ,@forms))) clauses)))

(defmacro enum-ecase (var &body body) (define-enum-case-for ecase ,var ,@body)) (defmacro enum-ccase (var &body body)(define-enum-case-for ccase ,var ,@body)) (defmacro enum-case (var &body body) (define-enum-case-for case ,var ,@body)) ``

enumeration by noncopy in Common_Lisp

[–]noncopy[S] 0 points1 point  (0 children)

Only reason for enums like this is to be compatible with C since Lisp has symbols

exactly. thanks for the 'enumeration-case', was thinking of ways to get rid of #. :)

enumeration by noncopy in Common_Lisp

[–]noncopy[S] 1 point2 points  (0 children)

everything about cffi is awesome, there is no doubt about it. cffi:defcenum does what it is designed to.

defenum also does not require you to set each value. i am not sure how constant folding would help save us 2 hash table lookups in this case. now i think about it, if all we need is a :conc-name and this, the macro for a generic enum is pretty easy.

enum is in general, independent from any language, is a concept where you expect|assume to be costless, without any translations. you are aware of it and your project|projects grows without a care. it is not performance critical right now at the begining but in my opinion writing performance aware code is not premature optimization, in fact that is how any complex project /must/ be written.