meowrobot changed the topic of #elliottcable to: Your topic makes my IRC client cry. 𝕯𝖊𝖓-𝖔𝖋-𝕯𝖊𝖙𝖊𝖗𝖒𝖎𝖓𝖊𝖉-𝕯𝖆𝖒𝖘𝖊𝖑𝖘 || #ELLIOTTCABLE is not about ELLIOTTC [string lost in sudden transmission termination]
<ELLIOTTCABLE>
hi
<ELLIOTTCABLE>
hi incomprehensibly
<ELLIOTTCABLE>
hi inimino
<pikajude>
hi
<ELLIOTTCABLE>
hi pikajude
<incomprehensibly>
hi
<pikajude>
hi
<ELLIOTTCABLE>
hi
<SwooshyCueb>
GOOD MORNING
<SwooshyCueb>
elliottcable so I might be able to come to Chicago at some point this semester
<ELLIOTTCABLE>
yay do
<ELLIOTTCABLE>
also hit VanguardVivian up so she knows
<ELLIOTTCABLE>
can co-plan
<ELLIOTTCABLE>
:D
<SwooshyCueb>
\o/
<SwooshyCueb>
So you are gonna actually be in Chicago at least until May then?
<ELLIOTTCABLE>
im staying home for the duration.
<ELLIOTTCABLE>
tbh im a fucking flake who disappears at the slightest provocation
<ELLIOTTCABLE>
but for w/e it's worth, I'm pretty burned out on traveling
<ELLIOTTCABLE>
and if you have specific plans to see me, I ain't going anywhere unless someone dies ¯\_(ツ)_/¯
<SwooshyCueb>
lemme fill you in on a couple things in PM
mylesborins has quit [Quit: farewell for now]
mylesborins has joined #elliottcable
nuck has quit [Ping timeout: 255 seconds]
nuck has joined #elliottcable
fujisan has joined #elliottcable
alexgordon has joined #elliottcable
alexgordon has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
danpalmer has joined #elliottcable
alexgordon has joined #elliottcable
fujisan has quit [Quit: Connection closed for inactivity]
alexgordon has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
<ELLIOTTCABLE>
argh
<pikajude>
argh
<pikajude>
there are a few circles of hell
<pikajude>
one is arguing with trump supporters online
<pikajude>
one is playing against a peach in 60+ ping
<ELLIOTTCABLE>
wtfff is this shit
<ELLIOTTCABLE>
peach, whta
<pikajude>
ELLIOTTCABLE: super smash bros melee
alexgordon has joined #elliottcable
<ELLIOTTCABLE>
i do not know of these things
<ELLIOTTCABLE>
but I do know that Fuck Code 12.
<meowrobot>
one circle of hell is drinking colonoscopy prep solution for all eternity
<meowrobot>
fuck this thing
<ELLIOTTCABLE>
meowrobot: O_O
* ELLIOTTCABLE
hugs meowrobot
* meowrobot
hugs ELLIOTTCABLE
<meowrobot>
i have to drink like, 2 gallons or something
<meowrobot>
in preparation for tomorrow
<meowrobot>
where i get my stomach, duodenum, and entire intestine examined very carefully
<ELLIOTTCABLE>
omfg there's a person in ##windows literally named cute_korean_girl
<ELLIOTTCABLE>
-_-
alexgordon has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
alexgordon has joined #elliottcable
<alexgordon>
sup ELLIOTTCABLE
<alexgordon>
is there some place where I can talk about random programming language ideas with people?
<alexgordon>
used to be here
<alexgordon>
but nobody's here anymore :(
<ELLIOTTCABLE>
arrghhhgh
<ELLIOTTCABLE>
alexgordon: I'm here!
<alexgordon>
hi!
<ELLIOTTCABLE>
there's a Slack, too, but I don't frequent it much
<alexgordon>
want to talk about type systems?
<ELLIOTTCABLE>
but there's *tons* of PLT activity
<ELLIOTTCABLE>
probably not, I suck at them >:
<alexgordon>
where?
<ELLIOTTCABLE>
snek.
<alexgordon>
snek?
<ELLIOTTCABLE>
idk they took down the signup page.
<alexgordon>
:S
<ELLIOTTCABLE>
also, it's V. SJW, and I'm pretty sure *I'd* get banned for inviting *you*
<ELLIOTTCABLE>
so I regret mentioning it -_-
<ELLIOTTCABLE>
THERE IS NO "Facetime BS Camera" ENTRY, DAMNIT
<alexgordon>
lol I'll be careful
<alexgordon>
or, we could start a non-political PLT group?
<jfhbrook>
"my politics" and "apolitical" aren't the same thing tho
<jfhbrook>
it's tempting to say that but
<jfhbrook>
you have political opinions
<alexgordon>
nah I mean like inclusive
<jfhbrook>
you have to be careful though
<jfhbrook>
for instance, "tolerant" and "tolerates nazis" aren't the same thing
<alexgordon>
ok well I tolerate SJWs
<ELLIOTTCABLE>
it's not "political"
<jfhbrook>
not that you're a nazi obviously but, like, lambdaconf
* ELLIOTTCABLE
sighs
<ELLIOTTCABLE>
not right now plzzzzzzz
<ELLIOTTCABLE>
)=
<alexgordon>
ELLIOTTCABLE: lol we're playing. it's like when fox cubs play fight
<ELLIOTTCABLE>
-_-
<ELLIOTTCABLE>
the ~6 people who ragequat this room after your last "playing episode" would seem to disagree, y'know?
<ELLIOTTCABLE>
ಠಠ_ಠ_ಠ__ಠ_ಠ_ಠಠ
<alexgordon>
lol but that's how it's always worked
<ELLIOTTCABLE>
does anybody here do, like, gaming-computer crap
<ELLIOTTCABLE>
I don't understand windowwwsssssss
<alexgordon>
I'm the channel's immune system
<alexgordon>
jfhbrook: we used to have a rule in here or ##paws, which was NO POLITICS
<alexgordon>
it worked quite well
<ELLIOTTCABLE>
SJWs aren't politics, yo
<ELLIOTTCABLE>
no politics means "don't mention trump"
<alexgordon>
ok but in those days you weren't a SJW
<alexgordon>
you were like far right sarah palin lover or something
<ELLIOTTCABLE>
it doesn't mean "you get to use the t-slur or insist that guy who kills people by upping the price of their drugs by 100x is Just Totally Fine Y'know"
<ELLIOTTCABLE>
"no politics" doesn't protect you if you have shite, hurtful opinions
<ELLIOTTCABLE>
I'm still pretty right on most things.
<ELLIOTTCABLE>
I'm a right-wing person who believes in *human rights* now.
<alexgordon>
anyway your opinion of me must be really low
<ELLIOTTCABLE>
I still think guns are Universally Good, I'm still something of a piece of capitalist trash, I'm still a boooorderline Bitcoin nerd;
<ELLIOTTCABLE>
but I think trans people are the gender they say they are. I think they deserve to be just as safe in everyday life as me, y'know, not, fucking curb stomped. I think Black people deserve safety and the ability to express their collective discontent, and shit.
<ELLIOTTCABLE>
-_-
<alexgordon>
ok but what I'm saying is that none of that has anything to do with programming language theory
<ELLIOTTCABLE>
and *all of that* is politics
<ELLIOTTCABLE>
but when *a real person*, who is a friend of mine, comes into a room named after me, and is *hurt by something you say*,
<ELLIOTTCABLE>
that is not politics.
<ELLIOTTCABLE>
That is *real world*, right here, actionable.
<alexgordon>
what exactly did I say?
<ELLIOTTCABLE>
It doesn't matter if *you* think what you said is political — what matters is the opinion of the person who was hurt, and *only* that person.
<ELLIOTTCABLE>
Not getting into old news. I'm just saying: maybe double-check what you think is "political". It's ... not a good sign if you think something is just "political", and everyone else around you is freaking out about it? -_-
<alexgordon>
I honestly have no idea what is offensive or not to americans
<alexgordon>
it's hard to know what you can't say if nobody will tell you
<alexgordon>
considering half of my country wants to kick out anybody who isn't white british, I'd say I turned out pretty well
* ELLIOTTCABLE
nods
<ELLIOTTCABLE>
and of all things, this is definitely the channel that will tell you :P
<ELLIOTTCABLE>
be very careful with the word "offensive", for instance.
<ELLIOTTCABLE>
that implies it's Not Important, and just something you're *giving* us, out of some inherent kindness.
<alexgordon>
it's more like, there's different cultures on this earth. When you're in another country you have to respect their culture. But on the internet all our cultures are equal
<ELLIOTTCABLE>
That's completely backwards: you're currently *denying* the people you're thinking about offending *basic human decency*, which would make you more of an ‘evil twat’ than anything — don't try and think about it in terms that somehow make you seem nice to yourself, you know? :P
<ELLIOTTCABLE>
don't let yourself off the hook when others have been hurt.
<alexgordon>
you haven't told me what I said that was hurtful
<ELLIOTTCABLE>
took me a couple years to learn to avoid thinking about who's “offended” (even once I'd *decided* that maybe I shouldn't “offend” people as much)
<ELLIOTTCABLE>
and start thinking about who was *hurt*.
<ELLIOTTCABLE>
again, like, zero intention of dredging up old stuff. Stick to the future, I guess?
<ELLIOTTCABLE>
but I'm glad you're willing to ask that, even if you frame it in a Classic Shitty Way According To The SJWs™
<alexgordon>
I know the term kafkaesque is often overused, but this is a good example :P
<ELLIOTTCABLE>
“What am I doing wrong” is a v. good question, even if ego forces it to come out shaped like “What do you idiots think I'm doing wrong, even though that's impossible because I'm a pure and perfect demigod” :P
<jfhbrook>
if I can level with you
<jfhbrook>
there are cultural practices that I think are barbaric
<pikajude>
what? SJWs again?
<pikajude>
jfc
<alexgordon>
ikr
<jfhbrook>
like female circumcision!
<jfhbrook>
or honor killings!
alexgordon is now known as drparse
<ELLIOTTCABLE>
DRPARSE TO OPERATING THEATRE α
<drparse>
:X
<ELLIOTTCABLE>
pikajude: be nice, we exist to be helpful :P
<pikajude>
doctor, we need you to kleene this stary
<pikajude>
star
<pikajude>
shit
<drparse>
:D
<ELLIOTTCABLE>
one SJW thing that realllllly bothers me is the “zero tolerance of intolerance” thing
<ELLIOTTCABLE>
I'm only comfortable with “zero tolerance of intolerant *action*”
<jfhbrook>
I've noticed that
<ELLIOTTCABLE>
but if you have no intolerance for intolerant *thought*, how the fuck are you ever going to help anybody?
<drparse>
jfhbrook: I'm not going to defend honor killings :P
<jfhbrook>
yeah, when I was back home I was talking to my dad and we got in an argument over black lives matter
<ELLIOTTCABLE>
so if a neonazi comes to you, but you're neither black nor a jew nor trans, like, where do you get off kicking him out or beating him down?
<pikajude>
heh
<ELLIOTTCABLE>
fucking educate him. He's not trying to hurt *you*, even if he's trying to hurt *your friends*.
<pikajude>
what wrong could possibly come from giving a platform to a neonazi?
<jfhbrook>
but like my dad has also done a lot of good things in terms of race
<ELLIOTTCABLE>
who said anything about giving them a platform?
<pikajude>
exactly
<jfhbrook>
and it's like, I gotta cut him some slack
<ELLIOTTCABLE>
If he chooses to leave your space because he disagrees with what you're saying, cool.
<ELLIOTTCABLE>
but speak to educate, not to force him out. _-_
<drparse>
anyway
<drparse>
ALL I SAID WAS
<jfhbrook>
I don't really want to hang out with nazis tho
<pikajude>
ELLIOTTCABLE: wait, do you think people are neonazis because they're not familiar with the arguments from the other side?
<drparse>
can we have a PLT community that is inclusive of people who aren't SJW?
<drparse>
like me
<pikajude>
i hope that's not the case
<ELLIOTTCABLE>
pikajude: what?
<ELLIOTTCABLE>
absolutely.
<pikajude>
oh ok
<ELLIOTTCABLE>
You *haven't been* a borderline neonazi. I have, so shut ur trap.
<ELLIOTTCABLE>
:P
<drparse>
programming language theory -> [discussion] -> honor killings
<pikajude>
how do you know i haven't?
<ELLIOTTCABLE>
I know exactly how racist and misogynist mindsets work from the inside; the idea that they're unfixable, or that they're inherent to the humanity of the person is such absolute trite, lazy trash.
<ELLIOTTCABLE>
drparse: so, this falls under what I was just saying — intolerance of intolerance, basically.
<ELLIOTTCABLE>
You're parsing this as "anything that disagrees with <viewpoint> is verbotenspeak”
<ELLIOTTCABLE>
but what you're missing is that the *actuality* of it, at least here, and in other relatively-sane spaces, is “anything that hurts <people present> is verbotenspeak.”
<ELLIOTTCABLE>
which, of course, I hope, sounds totally reasonable
<ELLIOTTCABLE>
but there's one catch:
<ELLIOTTCABLE>
unlike past spaces and rules you're used to, *you aren't required to understand why it's hurtful*.
<ELLIOTTCABLE>
There's no coming back with “but what I said was just fine!”
<ELLIOTTCABLE>
if somebody tells you in an “sjw space” to shut ur trap, you just *do*.
<drparse>
but presumably I'm allowed to know what is "hurtful" and what is not?
<ELLIOTTCABLE>
You don't even have to agree! It's not that we're intolerant of you disagreeing with us — just intolerant of your assumed-right to *exercise* that disagreement to someone else's detriment — make sense?
<pikajude>
yeah, that's why it's usually posted in the channel rules
<ELLIOTTCABLE>
to an extent, yes, of course
<pikajude>
or in a CoC
<ELLIOTTCABLE>
that's why things like CoCs exist (pending here ;_;)
<drparse>
it may surprise you, but I actually keep the my really controversial opinions to myself
<ELLIOTTCABLE>
and beyond that, there's simply being told “stop, ouch, stop” basically
<jfhbrook>
I have one for a mental health support chat
<jfhbrook>
I've actually needed it
<jfhbrook>
as you might imagine
<jfhbrook>
like there are things that are in there because they had to be put in there
<ELLIOTTCABLE>
jesú christo
<pikajude>
on the other side of that coin, i sympathize with people who don't believe that educating others about social justice topics is in the purview of a PLT channel
<ELLIOTTCABLE>
yeah thank god this is a plt space and not, like, actively sjw -_-
<ELLIOTTCABLE>
pikajude: hm, to a point
<ELLIOTTCABLE>
frankly, our industry is so fucking saturated, that any tiny bit of platform you can reclaim for kindness, is, like ...
<ELLIOTTCABLE>
non-optional?
<jfhbrook>
that reminds me
<jfhbrook>
speaking of programming languages!
<pikajude>
of course, if a neonazi can pretend he isn't a neonazi, he's definitely allowed in
<ELLIOTTCABLE>
speaking of programming languages!
<drparse>
ELLIOTTCABLE: all I want to do is talk about type systems
<ELLIOTTCABLE>
build a paws ;)
<jfhbrook>
this thing that's been tripping me up lately
<pikajude>
you don't get banned just for being one
<pikajude>
oh ok
<pikajude>
we done
<pikajude>
thank god
<pikajude>
jfhbrook: what is it
<jfhbrook>
in javascript, all objects are truthy, but in python empty arrays and presumably anything else that can be "empty" are falsey
<jfhbrook>
and I assume it's ultimately controlled by some magic method because what else
<jfhbrook>
and I'm not sure which one is more useful
<drparse>
jfhbrook: think of truthiness as an interface with a function T -> Bool
<ELLIOTTCABLE>
that ennnnttiiiiirely depends on what truthiness is used for
<ELLIOTTCABLE>
in a language with lots of nonexistence, truthiness mapping closely to existence is Very Useful;
<ELLIOTTCABLE>
frankly, I'm not convinced the "truthiness" of an object is a useful property
<drparse>
jfhbrook: then you can have different interfaces for different concepts of truthiness. The only thing special about it is what the `if` statement uses as a default
<jfhbrook>
which honestly is both of these languages
<ELLIOTTCABLE>
*especially* if it can be redefined
<ELLIOTTCABLE>
truthiness should apply only to truth and false, frankly
<jfhbrook>
hell nah
<ELLIOTTCABLE>
having an *explicit* existence operator-set is much clearer and more useful.
* ELLIOTTCABLE
still loves CoffeeScript's handling of existence
<jfhbrook>
I guess it's like I trade 'is not None' for 'and len(xs) == 0'
<jfhbrook>
er
<drparse>
that is what Java does
<drparse>
if can only take a Bool
<ELLIOTTCABLE>
JacobEthanWhite
<ELLIOTTCABLE>
get ur ass in here
<ELLIOTTCABLE>
im hungry help
<drparse>
jfhbrook: personally I think Python gets it right generally
<jfhbrook>
I'm on javascript's side with this one but some of that is familiarity
<drparse>
jfhbrook: I don't think it makes sense to treat arrays differently to strings
<ELLIOTTCABLE>
STINKY DOG
<ELLIOTTCABLE>
==
<ELLIOTTCABLE>
LOVE
<drparse>
because they are both sequences
<jfhbrook>
yeah, javascript gets that wrong--empty strings are falsey
<drparse>
whether a sequence is empty or not is not dependent on whether it's a string or an array
<ELLIOTTCABLE>
again: try and describe to me the value of this?
<ELLIOTTCABLE>
simply typing less in an if()-style statement, or,
<ELLIOTTCABLE>
"truthiness" is "branch direction when used, bare, as a decider expression"
<jfhbrook>
it's a shorthand for a common test, yeah
<ELLIOTTCABLE>
and like: why allow it to be used bare
<ELLIOTTCABLE>
what is the value of that
<ELLIOTTCABLE>
in absence of an existence-concept
<drparse>
the problem is actually the existence of null
<ELLIOTTCABLE>
and in the *presence* of existence, what's the value of differentiating it *ever* from that existence
<jfhbrook>
wut
<ELLIOTTCABLE>
innit the problem *always* the existence of null, tho :P
<drparse>
because that creates two levels of falsiness
<ELLIOTTCABLE>
jfhbrook: uhhh,
<ELLIOTTCABLE>
what drparse said
<drparse>
e.g. a string can be null, "" or "abcdef"
<ELLIOTTCABLE>
kinda?
<ELLIOTTCABLE>
here's my vote:
<drparse>
you can legitimately say that "" is an object (so not null), but also empty
<drparse>
without null then you just have "" vs "abcdef"
<ELLIOTTCABLE>
two separate ‘existence’ and ‘lame’ tests
<jfhbrook>
I feel like this hinges on the idea that "" should be falsey
<ELLIOTTCABLE>
if it's empty, devoid of content, uninitialized, whatever you want — dynamic — it's lame
<drparse>
and thus "" MUST be falsy otherwise it's a type error to even check the condition
<ELLIOTTCABLE>
but if it doesn't exist *at all*, undefined, null, whatever language construct you have for that, it's *nonexistent*
<ELLIOTTCABLE>
the only situation where that is the case
<jfhbrook>
but it's a string, it *is*
<drparse>
jfhbrook: imagine a language without null or undefined, etc
<drparse>
you write `if someString`
<drparse>
if empty strings are truthy then this is ALWAYS true
<ELLIOTTCABLE>
well a language without undefined, it's meaningless to test against a non-boolean
<ELLIOTTCABLE>
yes, drparse, that makes plenty of sense
<ELLIOTTCABLE>
of *course* that's always true
<drparse>
so it's an error, because a conditional should never be ALWAYS true, unless it's intentional
<ELLIOTTCABLE>
in a language with non-nullable references
<jfhbrook>
I'd make a null object
<jfhbrook>
just to be an asshole
<ELLIOTTCABLE>
hahaha
<ELLIOTTCABLE>
"in my language, `NULL` is equivalent to the string "gotcha"`
<ELLIOTTCABLE>
oops swapped a few quotes there
<ELLIOTTCABLE>
guess the rest of this channel will be unbalanced forevermore
<ELLIOTTCABLE>
¯\_(ツ)_/¯
<drparse>
anyway IMO I think null is stupid and should not exist
<jfhbrook>
I feel like I saw an example of that in the wild a few months back
<drparse>
it should be unified with exceptions
<ELLIOTTCABLE>
eerrrrrr, fuck exceptions plz
<jfhbrook>
like someone actually write `class NulL(object):`
<ELLIOTTCABLE>
those are trashdesign
<drparse>
ELLIOTTCABLE: hear me out :P
<ELLIOTTCABLE>
jfhbrook: and this is why it's called "the wild"
<ELLIOTTCABLE>
drparse: no, I totally get where you're coming from
<ELLIOTTCABLE>
but you're thinking so Rutty. ;)
* ELLIOTTCABLE
ducks
<drparse>
null is a shittier version of Optional<T>, and Optional<T> is a shittier version of Result<T, E>
<ELLIOTTCABLE>
I miss incomprehensibly
<drparse>
so instead of null just use Result everywhere
<drparse>
exceptions are also a shittier version of Result but with a nicer syntax
<ELLIOTTCABLE>
okay explain that
<ELLIOTTCABLE>
while I shower
<drparse>
so steal the syntax from exceptions, but keep Result
<jfhbrook>
yeah but presumably you like do some kind of process on them? like you unpack it somehow to see whether you need to do something with it or not?
<drparse>
jfhbrook: sure
<drparse>
there's no conceptual difference IMO between a try/catch block and a check for null. they're the same _concept_
<jfhbrook>
and wouldn't you differentiate between a thing that is, vs a thing that isn't?
<drparse>
so unify them
<drparse>
jfhbrook: say you have a function `divide(Int, Int)` what does it return?
<jfhbrook>
a Rational
<jfhbrook>
or
<drparse>
haha
<drparse>
ok
<jfhbrook>
possibly a "NaN" value
<drparse>
say you have a function `mod(Int, Int)`, what does it return?
<drparse>
if this function is total (defined on all its arguments) then it can't just return Int, because what is `mod(x, 0)`?
<ELLIOTTCABLE>
of course there is
<pikajude>
42!
<drparse>
now you can have this function throw an exception
<ELLIOTTCABLE>
try-catch is *exceptional* control-flow — i.e. out-of-band conveyance
<drparse>
or you can have it return null
<drparse>
but the best approach is to return a Result
<ELLIOTTCABLE>
the entire point is that it's an entirely secondary channel of communication between two arbitrary points in the control-flow graph.
<drparse>
so you get `mod(Int, Int) -> Result<Int, DivisionByZeroError`
<jfhbrook>
or NaN which is kind of like null
<ELLIOTTCABLE>
that's a whooooole different thing than passing around a null *through* the traditional control-flow graph.
<drparse>
jfhbrook: yeah but NaN is not in the type Int
danpalmer has quit [Quit: Connection closed for inactivity]
<ELLIOTTCABLE>
it's like a wormhole for errors.
<jfhbrook>
surely there are ways to accept categories of things
<ELLIOTTCABLE>
man types fuck people up
<drparse>
mathematically the function is undefined when the second arg is 0
<drparse>
there is no NaN in the ring of integers
<ELLIOTTCABLE>
brb photoshopping a bunch of don't-do-drugs posters from the '90s to say don't do types
<drparse>
so it's an error
<drparse>
ELLIOTTCABLE: :D
<ELLIOTTCABLE>
🙄
<ELLIOTTCABLE>
as soon as people learn about types, they start arguing about alllll the wrong things
<drparse>
lol ELLIOTTCABLE
<jfhbrook>
that seems like you really want the 2nd type to not be an Int but all Ints other than 0, or something
<ELLIOTTCABLE>
it's, like, when people become programmers, and start caring about like performance and shit instead of *what actually affects users*
<ELLIOTTCABLE>
why can't we replace all PLT nerds with fucking designers
<pikajude>
it really should accept a Nat
<pikajude>
not an Int
<drparse>
jfhbrook: ya that is possible, but it's just an example :P
<ELLIOTTCABLE>
that's what i'm going to do with my life: build a school for non-mathematician non-nerds to build programming languages. ಠ_ಠ
<pikajude>
or! FloNat
<drparse>
drparse: also that just moves the problem up a layer
<drparse>
erm *jfhbrook
<pikajude>
pikajude: agreed
<drparse>
jfhbrook: because if you ahve `mod(Int, IntNotZero) -> Int` then you also need `intToIntNotZero(Int) -> Result<IntNotZero, IntNotZeroError>
<pikajude>
noooo
<pikajude>
it should just take a Nat
<pikajude>
just awful
<drparse>
well Nat could still include 0
<pikajude>
it depends on which of the two common definitions you mean
<jfhbrook>
okay, so supposing you think that specific example should be an error of some kind rather than a null object, can you construct this argument for every case?
<pikajude>
the one i'm clearly not talking about or the one i'm clearly talking about
<drparse>
ok let's try a different example
<drparse>
what about readFile(path: String) -> ???`
<jfhbrook>
I suppose if your errors are designed better than javascript's, then you can accurately and easily differentiate between types of errors
<drparse>
this is no different. we want to make `readFile()` total on all possible arguments
<drparse>
actually I meant readText()
<drparse>
:X
<drparse>
iawjdoiawjdoiawjd
<ELLIOTTCABLE>
lol.
<pikajude>
Result<String, IOError>
<drparse>
point is you can't have a function `readText(path: String) -> String`
<drparse>
pikajude: yeah exactly
<drparse>
soooooo
<pikajude>
so
<drparse>
we gain a lot if we use Result everywhere
<drparse>
and I mean fucking everywhere
<pikajude>
Result is good for IO
<jfhbrook>
I mean, that's fine with me, promises mostly work like that
<drparse>
it's good for everything!
<pikajude>
but it's obviously not good for integer division
<drparse>
why not?
<drparse>
it's great!
<jfhbrook>
nodebacks do something similar, but with null values
<pikajude>
when you could instead restrict the type of the operand
<pikajude>
heh
<drparse>
well you can do that but you still need Result for it to be sound
<pikajude>
well, but you don't
<drparse>
as I said. to convert between Int and Nat or whatever
<pikajude>
mod by positive integer can't possibly fail
<jfhbrook>
"sound", well, *sounds*, like something some ivory tower academic would say
<pikajude>
but why would you need to convert from Int to Nat?
<drparse>
yeah but what if the second argument comes from user input?
<jfhbrook>
rather than someone who works on the factory floor
<pikajude>
in what case are you going to take user input to determine what to mod a number by?
<drparse>
IRC is pretty shit for writing code
<jfhbrook>
why should I care about euclidean ideals? XD
<drparse>
pikajude: it's an example!
<drparse>
you have to have SOME way to convert between Int and Nat
<pikajude>
drparse: ok. i'll say it doesn't come from user input
<pikajude>
you could always have an int constant of type Nat
<drparse>
pikajude: say you are writing `bc`
<pikajude>
then the invariant is enforced by the compiler
<pikajude>
sure, when writing mod i'd check if the operand is 0 and ask again
<pikajude>
or say it doesn't work
<pikajude>
or whatever
<drparse>
yeah but if the type of mod is `mod(Int, Nat) -> Int` and you are getting your input via `getIntThatTheUserTypedIn() -> Int`
<drparse>
then you need another function from `Int -> Nat`
<drparse>
otherwise your program won't typecheck!
<pikajude>
i'd rather write GetNatThatTheUserTypedIn() -> Nat
<pikajude>
then it will typecheck
<drparse>
lol
<drparse>
you are going to write one of those functions for every set of integers?
<pikajude>
hey, this is your example
<pikajude>
that's what i'd do if i needed to obtain a Nat from the user
<pikajude>
i'd probably write a function that gets one
<drparse>
so you are going to duplicate every function that might possibly return an Int and make a -> Nat variant?
<pikajude>
i'm not sure
<jfhbrook>
scuse me but Nat does not include negative numbers yes?
<pikajude>
Nat isn't isomorphic to Int
<drparse>
jfhbrook: in this context it is all positive integers
<pikajude>
but surely the a -> Int variant can be generalized to anything Int-y
<pikajude>
Nat isn't
<drparse>
because pikajude likes it that way
<pikajude>
yeah i'm just using this definition based on the definition of natural numbers
<pikajude>
"Nat"ural
<jfhbrook>
so that sounds like a problem
<pikajude>
getDivisor :: IO NonZero
<jfhbrook>
cause I know that someone somewhere has defined mod such that it works for negative ints
<drparse>
sure
<drparse>
it's almost always useless
<pikajude>
if you're writing a compiler for a calculator language, would make sense to have a nonzero primitive
<pikajude>
or nats
<pikajude>
either way
<drparse>
jfhbrook: so for the purpose of this discussion it doesn't really matter whether it is Z>0 or Z\0
<drparse>
anyyyyywaaaaaay
<pikajude>
anyway, what other types of numbers are we getting from the user
<pikajude>
besides N and Z
<drparse>
all I wanted to say was that Result is awesome and can replace all of: 1) exceptions, 2) optional, 3) assert
<jfhbrook>
also
<drparse>
4) null
<drparse>
I actually don't want to talk about the correct signature for mod() it was just an example :P
<jfhbrook>
I would write a getInput that gave me a string, a thing that parses it into a value I would expect, and then call the thing <_<; parts 1 and 2 can be combined but it doesn't seem to matter to me much
<jfhbrook>
am I missing something?
<drparse>
it doesn't matter
<drparse>
just function composition
<ec>
my Windows has been saying "Please wait" for half an hour
<ec>
how long do i wait, Windows
<ec>
give me some goddamn indicator
<drparse>
jfhbrook: you can write getInput() -> Bytes, and then have functions that do Bytes -> String, String -> Int, etc
<jfhbrook>
sure, so String -> Nat sounds reasonable
<drparse>
and if you really care you can do `getInt = stringToInt . bytesToString . getInput`
<jfhbrook>
clearly you want to list that in the other order
<drparse>
nah because mathematicians are weird
<jfhbrook>
they are wrong
<drparse>
yes they are
<drparse>
but it's the way we've always done it goddammit
<pikajude>
a . b . c is \ x -> a (b (c x))
<jfhbrook>
yeah I know
<pikajude>
oh
<jfhbrook>
but as a matter of "thing I type into my computer file"
<ec>
"thing I type into my computer file"
<drparse>
jfhbrook: you can just make another operator anyway!
<ec>
geeze, when you put it like that, my entire career sounds pointless
<pikajude>
i love computer files
<drparse>
jfhbrook: reverseCompose = flip (.)
<jfhbrook>
yes, computer files are the best files
<pikajude>
we have the best ones
<drparse>
anyway I wanted to talk about TYPPPPPPEEEE SYSTEEEEEEEEEEEEEEMS
<drparse>
I've got three rules for a type system, discuss: 1. It must not use constraint-solving (no hindley milner!), 2. It must be parametric, 3. It must be turing complete
<ec>
this is such crap ARGH
<ec>
drparse: why
<drparse>
feel like type systems have become too much about adding declarative metadata, and not enough about finding and identifiying bugs
<drparse>
and also constraint-based type systems are slow
<drparse>
so most people's idea of the "power" of a type system is different to mine
<jfhbrook>
I don't remember what constraint solving is in this context but I want it
<pikajude>
i love constraints
<pikajude>
they're kinky
<drparse>
:P
<jfhbrook>
idk why you would want your type system to be turing-complete though
<jfhbrook>
like I guess I feel like if your language as a whole can do everything, why insist on that being a property of a small subset of your language? to what end?
<drparse>
jfhbrook: there's two complete ways to write a type system. You can have the compiler generate constraints and then solve them (e.g. Haskell, ML, Rust, Swift). Or you can just naively follow the types through the program (e.g. Java, C++)
<drparse>
s/complete/competing
<ec>
omg
<ec>
somebody in ##Javascript is arguing that `else` should never be use
<drparse>
lol
<ec>
and that you should exclusively use ternary statements with IIFEs
<jfhbrook>
definitely not
<jfhbrook>
else: even worse than null
<jfhbrook>
that is actually insane advice
<drparse>
jfhbrook: my proposition is that the naive way is much _much_ more powerful, but nobody has really implemented a language with a powerful naive type system
<drparse>
jfhbrook: because when people make languages they tend to get seduced by constraints (which offer better type _inference_)
<drparse>
and that ultimately constraints (lol) the power of their type system
<ec>
jfhbrook: right lol
<drparse>
if you don't have constraints you can do loads of cool stuff for finding bugs that would be really difficult to do with constraints
<drparse>
the trade-off is that programmers will have to add more explicit type annotations
<drparse>
in their code
<pikajude>
oh god, I HATE type annotations
<drparse>
lol
<pikajude>
constraint solving is amazing while writing code
<drparse>
no
<pikajude>
and while refactoring code
<drparse>
you can still infer MOST types using naive type inference
<pikajude>
oh, okay
<pikajude>
i misinterpreted it as constraint-solving = inference
<drparse>
naive inference is like C++
<ec>
ew no
<ec>
get out
<drparse>
where you can even write lambdas without specifying types
<ec>
explicit types are for trashpeople using trashlanguages
<drparse>
`[](auto x, auto y) { return x + y }`
<drparse>
;
<ec>
types are *okay*, if they are entirely optional, partially-applied, and maximally-inferred.
<ec>
that's the only situation.
<drparse>
ec: yes, this is still infered
<ec>
can we *please* move on past the static-typing obsession of the early 'teens?
<ec>
🙄
<drparse>
it's about the way that the type system is implemented
<ec>
typing types is something for weird wannabe-mathematician programmers to do.
<ec>
not industry programmers trying to actually change the world usefully.
<drparse>
ec: this is not in opposition to that
<ec>
oh no oh no oh no oh no oh no
<ec>
now somebody's encouraging him to use SharedArrayBuffers
<ec>
instead of Arrays
<ec>
so he can write his code more like the C code he's used to
<ec>
no no 10,000x noooo
<drparse>
ec: this is in ##javascript?
<ec>
yesssss
<ec>
ahhah
<drparse>
ec: also I agree 100% anyway
<ec>
oh lord so many people are trolling this poor newbie
<ec>
No stop go away
<drparse>
I am way more productive in JavaScript and Python than I am in statically typed languages
<drparse>
because I've been writing Python for like a decade and actually I don't make that many errors
<drparse>
but I would take a free type checker if it had good type inference!
<drparse>
the main problem with today's dynamic languages is that they weren't designed to be easy to type check
<ec>
flow!
<ec>
I want to love flow
<drparse>
TypeScript!
<ec>
but no HKT defeated *literally the first thing I tried to do in it*
<ec>
no no no no
<ec>
did we learn *nothing* from CoffeeScript
<drparse>
lol
<ec>
layer on top, remain future-proof
<ec>
Do Not Fucking Transpile
<drparse>
my feature got merged into coffeescript!