Talk:Duck typing

message: I had no idea this page was a programming related article until I had read half of it. Why not put this kind of information at the top?  —Preceding unsigned comment added by 67.163.7.98 (talk) 22:38, 21 September 2007 (UTC)
thread_title:  Identity 

message: I'm no expert, but doesn't perl use duck typing too?  If so, it could be mentioned along with the other languages. 85.0.186.148 00:09, 10 February 2007 (UTC)
replies: text: I believe JavaScript / ECMA Script does as well, although I am not an expert either. --24.222.119.254 00:05, 24 February 2007 (UTC)
thread_title:  Perl? 

message: * Ya gotta have an object system
* Ya gotta have inheritance (for contrast).
* A statement calling a method on an object does not rely on the type of the object, only that the object, of whatever type, must implement the method called.
===An example===
you write a function to sum integers in a list like this:
  def summer (values, initial_value = 0):
    total = initial_value
    for value in values:
      total = total.add(value)
    return total
You normally call the function with a list of integers and the initial value with its default value of zero and are returned the arithmetic sum of those values.
In the language, if strings have an add method that concatenates two strings i.e. 'abc'.add('def') == 'abcdef', then the same summer function can be made to concatenate a list of string fragments, if the initial_value is the null string, .
To the summer function, a list of strings and an initial value of a string looks just like a list of integers and an initial value of an integer; they walk like the ints react ike the ints and so the summer has no trouble treating them like the ints hence Duck typing!
Can we remove the expert tag now? --Paddy 16:55, 3 March 2007 (UTC)
thread_title: Confused by what is Duck Typing?

message: you write a function to sum integers in a list like this:
  def summer (values, initial_value = 0):
    total = initial_value
    for value in values:
      total = total.add(value)
    return total
You normally call the function with a list of integers and the initial value with its default value of zero and are returned the arithmetic sum of those values.
In the language, if strings have an add method that concatenates two strings i.e. 'abc'.add('def') == 'abcdef', then the same summer function can be made to concatenate a list of string fragments, if the initial_value is the null string, .
To the summer function, a list of strings and an initial value of a string looks just like a list of integers and an initial value of an integer; they walk like the ints react ike the ints and so the summer has no trouble treating them like the ints hence Duck typing!
Can we remove the expert tag now? --Paddy 16:55, 3 March 2007 (UTC)
thread_title: An example

message: Duck typing is a pretty vauge term, as far as I can tell, and can refer to anything from implicit typing to run-time member-method name checking (to see if the object has a function the program is trying to call). Also, the duck typing of the different listed langauges are significantly different, and I've even heard that the "duck typing" in objective C isn't really duck typing. If anyone thinks this page could do without an expert, I can't imagine they would disagree that the page need lots of cleanup. Fresheneesz 23:11, 4 March 2007 (UTC)
thread_title:  Expert tag 

message: I think the Talk section has better examples than the main article, and clears up a lot of misconceptions as to what duck typing is.
I intend to re-write the main article this weekend keeping the relevant parts from both the article and the Talk page.
--Paddy 05:15, 22 March 2007 (UTC)
thread_title:  Re-writing page 

