←2021-01-25 2021-01-26 2021-01-27→ ↑2021 ↑all
00:16:18 -!- Arcorann has joined.
00:22:05 -!- rain1 has quit (Quit: WeeChat 3.0).
00:24:08 -!- SpaceDecEva has joined.
00:28:24 -!- SpaceDecEva has quit (Client Quit).
00:38:16 -!- TheLie has quit (Remote host closed the connection).
00:52:26 <esowiki> [[Parse this sic]] https://esolangs.org/w/index.php?diff=80320&oldid=80319 * Digital Hunter * (-226) /* Deadfish interpreter */ output was broken. Sigh.
00:56:55 <esowiki> [[Talk:Parse this sic]] https://esolangs.org/w/index.php?diff=80321&oldid=80299 * Digital Hunter * (+359)
01:53:28 -!- user24 has joined.
02:33:58 -!- user24 has quit (Quit: We must know, we will know).
02:52:58 -!- LKoen has quit (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”).
03:07:02 -!- MDude has quit (Quit: Going offline, see ya! (www.adiirc.com)).
03:07:16 -!- sprock has quit (Quit: ...).
03:39:19 -!- Deewiant has quit (Ping timeout: 256 seconds).
03:39:37 -!- Deewiant has joined.
07:16:43 <b_jonas> fungot, does the Great Seal of the United States, established by Queen Victoria, symbolize the secret rule of the freemason Illuminati?
07:16:43 <fungot> b_jonas: consider it forgotten. it's some strange suburb with a statue and a church in it.
07:35:36 <b_jonas> fungot, while an angel is incarnated for an earthly mission, they sate themselves with the same kind of mortal food as humans, right? if they can't find enough food and starve, do they die or are they merely dismissed to their original realm? or does that never happen because they can just use their power to create food out of nothing?
07:35:37 <fungot> b_jonas: 11903: what are you using for your coding?!! a pair of parentheses, all alike
07:42:59 -!- Deewiant has quit (Ping timeout: 256 seconds).
07:43:23 -!- Deewiant has joined.
07:55:14 <b_jonas> fungot, if one and a half hens lay one trench per one and a half weeks, then how many eggs can thirty soldiers dig in an hour if they only have ten shovels among them?
07:55:14 <fungot> b_jonas: last time i checked chicken is free as in " fnord". sounds uh fnord."
07:55:33 <b_jonas> not really an answer, but ok
07:56:53 <shachaf> Taneb: Did you save a bunch of kittens?
08:15:30 -!- rain1 has joined.
08:17:23 <esowiki> [[Talk:Parse this sic]] https://esolangs.org/w/index.php?diff=80322&oldid=80321 * JonoCode9374 * (+240) /* Interpreter */ new section
08:18:17 <esowiki> [[User:JonoCode9374]] https://esolangs.org/w/index.php?diff=80323&oldid=76638 * JonoCode9374 * (+21)
08:47:58 -!- arseniiv_ has joined.
09:03:49 -!- Sgeo has quit (Read error: Connection reset by peer).
09:07:05 -!- Arcorann has quit (Ping timeout: 240 seconds).
09:43:01 -!- Arcorann has joined.
10:18:03 -!- user24 has joined.
10:19:26 -!- Lord_of_Life_ has joined.
10:19:48 <esowiki> [[Caballo]] N https://esolangs.org/w/index.php?oldid=80324 * CatIsFluffy * (+7412) It's Spanish for "horse". Same starting letter since same target.
10:20:34 <esowiki> [[Language list]] https://esolangs.org/w/index.php?diff=80325&oldid=80297 * CatIsFluffy * (+14) /* C */ They say you're supposed to add languages here, but Special:LonelyPages tells a different story
10:21:16 -!- Lord_of_Life has quit (Ping timeout: 240 seconds).
10:21:16 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
10:22:04 -!- Bowserinator has quit (Quit: Blame iczero something happened).
10:22:04 -!- moony has quit (Quit: Bye!).
10:22:04 -!- iovoid has quit (Read error: Connection reset by peer).
10:34:46 -!- Bowserinator has joined.
10:38:47 -!- iovoid has joined.
10:39:19 -!- moony has joined.
10:48:58 -!- TheLie has joined.
10:56:40 -!- LKoen has joined.
11:15:30 <esowiki> [[Graphical Brainfuck]] https://esolangs.org/w/index.php?diff=80326&oldid=79429 * Razetime * (+210) Added my own implementation
11:18:20 <fizzie> fungot: Do you have an answer for every question?
11:18:20 <fungot> fizzie: i've heard srfi 19 is time data types and procedures: http://srfi.schemers.org/ srfi-50/ mail-archive/ msg00076.html partitioning
11:19:46 -!- none30 has quit (Quit: Bridge terminating on SIGTERM).
11:20:04 -!- Discordian[m] has quit (Quit: Bridge terminating on SIGTERM).
11:20:11 -!- acedic[m] has quit (Quit: Bridge terminating on SIGTERM).
11:20:11 -!- wmww has quit (Quit: Bridge terminating on SIGTERM).
11:31:47 -!- none30 has joined.
11:58:11 -!- wmww has joined.
11:58:11 -!- acedic[m] has joined.
11:58:12 -!- Discordian[m] has joined.
12:27:50 -!- TheLie has quit (Remote host closed the connection).
12:40:03 -!- LKoen has quit (Remote host closed the connection).
12:42:27 -!- LKoen has joined.
13:21:28 <esowiki> [[Special:Log/newusers]] create * Seshoumara * New user account
13:37:51 <esowiki> [[Parse this sic]] M https://esolangs.org/w/index.php?diff=80327&oldid=80320 * Digital Hunter * (+1) /* Example programs */
13:52:57 -!- user24 has quit (Quit: We must know, we will know).
13:56:38 <esowiki> [[Esolang:Introduce yourself]] M https://esolangs.org/w/index.php?diff=80328&oldid=80162 * Seshoumara * (+492)
14:18:07 -!- test00471 has joined.
14:21:04 -!- test00471 has quit (Quit: Connection closed).
14:37:28 -!- Arcorann has quit (Ping timeout: 260 seconds).
14:37:40 -!- gthread20 has left ("Leaving").
14:39:22 -!- gthread20 has quit (Quit: Leaving (123)).
14:50:58 -!- gthread20 has quit (Quit: Leaving).
14:51:53 -!- TheLie has joined.
15:02:38 <esowiki> [[Talk:Lazy evaluation]] https://esolangs.org/w/index.php?diff=80329&oldid=68869 * Chibiningen * (+312) /* Relevance to Esolangs? */ new section
15:11:31 <int-e> esowiki: we could just revert to https://esolangs.org/w/index.php?title=Lazy_evaluation&oldid=65961 ...
15:18:00 <esowiki> [[User:Martin Ender]] https://esolangs.org/w/index.php?diff=80330&oldid=54082 * Martin Ender * (+4)
15:20:54 <chibi_> int-e: That works, lol.
15:21:32 <chibi_> Though it'd still be nice to have a list of lazily evaluated Esolangs somewhere.
15:22:35 <int-e> it is there, to be evaluated lazily
15:23:31 <int-e> (It took me a moment to get to the bottom of the "More info will be added upon request" part. In the old version, that is...)
15:24:34 <chibi_> Oh let's not talk about ⊥, nothing good ever comes out of ⊥
15:24:47 <int-e> Oh that part was actually preserved.
15:26:02 <int-e> That pun was a fortunate accident. :) (But I did spot it before hitting RET.)
15:26:32 -!- MDude has joined.
15:36:40 -!- arseniiv_ has quit (Ping timeout: 264 seconds).
15:41:23 -!- Sgeo has joined.
15:43:32 -!- SpaceDecEva has joined.
15:44:24 <lambdabot> "test"
15:44:41 <lambdabot> "hello world"
15:45:38 <gthread20> > init$fmap(let f=(\x->if x==0 then 0 else 1+(f(x-1))) in chr.f)$take 39$map(\x->117-(mod(div(read(concat(map(\x->show(ord x))"\STX?3T\NUL\SOH0\"c\STX.SV:MN=\SOH3\STX2)+\SOH'`3\STX!\SOHA[\SOH2\STXKZD\STXN\"&$\STX5\"\ETX\SOH"))-1)(117^(38-x)))117))(iterate(+1)0)
15:45:40 <lambdabot> "23151 Segmentation fault (core dumped)"
15:47:05 -!- gthread20 has left ("Leaving").
15:50:52 -!- TheLie has quit (Remote host closed the connection).
15:54:35 -!- arseniiv_ has joined.
15:55:54 <rain1> hmmmmm
16:06:54 -!- SpaceDecEva has quit (Quit: Connection closed).
16:32:49 -!- sprock has joined.
16:57:19 <arseniiv_> <chibi_> Though it'd still be nice to have a list of lazily evaluated Esolangs somewhere. => check out Ⅎ, I created a page and a name for it but the idea is stumbled upon quite regularly, that’s because it’s an equational functional language without anything else. Hopefully I marked laziness as a must there
16:57:24 -!- arseniiv_ has changed nick to arseniiv.
16:59:00 <arseniiv> though it by no means should have lazy evaluation, as its essence is “functional equational”, but what’s done is done and anyway the page can be edited. I already named three variants of the language, so there may be six and more
17:03:31 -!- LKoen has quit (Remote host closed the connection).
17:24:01 -!- Deewiant has quit (Quit: WeeChat 2.3).
17:56:56 -!- Deewiant has joined.
18:14:34 -!- TheLie has joined.
18:48:57 -!- LKoen has joined.
18:58:35 -!- TheLie has quit (Remote host closed the connection).
18:59:33 <esowiki> [[Stupidc]] N https://esolangs.org/w/index.php?oldid=80331 * Not applicable * (+1310) i'll finish it later
19:00:51 -!- arseniiv has quit (Ping timeout: 256 seconds).
19:40:37 -!- arseniiv has joined.
19:40:49 <esowiki> [[Stupidc]] M https://esolangs.org/w/index.php?diff=80332&oldid=80331 * PythonshellDebugwindow * (-24) Use Templates Lowercase, Stub
19:45:40 <arseniiv> how do you call when there are several type systems each more precise than the last, and you may type program elements in any of them? It seems “gradual typing” denotes just one special case (two type systems, of which one is trivial with a single type). And that’s not plain subtyping either, as we have constraints on all occurring subtypes
19:46:50 <arseniiv> ais523: may I ping you, maybe you have a clue about that
19:46:51 <kmc> "refinement types" are a related concept, though I think not precisely what you're describing
19:51:09 <arseniiv> kmc: thanks, this is a good reminder. Being able to express pre-/postconditions in types is a good thing
19:51:19 <kmc> yes
19:52:09 <kmc> there are a lot of interesting implementation options, too
19:53:25 <kmc> like you may be able to discharge some of the predicates at compile time, and whatever's left can be emitted as asserts (maybe only for debug builds), and subject to QuickCheck-style automatic test case generation
19:54:31 <kmc> you could even have a compiler which "finishes" and yet continues to prove correctness properties and/or find counterexamples in the background
19:54:35 -!- LKoen has quit (Remote host closed the connection).
19:55:18 <kmc> continuous integration not as a set of discrete build/test jobs but as a continuously running and arbitrarily scalable pool of compute resources which is continually trying to break or improve your code
20:01:14 <kmc> it's also kind of related to lazy evaluation
20:02:07 <kmc> like you can think of the whole space of types/values as a single poset
20:02:57 <kmc> you can refine from "any" to "int" to "[0, 10]" to "[1, 3]" to "2"
20:03:03 <kmc> (using ranges as a simple example)
20:03:47 <kmc> and maybe a function doesn't need to return "2" precisely, maybe the caller only wants to know if the result is within [1, 3]
20:04:37 <kmc> in traditional lazy languages like Haskell you have this capability but only for the structural refinement of algebraic types with pattern matching
20:05:33 -!- LKoen has joined.
20:05:41 <kmc> so for example if you want lazy natural numbers you have to represent them as unary Peano numbers and you can only make lazy queries of the form "is it at least X"
20:09:05 <kmc> and there's a connection to topology too, which i can't explain very well because i don't really understand topology
20:09:27 <kmc> but like think of your refinement types as open / semidecidable sets
20:09:35 <kmc> so that if x \in T then you can prove it in finite time
20:09:57 <kmc> and then you want to work with continuous functions
20:10:27 <kmc> so that answering a query of the form y \in f(x) reduces to answering a disjunction of x \in S_0, S_1, etc.
20:10:30 <kmc> i dunno
20:10:44 <kmc> i'm probably not making a lot of sense cause i'm only kind of grasping at these concepts but i think there's something cool there
20:10:58 <arseniiv> I had a discussion with a pal about what I dislike in pure structural subtyping (at least for OOP-like languages with classes or records which are so subtyped), and I suggested adding “semantic tokens” to method names to make accidental subtyping less possible, but that obviously opens its own can of worms;
20:10:58 <arseniiv> and from their questions I noticed that one just need to be able to declare way more properties of methods (and classes awhole), and then any accidental subtyping would mean just that we didn’t state enough. Pre-/postconditions, algebraic identities on functions and all that are steps at that path;
20:10:58 <arseniiv> and then we’ll have type relations we are at ease with, as they are all grow from a type’s properties (those we wished to make its public API)
20:10:58 <arseniiv> <kmc> and whatever's left can be emitted as asserts <…> and subject to QuickCheck-style automatic test case generation => yeah, that’s very nice. Several languages with subtyping approach the first to a very small degree, via “assert x is T” which generates a runtime check and refines the type of x to T in the code that follows the assertion
20:10:58 <arseniiv> yep I remember something about the topology regarding ⊥, Just ⊥ and things like that, and this should be closely related
20:11:55 <arseniiv> (sorry this is in this order, I wrote the first part then read what you’ve been saying)
20:14:19 -!- pikhq has quit (Ping timeout: 272 seconds).
20:14:57 <arseniiv> hm and I see refinements allow us to express state changes in objects after calling methods and deny us calling them in the wrong order, and make state machines and all that, which I wanted a bit
20:16:44 -!- pikhq has joined.
20:17:52 <arseniiv> of course this magic bullet is costly. If I was messing with such a type system, I would have to allow users to write by hand proofs of facts hard to check, or even boldly claim “this one makes out right” without proof
20:19:01 <arseniiv> hm should I try to learn some F*?
20:19:21 <arseniiv> it seemed to have refinement types IIRC
20:20:01 <arseniiv> and many other things, and it tries to reason about them using some solver magic
20:31:14 <kmc> that state-change thing is called "typestate"
20:32:13 <kmc> in a pure functional setting it's easy to do with phantom types
20:33:23 <kmc> in an imperative setting it's less natural
20:33:40 <kmc> because passing a value to a function / calling a method on an object generally doesn't generally change the object's type
20:33:47 <kmc> most imperative langs have no way to express that
20:34:42 <kmc> one solution I can think of is to have the actual object mutate in-place but it also returns a "token" of the correct type, which you have to pass to future method calls
20:34:55 <kmc> the token is just some zero size object which proves that you called the earlier method
20:47:16 <arseniiv> that’s cumbersome even when plumbed away
20:48:41 <arseniiv> for a moment I thought self-types solve at least a small part of this but no, they just allow to restrict subtype definitions
20:49:26 <arseniiv> someone should make an OOP esolang with pre-post-self-types, then
20:53:35 <arseniiv> though that should be somehow constrained, or else having multiple references to the same object will require either something linear to control whether there are multiple references, or something indirectional to allow change an object to something completely different. Of course if all we want is encoding typestates, thanks for the term, then we’ll need to know if two types are typestates of the same object or not, but that doesn’t seem too hard
20:53:35 <arseniiv> if we’re not making the type system too elaborate?..
20:57:40 <b_jonas> arseniiv: re two levels of typing, one finer than the other: rust sort of has that: first you figure out which identifiers exist in which scopes, and which ones are value, types, functions, modules, traits etc, then it figures out the type of every expression and typechecks the program but you can do that ignoring lifetimes, then you checks lifetime. C without C11 _Generic first figures out each
20:57:46 <b_jonas> identifier in each scope and which ones are types, values etc, then you typecheck which you can do ignoring const and volatile qualifiers, then you check for const correctness.
20:58:43 <b_jonas> (this does not work in C++ because C++ can have functions overloaded or templates specialized on a nested const qualifier.)
21:00:41 <b_jonas> but as for *several* type systems, instead of just three, I'm not sure. I have a vague idea for an esolang that is an infinite nesting of identical layers, each one a syntactical preprocessor for the levels below it, but I couldn't yet figure out a nice way to do it.
21:00:56 <arseniiv> b_jonas: interesting! (Though I should have added more, I meant something in vein of declaring these levels on a user level, though I didn’t think enough about details and maybe refinements are a sufficient answer)
21:03:36 <b_jonas> "if you want lazy natural numbers you have to represent them as unary Peano numbers" => I still don't understand why people claim this, or in what sense it is true. you can absolutely have lazy natural numbers represented in other ways, eg. "http://www.math.bme.hu/~ambrus/pu/Bin.hs"
21:04:22 <arseniiv> like, I wrote a function and typed it int → int but then someone wasn’t satisfied and typed it odd → even, or even maybe (odd → even) ∪ (even → odd) for example, so their code with more specific types of other functions would be able to use this function without any unnecessary casts or such
21:04:53 <b_jonas> in that, you can lazy evaluate a number to tell if it's odd or even, or to tell its value modulo 2, etc, but you can only tell whether it's less than a constant or not if you happen to have fully evaluated it
21:05:31 <arseniiv> hm wait now I see p-adic topology!!
21:05:38 <arseniiv> in all its grace
21:05:59 <arseniiv> didn’t connect that
21:08:05 <arseniiv> and the topology for computing with lazy Peano numerals would be the usual topology of neighborhoods of ∞, a quite familiar one from real analysis
21:08:25 <arseniiv> now is there something unlike those and also practical?
21:09:31 <b_jonas> arseniiv: if by "accidental subtyping" you mean because method names happen to be used for multiple different things, you can have method names that are scoped like normal identifiers, as in Rust and Haskell, but unlike in python or C++ (without modules), but even then people sometimes use the same method names for different semantics for convenience of writing code with short method names, especially
21:09:37 <b_jonas> punctuation operator methods.
21:11:02 <b_jonas> you'd need more fancy distinctions between method names to distinguish between different semantics, and lots of methods that are just special case synonyms of other methods
21:11:19 <arseniiv> b_jonas: yeah precisely. And sometimes their signatures may match and the typechecker may thing one of them is compatible with the other, even in a good case when we have classes and protocols, the latter abstract and the former not subtyping one another
21:12:19 <b_jonas> so you can most certainly build classes this way in rust or haskell, they would just be annoying to use
21:13:27 <b_jonas> and I actually quite like rust's scoped methods
21:13:34 <arseniiv> and it was a small discovery to me that this is fixable in a natural way, just giving more information about what a subtype’s methods should satisfy
21:13:56 <arseniiv> haskell and rust are okay in that they aren’t precisely structural-types
21:13:58 <b_jonas> though the standard library makes a few questionable choices about naming the functions that aren't methods
21:14:04 <arseniiv> structural-typed*
21:14:43 <arseniiv> I very much like typeclasses and traits for the freedom they give and for semantics they for an extent bind
21:15:22 <b_jonas> but you can wrap many things with your own differently named abstractions
21:15:43 <b_jonas> when you don't like the names that is
21:16:08 <arseniiv> though I wonder if one can solve the problem of inserting a typeclass “in the middle” of existing ones (like we want to have Eq t => (new) PartialOrd t => Ord t)
21:17:16 <b_jonas> arseniiv: that one is not easy
21:17:29 <b_jonas> but usually you can do one of the less powerful things that's enough for your use case
21:17:47 <kmc> 13:13 < arseniiv> haskell and rust are okay in that they aren’t precisely structural-types
21:18:00 <kmc> neither one has structural subtyping, period
21:18:08 <kmc> Haskell doesn't have any subtyping, and Rust only has subtyping with respect to lifetimes
21:18:10 <arseniiv> b_jonas: sometimes wrapping is the last resort, for example in this middle-class thing one may redeclare their own hierarchy and it may end up with wrapper dictionaries at runtime
21:18:36 <arseniiv> redeclare the hierarchy the right way and reimplement all the needed instances*
21:19:12 <kmc> I think the type-based name resolution of methods in Rust is a pretty significant usability improvement over Haskell
21:19:37 <kmc> no more qualified imports for 10 libraries that all have a method called 'insert' that works on a different type
21:20:22 <b_jonas> kmc: you don't need such a strong trait system for that, C++ can also dispatch named functions based on their argument types :-)
21:20:26 <kmc> once you want a function that's generic over all things with an 'insert' method then you need to define a trait and impl it and get precise about what the requirements are
21:20:45 <kmc> otherwise, they are just unrelated methods that happen to have the same name
21:20:58 <kmc> and if there is ambiguity it's an error
21:21:16 <kmc> b_jonas: yes, and I think the fact that Rust *doesn't* do that for arguments *other than* the method receiver is a usability improvement over C++
21:22:14 <kmc> it does mean that methods are special though. x.f(y) is not just an alternative way to write f(x, y), it gives you type directed resolution of the name 'f' with respect to the type of 'x' (but not 'y')
21:22:24 <b_jonas> kmc: yes, that's why I said in rust they're *scoped* method names, in C++ (without conceps) it's just a string compare on the method names
21:22:49 <arseniiv> <kmc> neither one has structural subtyping, period => oops, indeed. For some time I thought there was something like structural subtyping without subtyping but I don’t know how that thing was born and lived for a time. I knew for a long time haskell and rust don’t have subtyping, but somehow I ended up with misnaming
21:23:20 <b_jonas> kmc: so? methods are special in haskell and rust too, they're just special in a different way
21:25:12 -!- delta23 has joined.
21:25:55 <arseniiv> <kmc> I think the type-based name resolution of methods in Rust is a pretty significant usability improvement over Haskell => yes! I thought that too. And rust still allows methods analogous to static methods in OOP, and it’s a shame languages with OOP-like syntax usually don’t allow to abstract those. Then one can’t even have a monoid interface
21:27:34 <arseniiv> I also came to think ad-hoc overloading is usually unneeded. When a language allows optional arguments, variadic arguments etc. then that’s almost never seems a good idea to have in addition
21:28:02 <b_jonas> kmc: there are some parts of rust syntax that I quite hate, but that in particular isn't one
21:29:31 <b_jonas> what gives me hope is that rust already managed to change syntax in such a way that you can combine old and new syntax even within the same compilation unit through macros, so they could "fix" the syntax (or provide an alternate non-traditional syntax) while giving access to all existing libraries. not that I have high opinion about the existing libraries currently, but still.
21:31:55 <arseniiv> also a tangent on name resolution above: it’s a shame haskell has this “import qualified Data.Map as M; import Data.Map (Map)” thing to not need to write M.Map (or even Map.Map for cases where single-letter aliases aren’t good)
21:32:54 <arseniiv> ah, and that record selectors and accessors are in the module’s scope too
21:33:33 <arseniiv> I saw discussions of what can be done to make things neater and it didn’t seem to take off very high still
21:35:48 <arseniiv> so much experience is dependent on the import system and scoping
21:47:09 <b_jonas> arseniiv: I don't understand why that's a shame
21:47:31 <b_jonas> haskell also lets you rename names as you import
21:47:59 <b_jonas> so if you have Map in two different modules, you can import one of them as XMap and the other as YMap, or even as single-letter names if you want
22:00:46 <arseniiv> this is good though I’ll consider it a baseline for contemporary languages. But the need to write two imports to not write Map.Map further is still a nuisance
22:01:23 <arseniiv> though to be honest I think I’m completely okay with M.Map
22:12:33 <zzo38> Does Haskell have yet the possibility to use escaped names in imports? (Or, do you need Template Haskell to do that?)
22:15:34 -!- LKoen has quit (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”).
22:22:52 <b_jonas> zzo38: what do you mean by "escaped names"?
22:32:09 <esowiki> [[Caballo]] https://esolangs.org/w/index.php?diff=80333&oldid=80324 * CatIsFluffy * (+67) Add input, since it turns out input is good
22:35:14 <b_jonas> I wish mobile phone providers gave this service where, besides my 12 character phone number, I also get a 15 or 16 character long phone number that they guarantee will never be reused, and then I give that number for two-factor authentication such as to my bank
22:35:52 <b_jonas> I'd prefer it to be even longer, but I think there's some technical limit where you might not be able to call a number longer than 15 or 16 characters through some routes
22:36:01 <b_jonas> (or SMS rather than call)
22:36:42 <b_jonas> (I guess they could give a 15 or 16 character long number, whichever is below the limit, and a 25 digit long number too)
22:37:35 <b_jonas> right now the 12 character phone numbers come from small namespaces and routinely get reused if I don't confirm my phone number in time
22:37:37 <esowiki> [[Brainfuck---]] https://esolangs.org/w/index.php?diff=80334&oldid=73518 * CatIsFluffy * (+7) Fix category
22:42:51 <FireFly> o.o
22:43:33 <FireFly> that sounds wonky, or at least here my mobile number is "basically permanent" and you can transfer it to a new service provider as well
22:47:26 <FireFly> and I'm not losing it as long as like, I have a phone plan tied to it
22:47:26 <b_jonas> FireFly: I can transfer it to a new service provider
22:47:26 <b_jonas> and I try hard not to lose my main one
22:47:26 <FireFly> *nod*
22:47:26 <b_jonas> but I've lost at least one spare, plus at least two of my grandmother's spares
22:47:26 <FireFly> I'm just confused since our mobile numbers are 10-digit and we seem to be doing fine
22:47:26 <zzo38> b_jonas: I mean if the name of a module or something in that module contains non-ASCII characters, to be able to use escape codes in the import to refer to them, specifying an alternative name which may be limited to ASCII characters. (It can also be used even if the name does consist entirely of ASCII characters, for example in case there is some name you must avoid for some reason)
22:47:26 <fizzie> There was a story here about a PAYG ("pay as you go") customer getting their phone number recycled because the providers are pretty aggressive in trying to clean up abandoned ones.
22:47:26 -!- sprock has quit (Quit: Lost terminal).
22:47:26 <arseniiv> <FireFly> you can transfer it to a new service provider as well => neat!
22:47:26 <FireFly> with the first two digits being completely fixed for mobile numbers (at least for now, but I guess that might change at some point as landlines are getting increasingly rare, so the old arrangement might change)
22:47:37 -!- sprock has joined.
22:48:56 <fizzie> Finland had a big area code renumbering at one point. I think it was still before ubiquitous mobile phones, but they coalesced the 80 or so geographical groupings down into just 13.
22:51:02 <FireFly> I think we had a renumbering at some point too, but that was before my time..
22:51:03 <fizzie> I don't remember what they did with the other digits though. I think maybe my grandparents' landlines just got a sixth digit added (between the area code and the previous number), presumably to disambiguate from others now joining the same area code.
22:51:26 <FireFly> and presumably also when we switched to 112 as emergency number, from the old 90000
22:52:19 <fizzie> In the big Helsinki metropolitan area, I think everyone already had 6-digit numbers, and they just flipped the "90" area code to "09". The old ones all started with 9, the new ones with the more international 0.
22:54:16 <esowiki> [[Caballo]] M https://esolangs.org/w/index.php?diff=80335&oldid=80333 * CatIsFluffy * (-1) Okay how did I miss that
22:59:32 -!- rodgort has quit (Quit: Leaving).
23:01:06 -!- Arcorann has joined.
23:03:42 -!- rodgort has joined.
23:11:43 -!- CatIsFluffy has joined.
23:33:32 <b_jonas> FireFly: I said 12 character (in Hungary), as in the plus sign, two digits for the country code, two digits of area code (currently only 5 out of the 91 possibilities are for mobile phones, but this set can change), then seven remaining digits.
23:33:50 <FireFly> ah fair
23:34:55 <fizzie> It's a great badge of shame that Finland got a three-digit country code.
23:34:58 <FireFly> here the mobile prefixes are all 07x but not all x'es are allocated for mobile purposes (though quite a lot are now I think)
23:35:00 <b_jonas> but the length can vary by country and possibly even within countries
23:35:02 <fizzie> Denmark, Sweden, Norway all got two-digit ones.
23:35:42 <b_jonas> fizzie: I think at one point they decided that two digit country codes were a mistake and they'll no longer issue any, so all the two digit codes are legacy ones
23:36:14 <fizzie> They've certainly reshuffled them. Finland got a two-digit one initially.
23:36:18 <FireFly> I don't think so, I think it was just an arbitrary division with which countries had more influence on the system
23:37:07 <FireFly> oh maybe not, idk
23:37:10 <fizzie> Then when they did the current numbering that's a little more grouped by continent, Europe (allegedly) got +3x and +4x because France (+33) and UK (+44) did not want to change their two-digit numbers.
23:37:22 <FireFly> I was mixing it up with the 3/4 split
23:37:26 <FireFly> heh
23:38:13 <fizzie> But in that reshuffle Finland got shunted into the three-digit club. Fair enough, someone's got to get there. And Iceland's at +354 -- but they're a lot tinier country too.
23:38:50 <FireFly> I always thought the +4 prefix was allocated to a weird set of countries
23:39:19 <FireFly> especially with the rest of the nordic ones being in +4 but finland getting a +3 prefix
23:40:12 <fizzie> It's kind of convenient that Czechoslovakia had a two-digit code (+42), because when they split up, they could just split that into +420 for the Czech Republic and +421 for Slovakia.
23:40:39 <b_jonas> fizzie: nine of the two-digit codes starting with +4 are used, so ... I think they just ran out of +4
23:40:52 <b_jonas> admittedly there are more three-digit +4 codes open
23:41:31 <b_jonas> (and of course some of Europe is technically under +7 and +9, but that's a technicality)
23:42:43 <fizzie> And it makes sense they ran out of two-digit codes, it's just that why are we the country who got left over, why not [insert a country we think less of] instead.
23:42:47 <fizzie> Anyway.
23:43:44 <fizzie> UK does this odd thing where mobile phone numbers are considered to have a five-digit area code, it's grouped as "07xxx xxxxxx" Sometimes with the last six split into 3+3.
23:46:36 <fizzie> The geographic landline numbers are "02x xxxx xxxx" for the most part, although for some reason there's a persistent myth that "0207" and "0208" would be separate area codes, even though they're not.