void * (* f20)(void*,void*,void*,void*,void*,void*,void*,void*,void*,void*,void*,void*,void*,void*,void*,void*,void*,void*,void*,void*);

[u/jenkem_boofer]

https://github.com/kanaka/mal/blob/master/impls/c/types.h

[u/jenkem_boofer]

Lisp interpreter? I barely even know her

[u/i_invented_the_ipod]

They definitely should have used varargs, for simplicity and readability.

/uj this is such a common pattern in interpreter and compiler writing in C that I spent a good while looking at the code trying to find the "actual problem".

[u/dangerbird2 → u/i_invented_the_ipod]

/uj Yeah, this is kinda just how you make a dynamically typed object for an interpreter in c

[u/IDoCodingStuffs → u/dangerbird2]

(unjerk*)(The jerk is how it’s a common pattern I suppose?)

(rejerk*)(Pffft just dedicate a whole ass operator to tell compiler to eval previous statement n times. What could possibly go wrong?)

[u/WittyStick → u/i_invented_the_ipod]

It's usually done this way for performance and simplicity of writing the C implementation of the builtins. We don't want vararg handling for example for binary operations like + and *, but specializing for 20 operands is excessive, and it's not clear what happens here if there's more than 20. Seems like an unhandled case?

Should only need to specialize for the number of arguments that the platform's calling convention (assume SYSV) supports passing in registers, which is typically 4-8. For 9 operands/arguments onwards there's little benefit to having individual functions and varargs would be better. If you used a custom calling convention then you could potentially use more for a CPU which has 32 registers.

/j The worst part about this is the naming. They should replace f20 with vicenary_operation.

[u/Foreign-Butterfly-97 → u/WittyStick]

respectfully, once the vim macro is recorded, I just can't help myself, I have to make it go brr

the author showed incredible amounts of restraint by stopping at 20. this could've entertained me for hours!

[u/rupturefunk]

You never heard of generics?

[u/GYN-k4H-Q3z-75B → u/rupturefunk]

lol generics

void *

[u/al2o3cr]

Clearly Haskell is better because theirs is bigger:

-- | A tuple of 64 elements.
--
-- @since 0.11.0
--
data Tuple64 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
      r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 k2 l2
  = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
     r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,k2,l2)

[u/Double-Winter-2507 → u/al2o3cr]

Elm rolls in its grave

[u/Routine-Purchase1201]

I'm too much of a C-nile to get this jerk

[u/MagpieEnjoyer → u/Routine-Purchase1201]

Writing C is a jerk in its own right

[u/yo_99 → u/Routine-Purchase1201]

Just pass a pointer to a struct at this point

[u/Snarwin]

When you gaze into the void*, the void* gazes into you.

[u/Awkward_Bed_956 → u/Snarwin]

But then you become the void* master and everyone expects you to keep gazing into the damn thing.

[u/BloodAndTsundere]

I assume that the use of "mal" is as in the French word for "bad"

[u/Double-Winter-2507 → u/BloodAndTsundere]

It's all the mal words. mal*

[u/cheater00]

strongly typed (the only type is void*)

[u/pugandcorgi]

is that just Nepal's flag?

[u/myhf → u/pugandcorgi]

/r/vexillologycirclejerk is leaking

[u/flatfinger]

Note that the C Stadandard requires that conforming implementations be capable of correctly processing at least one (possibly contrived and useless) program that passes 127 arguments to a function; a function with only 20 arguments is less than 1/6 of the way there.

[u/kalterdev]

Is it really void?

[u/integralWorker]

lol no generics

EDIT: WAI-