message: One of the things which often confounds discussions of 'duck typing' is that people want to talk about 'the' duck type of an object, which is a carryover from non-ducktyping systems.
I've been involved with dynamic OO languages for 25+ years, and I have spouted some of my opinions on duck typing in my blog http://talklikeaduck.denhaven2.com/articles/tag/ducks
In my opinion duck typing isn't about the type of an object, but rather about the functional requirements on an object used in a particular context (or role).  Any particular object may or may not be usable in a given role. My colleagues and I (who were Smalltalk programmers at the time) used to talk about role-based types long ago, before I ever heard the term duck-typing. Since I came across the term, I've tended to see duck-typing as pretty much the same thing.
An analogy I've used is that duck typing is similar to what happens with an actor is being considered for a part in a play.  It's the director, not the actor, who defines the requirements, often in a somewhat fuzzy way.  The 'type-matching' occurs through a process of audition.  In programming duck-typing is a process of defining roles, looking for, or writing, objects to fill these roles, auditioning these objects (i.e. testing), and possibly refining the role definition.  Sometimes/often a role might be written with a particular actor in mind, properly approached however, duck-typing allows the 'play' to be re-staged with a different cast of actors.
As an aside the articles in the Biological Classification Analogy section don't seem to me to be relevant.  I'm not sure if they have migrated away from being about evolution based taxonomys, or if there are other better reference.  In any case, I think that duck typing, unlike class/inheritance based type systems a la, say C++ is anti-inheritance/hierarchical typing.
Such hierarchical type systems force a particular classification hierarcy on types.  While it might seem natural that there is a 'natural' hierarchy of types since we tend to believe that taxonomies in biology or linquistics are somehow real, in fact those taxonomies are often artificial and based on particular viewpoints.
For a biological example, I would point to the Stephen Jay Gould essay "What, If Anything, Is a Zebra?"  which, as I recall, describes how the natural definition of a Zebra, i.e. a horse-like animal with black and white stripes, relates to different theories of evolutionary relationships between different species of Zebras in the field.
For linguistics examples, there is Lakoff's "Women, Fire, and Dangerous Things," which has several examples of how speakers of different languages, and members of different cultures, build different categorization hierarchies.  Although they might have different views of the hierarchical classification of objects, they can still use those objects according to their perception of the external qualities of individual objects at the base level, which tends to cut across these language/cultural lines. In other words, we tend to use duck typing in everyday life, rather than thinking about implementation hierarchies of the objects we use.
--Rick 14:37, 22 March 2007 (UTC)
thread_title:  My two cents. 

message: 90% self-flattery. 203.154.48.180 08:43, 14 July 2007 (UTC)
thread_title:  In Java 

message: I note that an anon IP has deleted the biological analogy section, and without any discussion. Personally I found this section useful as it's a clear statement and a good analogy. Should it be reverted?
Andy Dingley 11:33, 20 August 2007 (UTC)
thread_title: Biological analogy

message: I think no mention of a programming language should be made in the main article unless it is established within their languages community by, for example, Duck typing being positively mentioned, (not necessarily on a wiki), on the languages home site, or major articles by very prominent members of the community advocating Duck Typing for the language, (e.g. by mainstream language tutorial authors).
This would help keep the page focused. 
I know of no Statically Typed/Manifestly Typed language where this is the case, so I would be likely to keep mentions of languages such as Perl/Python/Ruby. 
If this affects your additions then please give examples of Duck Typings advocacy/standing within the languages community. --Paddy 05:35, 24 August 2007 (UTC)
thread_title: Duck typing in programming languages

message: :I've requested the opinion of a third party Wikipedia:Third_opinion#Active_disagreements.  —Preceding unsigned comment added by Paddy3118 (talk • contribs) 16:05, August 28, 2007 (UTC) 
This sounds like a good idea, thanks. 205.228.73.11 16:10, 28 August 2007 (UTC)
thread_title:  Requesting a third-opinion 

message: It would be good if all the languages mentioned in the implementations sections had at least one reference given to its implementation of duck typing. That means references are needed for Coldfusion, Smalltalk, and Objective-C. --Paddy 17:19, 9 October 2007 (UTC)
thread_title: External Reference request for some languages

message: "While duck typing is used to implement the foreach statement"
That is just plain wrong, foreach is done by the object implementing a particular interface -- this is not duck typing but strict inheritance.  I suggest it is deleted.  In addition anonymous types and duck typing are completely different. In the duck analogy anonymous types are a bit like saying 'I would like to be one of those quacky things over there' rather than actually being a duck :) RobChafer 09:56, 14 November 2007 (UTC)
replies: text: I've asked on the blog if it might be structural typing. But even if it is. How much is it part of the language? When would it be part of a normal C# release? --Paddy (talk) 18:40, 17 November 2007 (UTC)

