Re: (*) -> 1

Re: (*) -> 1

[Jean Louis]

* Michael Heerdegen <michael_heerdegen@web.de> [2023-01-19 16:56]:
> I'm out.  Enough information has been presented to you to enable you to
> learn.  But I cannot learn for you, you must do it yourself.

I did not ask for outside information, only if it is useful in Lisp,
apart from funny jokes and sketching of program.

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: (*) -> 1

[Jean Louis]

* Tassilo Horn <tsdh@gnu.org> [2023-01-19 18:35]:
> Jean Louis <bugs@gnu.support> writes:
> 
> > You found examples I am searching, though you can't provide references
> > where (*) is useful.
> 
> Gosh, Jean, of course nobody would literally write (*) but (apply #'*
> ...), and you'll find occurrences in emacs:

That has been said that is not necessarily problem or reason. 

Did you see reference to PicoLisp?

--
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: (*) -> 1

[Tassilo Horn]

Jean Louis <bugs@gnu.support> writes:

>> Gosh, Jean, of course nobody would literally write (*) but (apply #'*
>> ...), and you'll find occurrences in emacs:
>
> That has been said that is not necessarily problem or reason. 

I don't understand that sentence.

> Did you see reference to PicoLisp?

Yes, and I think it's seriously wrong with

  : (+)
  -> NIL

where its docs say

  Returns the sum of all num arguments. When one of the arguments
  evaluates to NIL, it is returned immediately.

Well, in (+) there exists no argument evaluating to NIL and
mathematically, the sum of zero numbers is 0
(https://en.wikipedia.org/wiki/Empty_sum).  Same for the empty product
(*) which should be 1 (https://en.wikipedia.org/wiki/Empty_sum) but also
gives NIL in picolisp.

So why does it return NIL?  And why do you apparently consider that
useful?  And can something be useful even though it is incorrect?

Bye,
Tassilo

Re: (*) -> 1

[Jean Louis]

* Tassilo Horn <tsdh@gnu.org> [2023-01-20 12:12]:
> Jean Louis <bugs@gnu.support> writes:
> 
> >> Gosh, Jean, of course nobody would literally write (*) but (apply #'*
> >> ...), and you'll find occurrences in emacs:
> >
> > That has been said that is not necessarily problem or reason. 
> 
> I don't understand that sentence.
> 
> > Did you see reference to PicoLisp?
> 
> Yes, and I think it's seriously wrong with
> 
>   : (+)
>   -> NIL
> 
> where its docs say
> 
>   Returns the sum of all num arguments. When one of the arguments
>   evaluates to NIL, it is returned immediately.

For some reason PicoLisp is quite different than other Lisp. I have
asked author about it.

15:07 <jmarciano> may somebody experienced with PicoLisp tell me if
                  (*) returning NIL in PicoLisp is obstacle or
                  feature? It is because I am trying to find use of
                  the function in other Lisp where (*) ➜ 1,
                  however, apparently, the use for it does not
                  exist. I have found PicoLisp returning NIL on
                  empty (*)
15:08 <jmarciano> Was author of PicoLisp aware that other Lisp
                  return (*) ➜ 1 at time of making it? 
15:08 <jmarciano> And what was decision of author, reasoning, why
                  not to include it?
15:08 <abu[m]> Hi jmarciano! Well, I'm the author.
15:08 <jmarciano> Which reasoning I favor, as I rather like NIL
                  returned, rather than finding out where did I
                  miss to place the numbers.
15:09 <jmarciano> Nice to meet you. 
15:09 <abu[m]> It is a "feature" that NIL propagates through
               arithmetics
15:09 <jmarciano> How does it help instead of providing identity
                  elements?
15:09 <abu[m]> (*) especially was not contemplated though, it is a
               pretty useless call
15:10 <abu[m]> but (+ 3 NIL) -> NIL was desired
15:10 <jmarciano> and why?
15:11 <jmarciano> Were you aware at the time of authoring it, that
                  other Lisp was giving (*) ➜ 1 
15:11 <abu[m]> It is very convenient. I think I have hundreds of
               cases where I rely on getting NIL when not all
               argumets are ready (yet)
15:11 <abu[m]> very common in valuen from GUI
15:11 <abu[m]> A was not aware
15:11 <abu[m]> and never cared about other Lisps
15:12 <jmarciano> (*) ➜ 1, (+) ➜ 0, (-) ➜ 0, that is in Emacs Lisp
15:12 <abu[m]> Note that PicoLisp is very different from most Lisps
               anywad
15:12 <abu[m]> What is a call like (*) useful for?

As you see, author also asked naturally why is it useful.

> So why does it return NIL?  And why do you apparently consider that
> useful?  And can something be useful even though it is incorrect?

I find it right as with error raising or nil I can find what is
wrong. I would not like forgetting some arguments and getting (*) ➜ 1
when instead I had to write something like (* a b). Even this case is
rare I find error better, or NIL, as with NIL I can't to other
mathematical operations, I will get error:

(* nil 2) will not work, and that will help me put attention on
it. Similarly (* (*) 2) would raise error putting my attention that I
forgot some arguments, then I would correct and write (* (* a b) 2).

Something is maybe "correct" in somebody's opionion but have no
practical use. And question was not what somebody considers correct,
but what is the practical use of it.

There are X mathematical subjects that are not injected in Emacs Lisp
functions just to be discovered they exist for themselves only.

Functions should serve a purpose, not only representation purpose of
some mathematica subject.

Function `*' to me should serve purpose of multiplication, not
representation of set theory or identity elements, UNLESS those
identity elements are useful somewhere.

And I asked for case where it is useful.

There is so far none case found, apart from mathematical
representation for those people who like to talk about it.

--
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: (*) -> 1

[Tassilo Horn]

Jean Louis <bugs@gnu.support> writes:

>> Yes, and I think it's seriously wrong with
>> 
>>   : (+)
>>   -> NIL
>> 
>> where its docs say
>> 
>>   Returns the sum of all num arguments. When one of the arguments
>>   evaluates to NIL, it is returned immediately.
>
> For some reason PicoLisp is quite different than other Lisp. I have
> asked author about it.
>
> 15:09 <abu[m]> It is a "feature" that NIL propagates through
>                arithmetics

Well, but with (*) and (+), there is no single NIL involved!  And in
Elisp (+ nil), where actually a nil is involved, you get an error.

> 15:09 <jmarciano> How does it help instead of providing identity
>                   elements?
> 15:09 <abu[m]> (*) especially was not contemplated though, it is a
>                pretty useless call
> [...]
> 15:12 <abu[m]> What is a call like (*) useful for?
>
> As you see, author also asked naturally why is it useful.

So go and ask why he thinks (apply '+ ()) -> NIL is more useful than 0
given that the sum of the empty set of numbers _is_ 0.

>> So why does it return NIL?  And why do you apparently consider that
>> useful?  And can something be useful even though it is incorrect?
>
> I find it right as with error raising or nil I can find what is
> wrong.

It's good to signal an error when the expression is wrong as does Elisp
with

  (+ nil)
  (* 1 2 nil)
  (apply #'+ (list 1 nil 19))
  (+ 2 "i am not a number")

but when there is no nil or otherwise wrongly typed value involved,
there's nothing to signal.

Bye,
Tassilo

Re: (*) -> 1

[Jean Louis]

* Tassilo Horn <tsdh@gnu.org> [2023-01-20 16:14]:
> Jean Louis <bugs@gnu.support> writes:
> 
> >> Yes, and I think it's seriously wrong with
> >> 
> >>   : (+)
> >>   -> NIL
> >> 
> >> where its docs say
> >> 
> >>   Returns the sum of all num arguments. When one of the arguments
> >>   evaluates to NIL, it is returned immediately.
> >
> > For some reason PicoLisp is quite different than other Lisp. I have
> > asked author about it.
> >
> > 15:09 <abu[m]> It is a "feature" that NIL propagates through
> >                arithmetics
> 
> Well, but with (*) and (+), there is no single NIL involved!  And in
> Elisp (+ nil), where actually a nil is involved, you get an error.

What we can learn from PicoLisp is that there was no use for (*) ➜ 1
and that programs work, GUI applications and Android/Replicant work,
and there was no use of (*) ➜ 1 so far.

Similarly like author of PicoLisp finding use when (*) ➜ NIL, so I
would also find (very rare) use with errors. Even if NIL, I find use
as I will get error raised in combinations like (+ (*) (* 2 2)),
because (+ nil 4) would raise error.

> > 15:09 <jmarciano> How does it help instead of providing identity
> >                   elements?
> > 15:09 <abu[m]> (*) especially was not contemplated though, it is a
> >                pretty useless call
> > [...]
> > 15:12 <abu[m]> What is a call like (*) useful for?
> >
> > As you see, author also asked naturally why is it useful.
> 
> So go and ask why he thinks (apply '+ ()) -> NIL is more useful than 0
> given that the sum of the empty set of numbers _is_ 0.

I will ask.

But docstring does not speak of empty sets. You introduce "sets" where
there is not direct relation to it.

(+ &rest NUMBERS-OR-MARKERS)

Return sum of any number of arguments, which are numbers or
markers. Of course I get confused.

I ask A, but people say B. 
I ask A, but people say C.
I ask A, but people say D.

No answer about A. But there are many introductions of things not
relevant to function itself. 

I still believe that there is some actual practical use.

`apply' can be used with (apply '+ '(a b)) as why would you need in
apply for addition two arguments?

If list is with one argument, testing with `cadr' will be known,
otherwise, I use `car' instead of `apply'.

> >> So why does it return NIL?  And why do you apparently consider that
> >> useful?  And can something be useful even though it is incorrect?
> >
> > I find it right as with error raising or nil I can find what is
> > wrong.
> 
> It's good to signal an error when the expression is wrong as does Elisp
> with
> 
>   (+ nil)
>   (* 1 2 nil)
>   (apply #'+ (list 1 nil 19))
>   (+ 2 "i am not a number")

That is exactly my point, what you see useful there, I see too. Making
it less error prone with useless default identity elements hides the
real event preceding the operation.

--
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: (*) -> 1

[Tassilo Horn]

Jean Louis <bugs@gnu.support> writes:

>> >> Yes, and I think it's seriously wrong with
>> >> 
>> >>   : (+)
>> >>   -> NIL
>> >> 
>> >> where its docs say
>> >> 
>> >>   Returns the sum of all num arguments. When one of the arguments
>> >>   evaluates to NIL, it is returned immediately.
>> >
>> > For some reason PicoLisp is quite different than other Lisp. I have
>> > asked author about it.
>> >
>> > 15:09 <abu[m]> It is a "feature" that NIL propagates through
>> >                arithmetics
>> 
>> Well, but with (*) and (+), there is no single NIL involved!  And in
>> Elisp (+ nil), where actually a nil is involved, you get an error.
>
> What we can learn from PicoLisp is that there was no use for (*) ➜ 1
> and that programs work, GUI applications and Android/Replicant work,
> and there was no use of (*) ➜ 1 so far.

You are jumping to conclusions.  If someone needed a mathematically
sound product in PicoLisp, they might have defined it as

  (de product @
    (if (not (args))
       1
       (* (next) (apply 'product (rest)))))

[Not sure if that's correct, I've just skimmed the docs.]

>> > 15:09 <jmarciano> How does it help instead of providing identity
>> >                   elements?
>> > 15:09 <abu[m]> (*) especially was not contemplated though, it is a
>> >                pretty useless call
>> > [...]
>> > 15:12 <abu[m]> What is a call like (*) useful for?
>> >
>> > As you see, author also asked naturally why is it useful.
>> 
>> So go and ask why he thinks (apply '+ ()) -> NIL is more useful than
>> 0 given that the sum of the empty set of numbers _is_ 0.
>
> I will ask.

I'm interested in the reply.  I feel it might be just an oversight which
is hard or impossible to fix now.

> But docstring does not speak of empty sets.

Yes, so the docstring is at least incomplete because it doesn't include
the completely valid case where no args are given.

> You introduce "sets" where there is not direct relation to it.

17 is an element of the set of integers, isn't it?

> (+ &rest NUMBERS-OR-MARKERS)
>
> Return sum of any number of arguments, which are numbers or
> markers. Of course I get confused.

Why?  At least when ignoring markers which happen to have an integer
representation which is an implementation detail.

> `apply' can be used with (apply '+ '(a b)) as why would you need in
> apply for addition two arguments?

You don't but you can use it if (a b) is not a literal list but a
variable, i.e., use (+ a b) or (apply #'+ my-list-of-numbers).

>> It's good to signal an error when the expression is wrong as does
>> Elisp with
>> 
>>   (+ nil)
>>   (* 1 2 nil)
>>   (apply #'+ (list 1 nil 19))
>>   (+ 2 "i am not a number")
>
> That is exactly my point, what you see useful there, I see too.

Good! :-)

> Making it less error prone with useless default identity elements
> hides the real event preceding the operation.

Let's agree to disagree then.  In my book, it is useful to have
mathematically sound behavior by default.  If you have a reason to
handle some edge-cases differently in some application (which is totally
possible!), then define your own function which does what you wish.

Bye,
Tassilo

Re: (*) -> 1

[Emanuel Berg]

Tassilo Horn wrote:

> In my book, it is useful to have mathematically sound
> behavior by default. If you have a reason to handle some
> edge-cases differently in some application (which is totally
> possible!), then define your own function which does what
> you wish.

Your book? Actually I think a lot of people have it.

-- 
underground experts united
https://dataswamp.org/~incal

Re: (*) -> 1

[Jean Louis]

* Emanuel Berg <incal@dataswamp.org> [2023-01-22 08:55]:
> Tassilo Horn wrote:
> 
> > In my book, it is useful to have mathematically sound
> > behavior by default. If you have a reason to handle some
> > edge-cases differently in some application (which is totally
> > possible!), then define your own function which does what
> > you wish.
> 
> Your book? Actually I think a lot of people have it.

Question is resolved.

I have re-defined (*) ➜ 1 to give me at least something useful:

(defun * ()
  "sex")

(*) ➜ "sex"


--
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: (*) -> 1

[Emanuel Berg]

Jean Louis wrote:

>>> In my book, it is useful to have mathematically sound
>>> behavior by default. If you have a reason to handle some
>>> edge-cases differently in some application (which is
>>> totally possible!), then define your own function which
>>> does what you wish.
>> 
>> Your book? Actually I think a lot of people have it.
>
> Question is resolved.
>
> I have re-defined (*) → 1 to give me at least something
> useful:
>
> (defun * ()
>   "sex")
>
> (*) → "sex"

The No. 1 thing to some people ...

-- 
underground experts united
https://dataswamp.org/~incal

RE: [External] : Re: (*) -> 1

[Drew Adams]

> > (*) → "sex"
> The No. 1 thing to some people ...

We pretty much _all_ depend on it.

Until we start cloning people or we
develop human parthenogeny.

(There's in vitro fertilization, but
you still need two sexes there.)

Oh, sorry, didn't mean to leave out
the miracle of virgin birth.

Miracles aside, sex is pretty helpful.

Re: (*) -> 1

[Akib Azmain Turja]

[-- Attachment #1: Type: text/plain, Size: 6158 bytes --]

Emanuel Berg <incal@dataswamp.org> writes:

> Tassilo Horn wrote:
>
>> In my book, it is useful to have mathematically sound
>> behavior by default. If you have a reason to handle some
>> edge-cases differently in some application (which is totally
>> possible!), then define your own function which does what
>> you wish.
>
> Your book? Actually I think a lot of people have it.

I just made a language named "Emacs Lisp Fuck", and here's the
"Hello, World!" program:

#+begin_src emacs-lisp
(string
 (+(*)(+)(*)(*)(*)(*)(+)(+)(+)(+)(*)(*)(*)(+)(+)(*)(*)(*)(*)(+)(*)(*)
   (*)(*)(*)(*)(*)(+)(*)(+)(*)(*)(*)(*)(+)(+)(*)(*)(+)(*)(+)(*)(*)(*)
   (*)(+)(+)(+)(*)(+)(*)(*)(+)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(+)
   (*)(*)(*)(+)(+)(*)(*)(+)(+)(+)(*)(+)(+)(+)(+)(*)(*)(+)(*)(+)(*)(*)
   (+)(*)(+)(+)(*)(+)(*)(+)(*)(*)(*)(+)(*)(+)(+)(*)(+)(+)(+)(+)(+)(+)
   (*)(+)(+)(*)(*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(+)(+)(+))
 (+(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(+)(*)(*)(*)(*)(+)(*)(*)(+)(*)
   (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(+)(*)(*)(+)(*)
   (*)(*)(+)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)
   (*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(+)(+)(*)(+)(*)(*)(+)(*)(+)(*)
   (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)
   (*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(+)(*))
 (+(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)
   (*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)
   (*)(*)(*)(*)(*)(+)(+)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(+)(+)(*)(*)(*)
   (*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)
   (*)(*)(+)(*)(+)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
   (*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))
 (+(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)
   (*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)
   (*)(*)(*)(*)(*)(+)(+)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(+)(+)(*)(*)(*)
   (*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)
   (*)(*)(+)(*)(+)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
   (*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))
 (+(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(*)
   (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
   (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)
   (*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(+)(+)(*)(*)(*)(*)(*)
   (*)(*)(+)(+)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(+)(*)(+)(*)(*)
   (*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(+)(*)(*))
 (+(+)(+)(+)(+)(+)(*)(+)(+)(*)(*)(+)(+)(*)(+)(+)(+)(+)(*)(+)(+)(*)(*)
   (*)(+)(+)(+)(*)(+)(+)(*)(+)(*)(+)(*)(*)(+)(+)(*)(+)(+)(+)(*)(*)(+)
   (+)(*)(*)(*)(*)(+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(*)(+)(+)(+)
   (*)(+)(*)(*)(+)(+)(+)(+)(+)(*)(+)(+)(*)(+)(+)(+)(+)(+)(*)(*)(+)(+)
   (+)(+)(*)(+)(*)(+)(+)(+)(+)(*)(*)(+)(+)(*)(+)(*)(*)(+)(+)(+)(*)(+)
   (*)(+)(+)(+)(+)(*)(*)(+)(+)(+)(+)(*)(+)(*)(+)(*)(*)(+))
 (+(+)(*)(+)(*)(+)(+)(+)(+)(+)(*)(*)(*)(+)(*)(+)(*)(+)(*)(+)(*)(+)(+)
   (+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(*)(*)(+)(+)(+)
   (*)(*)(+)(+)(+)(+)(+)(*)(+)(*)(+)(*)(*)(*)(+)(+)(+)(+)(+)(+)(+)(*)
   (+)(+)(*)(*)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)
   (+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(*)(+)(+)(+)(+)(+)(+)(*)(*)(+)(*)
   (+)(*)(*)(*)(+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(*))
 (+(*)(+)(*)(+)(+)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(+)(+)(*)(+)(+)(+)
   (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(+)(+)(+)(*)(*)(*)(*)(+)(*)(*)(*)
   (*)(*)(*)(*)(*)(*)(+)(+)(*)(+)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(+)(*)
   (+)(+)(*)(*)(*)(+)(+)(*)(*)(*)(+)(+)(+)(+)(*)(*)(*)(+)(+)(+)(+)(*)
   (*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(+)(+)(*)(+)(*)(*)(*)(+)(*)(*)
   (*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*))
 (+(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(*)
   (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
   (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)
   (*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(+)(+)(*)(*)(*)(*)(*)
   (*)(*)(+)(+)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(+)(*)(+)(*)(*)
   (*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(+)(*)(*))
 (+(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)
   (*)(*)(*)(+)(+)(+)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)
   (*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(+)
   (*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
   (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
   (*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))
 (+(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)
   (*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)
   (*)(*)(*)(*)(*)(+)(+)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(+)(+)(*)(*)(*)
   (*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)
   (*)(*)(+)(*)(+)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
   (*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))
 (+(+)(*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)
   (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(+)(*)(*)(*)
   (*)(*)(*)(*)(+)(*)(*)(+)(*)(*)(*)(+)(*)(*)(*)(+)(+)(*)(*)(*)(*)(*)
   (*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(+)(*)(*)(+)(*)
   (*)(*)(+)(*)(+)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(+)(*)
   (*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(+)(+)(*)(*)(+)(*))
 (+(+)(+)(*)(+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(*)(+)(*)(*)(*)(+)
   (+)(*)(+)(+)(+)(+)(+)(*)(+)(*)(+)(*)(*)(+)(+)(+)(+)(+)(*)(+)(+)(+)
   (+)(+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(*)(*)(+)(+)(*)(+)(+)(+)
   (+)(+)(+)(+)(*)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(*)(*)(+)
   (+)(*)(+)(+)(*)(+)(*)(+)(+)(*)(+)(+)(+)(*)(*)(*)(+)(+)(*)(+)(+)(+)
   (+)(*)(+)(+)(*)(*)(+)(+)(+)(+)(*)(+)(+)(*)(+)(+)(*)(+)))
#+end_src

Even I don't know how this works!

-- 
Akib Azmain Turja, GPG key: 70018CE5819F17A3BBA666AFE74F0EFA922AE7F5
Fediverse: akib@hostux.social
Codeberg: akib
emailselfdefense.fsf.org | "Nothing can be secure without encryption."

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 832 bytes --]

Re: (*) -> 1

[Emanuel Berg]

Akib Azmain Turja wrote:

>>> In my book, it is useful to have mathematically sound
>>> behavior by default. If you have a reason to handle some
>>> edge-cases differently in some application (which is
>>> totally possible!), then define your own function which
>>> does what you wish.
>>
>> Your book? Actually I think a lot of people have it.
>
> I just made a language named "Emacs Lisp Fuck", and here's
> the "Hello, World!" program:
>
> (string
>  (+(*)(+)(*)(*)(*)(*)(+)(+)(+)(+)(*)(*)(*)(+)(+)(*)(*)(*)(*)(+)(*)(*)
>    (*)(*)(*)(*)(*)(+)(*)(+)(*)(*)(*)(*)(+)(+)(*)(*)(+)(*)(+)(*)(*)(*)
>    (*)(+)(+)(+)(*)(+)(*)(*)(+)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(+)
>    (*)(*)(*)(+)(+)(*)(*)(+)(+)(+)(*)(+)(+)(+)(+)(*)(*)(+)(*)(+)(*)(*)
>    (+)(*)(+)(+)(*)(+)(*)(+)(*)(*)(*)(+)(*)(+)(+)(*)(+)(+)(+)(+)(+)(+)
>    (*)(+)(+)(*)(*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(+)(+)(+))
>  (+(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(+)(*)(*)(*)(*)(+)(*)(*)(+)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(+)(*)(*)(+)(*)
>    (*)(*)(+)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)
>    (*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(+)(+)(*)(+)(*)(*)(+)(*)(+)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)
>    (*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(+)(*))
>  (+(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)
>    (*)(*)(*)(*)(*)(+)(+)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(+)(+)(*)(*)(*)
>    (*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(+)(*)(+)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))
>  (+(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)
>    (*)(*)(*)(*)(*)(+)(+)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(+)(+)(*)(*)(*)
>    (*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(+)(*)(+)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))
>  (+(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)
>    (*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(+)(+)(*)(*)(*)(*)(*)
>    (*)(*)(+)(+)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(+)(*)(+)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(+)(*)(*))
>  (+(+)(+)(+)(+)(+)(*)(+)(+)(*)(*)(+)(+)(*)(+)(+)(+)(+)(*)(+)(+)(*)(*)
>    (*)(+)(+)(+)(*)(+)(+)(*)(+)(*)(+)(*)(*)(+)(+)(*)(+)(+)(+)(*)(*)(+)
>    (+)(*)(*)(*)(*)(+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(*)(+)(+)(+)
>    (*)(+)(*)(*)(+)(+)(+)(+)(+)(*)(+)(+)(*)(+)(+)(+)(+)(+)(*)(*)(+)(+)
>    (+)(+)(*)(+)(*)(+)(+)(+)(+)(*)(*)(+)(+)(*)(+)(*)(*)(+)(+)(+)(*)(+)
>    (*)(+)(+)(+)(+)(*)(*)(+)(+)(+)(+)(*)(+)(*)(+)(*)(*)(+))
>  (+(+)(*)(+)(*)(+)(+)(+)(+)(+)(*)(*)(*)(+)(*)(+)(*)(+)(*)(+)(*)(+)(+)
>    (+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(*)(*)(+)(+)(+)
>    (*)(*)(+)(+)(+)(+)(+)(*)(+)(*)(+)(*)(*)(*)(+)(+)(+)(+)(+)(+)(+)(*)
>    (+)(+)(*)(*)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)
>    (+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(*)(+)(+)(+)(+)(+)(+)(*)(*)(+)(*)
>    (+)(*)(*)(*)(+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(*))
>  (+(*)(+)(*)(+)(+)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(+)(+)(*)(+)(+)(+)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(+)(+)(+)(*)(*)(*)(*)(+)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(+)(+)(*)(+)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(+)(*)
>    (+)(+)(*)(*)(*)(+)(+)(*)(*)(*)(+)(+)(+)(+)(*)(*)(*)(+)(+)(+)(+)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(+)(+)(*)(+)(*)(*)(*)(+)(*)(*)
>    (*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*))
>  (+(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)
>    (*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(+)(+)(*)(*)(*)(*)(*)
>    (*)(*)(+)(+)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(+)(*)(+)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(+)(*)(*))
>  (+(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(+)(+)(+)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(+)
>    (*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))
>  (+(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)
>    (*)(*)(*)(*)(*)(+)(+)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(+)(+)(*)(*)(*)
>    (*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(+)(*)(+)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))
>  (+(+)(*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(+)(*)(*)(*)
>    (*)(*)(*)(*)(+)(*)(*)(+)(*)(*)(*)(+)(*)(*)(*)(+)(+)(*)(*)(*)(*)(*)
>    (*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(+)(*)(*)(+)(*)
>    (*)(*)(+)(*)(+)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(+)(*)
>    (*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(+)(+)(*)(*)(+)(*))
>  (+(+)(+)(*)(+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(*)(+)(*)(*)(*)(+)
>    (+)(*)(+)(+)(+)(+)(+)(*)(+)(*)(+)(*)(*)(+)(+)(+)(+)(+)(*)(+)(+)(+)
>    (+)(+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(*)(*)(+)(+)(*)(+)(+)(+)
>    (+)(+)(+)(+)(*)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(*)(*)(+)
>    (+)(*)(+)(+)(*)(+)(*)(+)(+)(*)(+)(+)(+)(*)(*)(*)(+)(+)(*)(+)(+)(+)
>    (+)(*)(+)(+)(*)(*)(+)(+)(+)(+)(*)(+)(+)(*)(+)(+)(*)(+)))
>
> Even I don't know how this works!

Haha :)

-- 
underground experts united
https://dataswamp.org/~incal

Re: (*) -> 1

[Jean Louis]

* Akib Azmain Turja <akib@disroot.org> [2023-01-22 17:37]:
> I just made a language named "Emacs Lisp Fuck", and here's the
> "Hello, World!" program:

I knew it, as I already got it (ouch) on the mailing list.

> #+begin_src emacs-lisp
> (string
>  (+(*)(+)(*)(*)(*)(*)(+)(+)(+)(+)(*)(*)(*)(+)(+)(*)(*)(*)(*)(+)(*)(*)
>    (*)(*)(*)(*)(*)(+)(*)(+)(*)(*)(*)(*)(+)(+)(*)(*)(+)(*)(+)(*)(*)(*)
>    (*)(+)(+)(+)(*)(+)(*)(*)(+)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(+)
>    (*)(*)(*)(+)(+)(*)(*)(+)(+)(+)(*)(+)(+)(+)(+)(*)(*)(+)(*)(+)(*)(*)
>    (+)(*)(+)(+)(*)(+)(*)(+)(*)(*)(*)(+)(*)(+)(+)(*)(+)(+)(+)(+)(+)(+)
>    (*)(+)(+)(*)(*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(+)(+)(+))
>  (+(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(+)(*)(*)(*)(*)(+)(*)(*)(+)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(+)(*)(*)(+)(*)
>    (*)(*)(+)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)
>    (*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(+)(+)(*)(+)(*)(*)(+)(*)(+)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)
>    (*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(+)(*))
>  (+(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)
>    (*)(*)(*)(*)(*)(+)(+)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(+)(+)(*)(*)(*)
>    (*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(+)(*)(+)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))
>  (+(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)
>    (*)(*)(*)(*)(*)(+)(+)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(+)(+)(*)(*)(*)
>    (*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(+)(*)(+)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))
>  (+(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)
>    (*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(+)(+)(*)(*)(*)(*)(*)
>    (*)(*)(+)(+)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(+)(*)(+)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(+)(*)(*))
>  (+(+)(+)(+)(+)(+)(*)(+)(+)(*)(*)(+)(+)(*)(+)(+)(+)(+)(*)(+)(+)(*)(*)
>    (*)(+)(+)(+)(*)(+)(+)(*)(+)(*)(+)(*)(*)(+)(+)(*)(+)(+)(+)(*)(*)(+)
>    (+)(*)(*)(*)(*)(+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(*)(+)(+)(+)
>    (*)(+)(*)(*)(+)(+)(+)(+)(+)(*)(+)(+)(*)(+)(+)(+)(+)(+)(*)(*)(+)(+)
>    (+)(+)(*)(+)(*)(+)(+)(+)(+)(*)(*)(+)(+)(*)(+)(*)(*)(+)(+)(+)(*)(+)
>    (*)(+)(+)(+)(+)(*)(*)(+)(+)(+)(+)(*)(+)(*)(+)(*)(*)(+))
>  (+(+)(*)(+)(*)(+)(+)(+)(+)(+)(*)(*)(*)(+)(*)(+)(*)(+)(*)(+)(*)(+)(+)
>    (+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(*)(*)(+)(+)(+)
>    (*)(*)(+)(+)(+)(+)(+)(*)(+)(*)(+)(*)(*)(*)(+)(+)(+)(+)(+)(+)(+)(*)
>    (+)(+)(*)(*)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)
>    (+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(*)(+)(+)(+)(+)(+)(+)(*)(*)(+)(*)
>    (+)(*)(*)(*)(+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(*))
>  (+(*)(+)(*)(+)(+)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(+)(+)(*)(+)(+)(+)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(+)(+)(+)(*)(*)(*)(*)(+)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(+)(+)(*)(+)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(+)(*)
>    (+)(+)(*)(*)(*)(+)(+)(*)(*)(*)(+)(+)(+)(+)(*)(*)(*)(+)(+)(+)(+)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(+)(+)(*)(+)(*)(*)(*)(+)(*)(*)
>    (*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*))
>  (+(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)
>    (*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(+)(+)(*)(*)(*)(*)(*)
>    (*)(*)(+)(+)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(+)(*)(+)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(+)(*)(*))
>  (+(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(+)(+)(+)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(+)
>    (*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))
>  (+(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)
>    (*)(*)(*)(*)(*)(+)(+)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(+)(+)(*)(*)(*)
>    (*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(+)(*)(+)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)
>    (*)(*)(*)(*)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))
>  (+(+)(*)(*)(*)(+)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)
>    (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(+)(+)(*)(*)(*)
>    (*)(*)(*)(*)(+)(*)(*)(+)(*)(*)(*)(+)(*)(*)(*)(+)(+)(*)(*)(*)(*)(*)
>    (*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(*)(+)(*)(+)(*)(*)(+)(*)
>    (*)(*)(+)(*)(+)(*)(+)(*)(*)(*)(+)(*)(*)(*)(*)(*)(*)(+)(*)(*)(+)(*)
>    (*)(*)(*)(*)(*)(+)(*)(*)(*)(+)(*)(*)(+)(+)(*)(*)(+)(*))
>  (+(+)(+)(*)(+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(*)(+)(*)(*)(*)(+)
>    (+)(*)(+)(+)(+)(+)(+)(*)(+)(*)(+)(*)(*)(+)(+)(+)(+)(+)(*)(+)(+)(+)
>    (+)(+)(+)(+)(+)(+)(+)(+)(+)(*)(+)(+)(+)(+)(*)(*)(+)(+)(*)(+)(+)(+)
>    (+)(+)(+)(+)(*)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(+)(*)(*)(+)
>    (+)(*)(+)(+)(*)(+)(*)(+)(+)(*)(+)(+)(+)(*)(*)(*)(+)(+)(*)(+)(+)(+)
>    (+)(*)(+)(+)(*)(*)(+)(+)(+)(+)(*)(+)(+)(*)(+)(+)(*)(+)))
> #+end_src
> 
> Even I don't know how this works!

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: (*) -> 1

[Jean Louis]

* Akib Azmain Turja <akib@disroot.org> [2023-01-22 17:37]:
> I just made a language named "Emacs Lisp Fuck", and here's the
> "Hello, World!" program:

It needs a package.

(defun elbf-char (n)
  (concat "(+ " (string-replace "*" "(*)" (make-string n ?*)) ")"))

(defun elbf-string (string)
  (let ((list (string-to-list string)))
    (with-temp-buffer
      (insert "(string ")
      (while list
	(insert (elbf-char (pop list))))
      (insert ")")
      (buffer-string))))

(elbf-string "Hello") ➜ (string (+ (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))(+ (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))(+ (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))(+ (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))(+ (*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*))) ➜ "Hello"

  
-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: (*) -> 1

[Emanuel Berg]

Jean Louis wrote:

> (defun elbf-char (n)
>   (concat "(+ " (string-replace "*" "(*)" (make-string n ?*)) ")"))
>
> (defun elbf-string (string)
>   (let ((list (string-to-list string)))
>     (with-temp-buffer
>       (insert "(string ")
>       (while list
> 	(insert (elbf-char (pop list))))
>       (insert ")")
>       (buffer-string))))

Not bad!

Only: Hard coding the same data several times -> court martial.

But it's not like there is real punishment or anything ...

-- 
underground experts united
https://dataswamp.org/~incal

Re: [External] : Re: (*) -> 1

[Jean Louis]

* Drew Adams <drew.adams@oracle.com> [2023-01-19 20:47]:
> > I'm out.  Enough information has been
> > presented to you to enable you to learn.
> > But I cannot learn for you, you must do
> > it yourself.
> > Michael.
> 
> Bingo.  Ditto.  Shoulda just considered it
> as trolling perhaps.  In any case, shoulda 
> stopped trying to help long ago.  Gave the 
> benefit of the doubt; wasted time helping.
> Maybe Dunning-Kruger?  Whatever.

My question was pretty clear from beginning. I did not ask for
theories, I was asking for for practical usage example in Lisp.

If you challenge me to use profanities, I can do that better than you.

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: (*) -> 1

[Jean Louis]

* Óscar Fuentes <ofv@wanadoo.es> [2023-01-18 17:09]:
> Sure^2. I was talking about _why_ (*) and (* a) are supported in Elisp.
> Once the language designer chose to support those expressions and
> decided that they must return a number (instead of something else like a
> partially applied function) the value they shall return comes from the
> properties of the underlying operation, of course.

OK and I understood that somebody decided to include that.

Why did they decide to include it?

Do you think it is only for `apply' reasons?

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/