text: Is it confined to foreach or can the programmer use Duck typing in his own functions? Could you write the Duck&Trance or DuckDecoy examples above for example? (P.S. I am not a C# programmer  so I'm asking directed questions for those who are). --Paddy (talk) 21:45, 13 December 2007 (UTC)
replies: text:  It is confined to foreach, and to some of the new language features in C# 3.0. The programmer cannot use duck typing in his own functions. C# is still mostly a statically typed language; the only exceptions are those allowed specifically by the spec and implemented by the compiler. So you could not write the DuckDecoy above; any object passed in to the duckworld method would have to have a defecate member method, even if it would never be called. Commongenius (talk) 15:20, 26 December 2007 (UTC)
thread_title:  C# 

message: What about Reflection in C#? is this duck typing? 
public class Duck {
    public void Quack();
    public void Swim(); 
}
public class DuckRobot {
    public void Quack();
    public Weapon LaserGun;
}
object[] Array = new object[] { new Duck(), new DuckRobot() };
foreach(object quacker in Array) {
    quacker.GetType().FindMethod("Quack").Invoke(quacker, null);
}
So, could a C# expert state what are the limitations of that languages dynamic capabilities that stops it from copying the Duck&Trance or DuckDecoy examples but seemingly allows the reflection above? Is it that the reflection is tied to array accesses? --Paddy (talk) 20:03, 28 February 2008 (UTC)
replies: text: I originally posed the example above, because I'm not sure what the distinction is. Regarding capabilities of reflection, there is no reason the duckdecoy and trance examples cannot be done in C# or VB.NET or possibly Java (IIRC, the Java runtime also has reflection). I would say that unlike duck typing, reflection isn't a language feature, rather it's an ability of the .NET runtime (as implemented in the System.Type and System.Reflection.MethodInfo classes) so perhaps the distinction is a semantic one. Talyian (talk) 23:12, 18 March 2008 (UTC)
thread_title:  Duck Typing in relation to Reflection 

message: Is the term 'duck typing' reserved for dynamically typed languages? I could well imagine a Java-like language that would allow the following:
interface Duck {
  Quack();
  Walk();
}
class RoboDuck /** does not explicitly implement 'duck'! */ {
  Quack() { ... }
  Walk() { ... }
}
performQuack(Duck duck) {
  duck.Quack();
}
performQuack(new RoboDuck());
The language here does not check whether the parameter passed to 'performQuack' explicitly implements the Duck interface, but statically verifies that it does meet all the requirements of that interface. Definitely sounds like a 'duck check' to me - perhaps even more convincingly than the classic python/ruby example, as those do not make the 'then it's a duck' part explicit. --Raboof (talk) 11:34, 24 March 2008 (UTC)
replies: text: What I had in mind is called Structural typing (in contrast to Nominative typing), which gives some of the advantages of Duck typing, but is generally applied to statically typechecked languages. I wonder if you could say Duck typing is a form of Structural typing. --Raboof (talk) 14:29, 7 October 2008 (UTC)
thread_title:  Static Duck Typing 

message: Currently the paragraph about criticism contains: "One issue with duck typing is that it forces the programmer to have a much wider understanding of the code he or she is working with at any given time."
But that is totally wrong. In ruby you usually see .is_a? String or even better a .responds_to? some_method relationship. At this point you do NOT AT ALL need to understand WHAT the code is doing as long as it gives you meaningful results (which it should, since it will support "duck typing" already. Whoever wrote this was either biased, didnt know what he is writing about, or simply lies. It should be reworded or removed, because the issue as described here does NOT exist. Duck typing really is about not worrying at all that the object will do something "illegal" and it frees programmer's brain.  —Preceding unsigned comment added by 80.108.103.172 (talk) 23:19, 17 April 2008 (UTC)
replies: text: sorry, you are promoting and arguing in favour, while this paragraph is about Criticism. In such an paragraph, it is not the point to show if the Criticism is true or false, it's about mentioning that there is Criticism. Much of the problem with this page stems from people trying to argue here (in the enceclopedia), instead of documenting (underpinned with valid references) the arguments brought forth elsewhere by the experts of the matter.  —Preceding unsigned comment added by 91.12.1.109 (talk) 01:40, 22 July 2009 (UTC)
thread_title:  Criticism 

message: .NET is not a language, and if the dynamic languages under .NET do not support generics then the edit adding .NET to the languages supporting generics is wrong.  --Paddy (talk) 08:49, 22 June 2008 (UTC)
thread_title:  .NET not a language 

message: I've been playing about with VB for a bit, and it looks to me like this code supports duck typing
Option Explicit Off
Module Module1
    Sub Main()
        Dim donald = New Duck
        Dim john = New Person
        donald.quack()
        john.quack()
        donald.feathers()
        john.feathers()
        For JJ = 0 To 4
            DuckWorld(donald)
        Next
        For JJ = 0 To 4
            DuckWorld(john)
        Next
    End Sub
    Private Sub DuckWorld(ByVal duck)
        If duck.inFlight Then
            duck.defecate()
        Else
            duck.quack()
        End If
    End Sub
End Module
Class Duck
    Shared rand
    Public Sub quack()
        Console.Out.WriteLine("Quaaaaaack !")
    End Sub
    Public Sub feathers()
        Console.Out.WriteLine("The duck has white and gray feathers.")
    End Sub
    Public Function inFlight()
        If rand Is Nothing Then
            rand = New Random
        End If
        Dim check = rand.Next(0, 2)
        If check = 1 Then
            Return True
        End If
        Return False
    End Function
    Public Sub defecate()
        Console.Out.WriteLine("Crap")
    End Sub
End Class
Public Class Person
    Public Sub quack()
        Console.Out.WriteLine("The person imitates a duck.")
    End Sub
    Public Sub feathers()
        Console.Out.WriteLine("The person takes a feather from the ground and shows it.")
    End Sub
    Public Function inFlight()
        Return False
    End Function
End Class
It looks to me like VB9, at least, is pretty happy to duck-type, and can pretty much implement the DuckDecoy example shown earlier in the discussion.
I believe this is backed up by section 1.11 of the MS document "visual basic 9.0 overview" which I found at http://download.microsoft.com/download/5/8/4/5841bc1a-e864-4423-bb75-d4f3c18c0af5/visual%20basic%209.0%20overview.doc
I'm not going to make the edit myself immediately, because I'm a big ol' coward, but I might put it in in a couple of days if there are no objections here.
Sorry for the lack of knowing what I'm doing, but I don't know what I'm doing.  —Preceding unsigned comment added by 217.206.32.3 (talk) 10:15, 26 September 2008 (UTC)
thread_title:  Visual Basic 

message: I think the link between "everything is a string" and "Tcl supports Duck Typing" should be deleted if it cannot be succinctly and relevantly explained for those who do not have much or any TCL experience. 
On reading the Wikipedia entry on TCL Arrays it states that arrays cannot be treated as strings, The TCL wiki also says  similar the quote is:
:"It's also important to know that arrays have no implicit string representation other than their name".
Well, since everything is not a string, the phrase should be deleted. --Paddy (talk) 01:21, 8 July 2008 (UTC)
thread_title:  DT in TCL 

message: It is good English. --Paddy (talk) 17:05, 15 July 2009 (UTC)
thread_title: Oft cited

message: C# now has "dynamic member lookup" (See C_Sharp_(programming_language)#Dynamic_member_lookup), which I think should  be added to this article in the Implementations section. (I don't know if other .NET languages such as VB.NET also support this.) I have not used C# or .NET for a long while, so someone else may be able to give a better treatment of it than me. For now, I'll just ad d a link to that article. SimonTrew (talk) 09:34, 17 July 2009 (UTC)
thread_title:  C# implementation. 

message: Mainly because it was an example of templates rather than duck typing and did not, for example, succinctly give any more comparison info on templates vs duck typing except by wading through a template example. --Paddy (talk) 15:26, 24 January 2010 (UTC)
replies: text: Templates apply a duck test at compile-time. Also, the article now suggests that Java generics and C++ templates are similar. This is wrong, because they are fundamentally different in underlying mechanism and abilities, sharing only < > brackets. Generics use interfaces which need to be declared explicitly, and templates are independent of OOP. 89.189.179.81 (talk) 00:30, 25 January 2010 (UTC)

text: also, the statement Duck typing can also be more flexible in that only the methods actually called at run time need to be implemented, while templates require implementation of all methods that cannot be proven unreachable at compile time. is of low value because in the programmer can always statically add empty method which throws exception and get the same run-time behaviour as with interpreted languages. 89.189.179.81 (talk) 00:37, 25 January 2010 (UTC)
thread_title: C++ and D template example removed

message: SLIME is not a REPL  —Preceding unsigned comment added by 160.36.57.47 (talk) 00:29, 29 March 2011 (UTC)
thread_title:  SLIME 

message: Should there be a section on Google's language, Golang, and its use of Interfaces to establish duck typing? (I personally do not understand Golang enough to author it myself). Gavintlgold (talk) 01:19, 13 June 2011 (UTC)
replies: text: Is it an interface or is it Duck-typing? If the former, then it should not be included. --Paddy (talk) 06:46, 13 June 2011 (UTC)
thread_title:  Golang Section? 

message: Eric Lippert discussed the Wikipedia article on Duck typing today on his blog. The article and its comments may be useful for improving this article. Martijn Hoekstra (talk) 16:25, 3 January 2014 (UTC)
replies: text: And Phil Haack is weighing in too now. Martijn Hoekstra (talk) 12:18, 5 January 2014 (UTC)
replies: text: And code better too. Martijn Hoekstra (talk) 12:38, 5 January 2014 (UTC)
replies: text: And Haack again. Martijn Hoekstra (talk) 13:53, 7 January 2014 (UTC)
thread_title:  Eric Lippert 

message: This seems to be a point of contention (see this question on Stack Overflow: Duck typing, must it be dynamic?).  The article itself is contradictory - first stating that duck typing exists in static type languages, then contrasting it with the static-typed equivalents.
:Hi, it is not contradictory there. If you read the whole sentence it states only in "static" languages that have the ability to force type resolution at runtime. For those that don't, the comparisons are valid. --Paddy (talk) 13:46, 9 July 2014 (UTC)
thread_title:  Static Duck Typing 

message: It was nice to see the "dog" example in the C++ code, showing how it won't even compile and thus is commented out.  However, to my eyes, it seems that one of the major features of duck typing is to handle the "dog" case, yet the "dog" case and its results are missing from most of the examples (even the languages whose philosophy embraces duck typing).  I want to know what happens in Python when "in_the_forest(Dog())" is called.  Nothing?  Is an error printed?  Is an exception thrown?
216.64.156.5 (talk) 11:11, 6 October 2014 (UTC)
thread_title:  Most examples missing "dog" 

message: I know very little about F# but I do know that it supports both dynamic duck typing and structural types.  The desription of F# in the **In statically typed languages** section is simply wrong, since it claims F# checks at compile time, but also silly, since this article takes the position that Duck Typing is inherently dynamic and so F# should not be in that section if the claim about F# were accurate.  As it is, the language should have a mention in both this section and **Structural Types**. If nobody else corrects this, I will once I have learned more about F#.
Itsbruce (talk) 11:41, 14 January 2015 (UTC)
thread_title:  F# mention is wrong 

message: I had modified the article's introduction by replacing the previous
"duck typing is a style of typing"
with 
"duck typing is a layer of programming language and design rules on top of typing"
and elaborated the discrimination with two pairs of sentences highlighting
two key differences between ordinary typing and duck typing.
For this, the edit summary offered the explanation 
"Differentiate duck typing more clearly from type systems (which exist below duck typing in most languages)".
Paddy3118 reverted the modification without giving an explanation why.
So let me now offer some further explanation for my modification:
The previous version already referred to the article Type system.
The Type system article states "a type system is a collection of rules that assign a property called a type to the various constructs".
Indeed, duck-typed languages do also have an ordinary type system 
in that sense. For instance in Python, the expression type(obj)
will return the type of any object obj (so type("a") will give you 
the string type str).
Duck-typing is obviously something in addition to that.
It is this aspect of the confusion around the term duck typing
that my edit addressed.
I will now undo Paddy's revert.
Paddy3118, if you think my modification is inappropriate,
please explain here on the talk page why and let's discuss
this until we reach a consensus.
LutzPrechelt (talk) 18:26, 9 April 2015 (UTC)
thread_title:  "style of typing" vs. "layer of rules on top of typing" 

message: === The example "pseudo-code" is: ===
function calculate(a, b, c) => return (a + b)*c
example1 = calculate (1, 2, 3)
example2 = calculate ([1, 2, 3], [4, 5, 6], 2)
example3 = calculate ('apples ', 'and oranges, ', 3)
print to_string example1
print to_string example2
print to_string example3
=== And the result as written is: ===
If translated to Ruby or Python, for example, the result of the code would be:
9
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
apples and oranges, apples and oranges, apples and oranges,
=== But, the sum of [1,2,3] with [4,5,6] times 2, in my opinion is [10,14,18] and not [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]: ===
(a+b) --> [1,2,3] + [4,5,6] = [5,7,9]
(a+b)*c --> [5,7,9] * 2 = [10,14,18]
=== Am I right? ===
I believe you are wrong. This is confusing, and if taken literally, the + and * of python are indeed supposed to concatenate.
This is why, in my opinion, since duck uses the default implementation of the method, the example should show the concatenation and not the dot operations.  — Preceding unsigned comment added by Nadavge (talk • contribs) 13:24, 22 January 2016 (UTC)
thread_title:  Wrong Result 

message: I believe you are wrong. This is confusing, and if taken literally, the + and * of python are indeed supposed to concatenate.
This is why, in my opinion, since duck uses the default implementation of the method, the example should show the concatenation and not the dot operations.  — Preceding unsigned comment added by Nadavge (talk • contribs) 13:24, 22 January 2016 (UTC)
thread_title:  Am I right? 

message: Most of the examples includes "Duck" and "Person" or something similar, but both types include the same set of methods.
This can lead a reader to wonder what's the difference between DT and structural typing.
The examples should outline more of the fact that an object could only implement a subset of the duck behavior (as Alex Martelli noted in his original posthttps://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ "[...] check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need [...]"), which is one of the main difference with structural typing.
As an example, this can be done with a "string action" argument which tells the received object what to do.
Geod24 (talk) 13:45, 23 November 2015 (UTC)
thread_title:  Most examples are not representative of duck typing  

message: The article says:
"... suitability is determined by the presence of certain methods and properties (with appropriate meaning)".
However, compilers usually are unable to infer the "meaning" of anything. Shouldn't "meaning" be replaced with "signature" or possibly "signature and return type" (depending on the exact definition of signature used)?
O. Jacot-Descombes (talk) 16:57, 19 December 2015 (UTC)
thread_title:  Determination of suitability 

message: Hello fellow Wikipedians,
I have just modified  on Duck typing. Please take a moment to review my edit. If you have any questions, or need the bot to ignore the links, or the page altogether, please visit this simple FaQ for additional information. I made the following changes:
*Added archive https://web.archive.org/web/20081006075246/http://boo.codehaus.org:80/Duck+Typing to http://boo.codehaus.org/Duck+Typing
When you have finished reviewing my changes, please set the checked parameter below to true or failed to let others know (documentation at ).
Cheers.—InternetArchiveBot (Report bug) 11:14, 17 December 2016 (UTC)
thread_title:  External links modified 

message: The number and verbosity of examples on this page is far more than is required. I could find no other programming-related pages with this many examples. In fact, I believe that it does more harm than good, confusing the subject and making it more difficult to understand what duck typing actually is. Many of the examples are not well put together and either don't demonstrate duck typing at all or don't demonstrate it clearly. Especially damaging to their clarity is their verbosity, as mentioned above, particularly their usage of duck-related phrases. One example could be maintained by the community and be considered valuable, but twenty absolutely cannot. And as long as there are so many examples, it is an invitation for more to be added.
As such, I will be deleting the entire Language Support section. I'll link the revision below, and if a consensus is come to that this section should be restored, it can be found there. Perhaps in the future, a table or list of languages with support for duck typing can be added back, but even that may do more harm than good.
--CrackedP0t (talk) 04:25, 15 June 2017 (UTC)
replies: text: --CrackedP0t (talk) 04:30, 15 June 2017 (UTC)
thread_title:  Removal of the excessive examples 

message: Similarly to the Language Support section, the examples are incredibly verbose to the point of confusion. The output text is needlessly "humorous", and having two examples - in two different languages no less - merely complicates the issue. I'll replace them with a simple Python example, which of course can be edited as needed.  — Preceding unsigned comment added by CrackedP0t (talk • contribs) 04:48, 15 June 2017 (UTC)
thread_title:  Paring down examples 

message: This wiki page asserts that a limitation of protocols is that externally defined classes cannot be made to support the interface (without something like an adapter class). While this is true for many languages, it is not true for all. For example, the Swift programming language allows you to extend external classes to support an internal protocol.  — Preceding unsigned comment added by Jmacglashan (talk • contribs) 17:18, 6 September 2019 (UTC)
thread_title:  Cited limitation of protocols is only true for some languages